Die folgenden Folien beinhalten Erluterungen die einen Inhalt

Die folgenden Folien beinhalten Erläuterungen, die einen Inhalt des Seminars ‚Fehler in der Schule – Schülerfehler‘ unterstützen sollen: Die Frage, wie sich systematisch auftretende Fehler erkennen lassen. Bei Klassengrößen zwischen 25 und 30, und vier bis sechs zu betreuenden Klassen, dürfte es kaum möglich sein, die Fehler, die jede einzelne Schülerin, jeder Schüler macht, im Blick zu behalten. Damit liegt es nahe, rechnergestützte Analyseverfahren zu nutzen und damit zugleich einen Blick auf die angewandten wissenschaftlichen Methoden psychologisch-pädagogischer Fehlerforschung zu richten. Die Folien sollen dabei behilflich sein, in Eigenarbeit die im Seminar besprochenen und erprobten Rechnen- und Analyseschritte nach zu vollziehen.

Ein erster, wichtiger Schritt der systematischen Analyse von Fehlern besteht in der Erfassung auftretender Fehler. Die detaillierte Feinauflösung dieser Erfassung kann nur gegenstands-, bzw. fachspezifisch diskutiert und erläutert werden. Im Prinzip gilt es, auftretende Fehler, unterschieden nach unterschiedlichen Fehlerarten (siehe dazu Weimer 1925), möglichst genau, bezogen auf den Ort ihres Auftretens, zu erfassen. Um dies an einem einfachen Beispiel kurz zu demonstrieren, wird auf der nächsten Folie ein Text vorgestellt, der als Diktat vorgegeben wird. Die hier nicht geleistete Aufgabe bestünde bei der Konzeption des Textes darin, unterschiedliche Komma-Setz-Regeln (der aktuelle Duden behandelt dieses Thema in den § 71 bis 79) an verschiedenen Stellen des Textes, idealer Weise möglichst mehrfach, einzubauen. Das mehrfache Auftreten erlaubt Hinweise auf irrtümliche Annahmen, wenn auf inkonsistente Art und Weise mit der Kommasetzung ungegangen wird.

Beispiel für einen zu analysierenden Text; der Fokus soll hier auf der Analyse von Komma-Fehlern liegen Text eines Diktats: „Peter, ein Junge aus der Nachbarschaft, traf seine Freundin Inge war gerade auf dem Weg zum Freibad, obwohl es regnete, recht kalt war und das Wetter damit nicht gerade zum Baden einlud. Peter, der einen dicken Pullover unter einer Regenjacke trug, fand das Badengehen daher auch eine recht merkwürdige Idee. Er schlug statt dessen vor, ins Kino zu gehen. Doch er wollte, sie nicht. […. . ]“

Die im Text zu analysierenden Fehler müssen in einem ersten Schritt markiert werden. Eine Möglichkeit wäre es, einfach alle erforderlichen Kommata durchzunummerieren. Wichtig ist es, ein möglichst einfach und sicher handhabbares Verfahren anzuwenden. Im Anschluss wird eine Datenmatrix erstellt, bspw. so wie in der folgenden Tabelle dargestellt. Für jede Schülerin und jeden Schüler wird mit Hilfe einer festzulegenden Codierung eingetragen, ob das erforderliche Komma richtig oder falsch gesetzt wurde oder ob die Passage gar nicht geschrieben wurde. Schüler. In Komma_01 Komma_02 Komma_03 Komma_04 Komma_05 Komma_06 Komma_07 Komma_08 Sahra 1 1 2 1 1 1 Beate 1 1 1 1 Jürgen 2 1 2 2 2 Günther 1 1 2 2 2 1 2 2 Dieter 1 1 2 2 0 1 …. Codierung: • 0 = Nicht bearbeitet • 1 = Richtig • 2 = Fehler

Wie lassen sich diese Daten nun auswerten? Zunächst ist zu betonen, dass es ganz unterschiedliche Fragen gibt, die an diese Daten gestellt werden können. Entsprechend gibt es mehr als eine Antwort auf die Frage nach der Vorgehensweise einer Auswertung. Hier wird eine dieser Fragen in einem exemplarischen Sinne hervorgehoben, um die Vorgehensweise vorzustellen und zu erläutern. Diese Frage lautet: Wie häufig tritt bei einem einzelnen Schüler/Schülerin ein bestimmter Fehler auf. Oder anders formuliert: Wie verteilen sich die Fehlerhäufigkeiten bezogen auf die Schüler/Schülerinnen und die verschiedenen Anlässe, einen Fehler zu machen?

Vorgestellt wird die Vorgehensweise an einem Datensatz, der (auch) im Seminar erhoben wurde: Daten des d 2 Aufmerksamkeits-Belastungstests (Brickenkamp 1981; 2002). Vereinfacht sind in diesem Satz die dabei erhobenen Daten wie folgt codiert: • 0 = Nicht bearbeitet • 1 = Richtig • 2 = Fehler Für jede der 14 Zeilen und allen Spalten des Tests wird eingetragen, ob das Zeichen richtig (= 1), fehlerhaft (= 2) oder gar nicht (= 0) bearbeitet wurde. Wie man sieht, wurden in dem hier gezeigten Abschnitt alle Zeichen richtig angestrichen.

Die Daten jedes Testbogens sind hier durch eine Leerzeile voneinander getrennt. Die hier gestellte Aufgaben lautet damit genauer: Wie häufig werden die Zeichen in der Zeile 1 und in der Spalte 1 fehlerhaft markiert? Wie häufig werden die Zeichen in der Zeile 2 und in der Spalte 1 fehlerhaft markiert? Etc.

Die Vorgehensweise zur Beantwortung dieser Frage lässt sich schematisch wie folgt darstellen: Gesamtdatensatz Gib mir nur die Daten der ersten Zeile, erste Spalte Gib mir Gibdie mir. Daten nur die Daten der zweiten Zeile, erste Spalte Teildatensatz Aus dem Gesamtdatensatz werden nacheinander Teildatensätze gebildet, die jeweils nur die Daten einer Zeile und einer Spalte enthalten.

SPSS/PASW bietet dafür unter Daten die Option Fälle auswählen

Klicken Sie diese Option an, öffnet sich das folgende Dialogfenster. Dort klicken Sie das Feld Falls Bedingung zutrifft Falls an, worauf das nächste Dialogfenster geöffnet wird, in dem Sie Zeile = 1 eingeben.

Die Datei sieht nun wie folgt aus: Es gibt nur noch die Daten aller Zeilen 1 und der Spalte 1 (S_01). Wie kann jetzt ermittel werden, wie oft in der Variable S_01 die Werte 0, 1 und 2 vorkommen? Dazu gibt es einen Befehl:

Unter Transformieren findet sich die Option Werte in Fällen zählen

Auf die bis zum diesem Punkt erläuterte Art und Weise ließen sich jetzt alle Spalten, aller Zeilen nacheinander analysieren. Doch: bei 14 Zeilen à 47 Spalten müsste 658 mal dieselbe Prozedur mit Mausklick und entsprechenden Eingaben durchgeführt werden — eine extrem mühsame ‚Eselsarbeit‘. Doch SPSS/PASW bietet, wie fast alle anderen Programme auch, Automatisierungsoptionen in Form sog. Syntax-Prozeduren oder Makros. Im folgenden wird die Nutzung dieser Optionen erläutert. Kurz: für jede Spezifikation per Mausklick und Tastatur wird im Hintergrund ein Programmier-Code generiert, der für gewöhnlich ‚unsichtbar‘ bleibt. Um diesen Code zu sehen müssen folgende Einstellungen vorgenommen werden:

Unter Bearbeiten finden Sie ganz unter die Optionen. Diese klicken Sie an.

Dann weiter zu Datei-Speicherstellen. Dort findet sich das Feld Sitzungs-Journal.

Hier kann die Option Syntax in Journal aufzeichnen aktiviert werden, wodurch automatisch im Hintergrund der Programmier-Code (nahezu) aller Arbeitsschritte aufgezeichnet wird. Ein Stufe tiefer kann festgelegt werden, ob die Aufzeichnung jeweils an die bereits vorhandenen Aufzeichnungen angehängt werden sollen, oder ob bei jedem Neustart des Programms die vorherigen Eintragungen gelöst und eine neue Aufzeichnung erstellt wird. Hier gilt es zu bedenken, dass bei Anhängen und komplexen Programmen relativ schnell vorhandene Speicherkapazitäten erreicht werden können, die Software dann auf unterschiedliche Speicherorte zugreift, was die Rechengeschwindigkeit erheblich reduzieren kann. Zu guter Letzt muss der Speicherort der Datei und der Name der Journal-Datei festgelegt werden – sofern nicht die Voreinstellung akzeptiert wird.

Um alle verfügbaren Befehle und Optionen, inklusive ihrer Spezifikationen, zu sehen und erläutert zu bekommen, findet sich unter Hilfe die Rubrik Befehlssyntax-Referenz.

Die folgenden Seiten erläutern nun Schritt für Schritt den Inhalt einer Syntax, mit der die Berechnungen der Fehlerhäufigkeit in Prozenten aller bearbeiteten Spalten und Zeilen durchgeführt werden kann. Die Befehle können dabei a) als solche direkt in das Programm eingegeben werden – was die Kenntnis dieser Befehle und ihrer Spezifikationen erfordert, oder b) die Befehle können per Mausklick und Tastatureingaben, wie weiter oben erläutert, so lange eingegeben werden, bis das Resultat den gewünschten Zielen entspricht, um dann den Programmier-Code aus dem Journal heraus zu kopieren und in das Programm einzufügen.

GET FILE='SPEICHER 01. sav' /KEEP= Zeile, S_01. EXECUTE. SELECT IF (Zeile = 1). EXECUTE. COUNT F_S = S_01 (2). EXECUTE. COUNT R_S = S_01 (1). EXECUTE. COUNT O_S = S_01 (0). EXECUTE. RECODE F_S R_S O_S (MISSING=0). EXECUTE. COMPUTE Fall = 1. CREATE Fall = CSUM(Fall). CREATE F_S = CSUM(F_S). CREATE R_S = CSUM(R_S). CREATE O_S = CSUM(O_S). EXECUTE. SORT CASES BY Fall (D). SELECT IF ($casenum = 1). EXECUTE. COMPUTE Proz_F = (100 * F_S) / (F_S + R_S). EXECUTE. Dieser Befehlsbereich öffnet die in Anführungszeichen gesetzte Datei und listet dabei durch den Zusatz KEEP nur die nach dem Gleichheitszeichen aufgeführten Variablen.

GET FILE='SPEICHER 01. sav' /KEEP= Zeile, S_01. EXECUTE. SELECT IF (Zeile = 1). EXECUTE. COUNT F_S = S_01 (2). EXECUTE. COUNT R_S = S_01 (1). EXECUTE. COUNT O_S = S_01 (0). EXECUTE. RECODE F_S R_S O_S (MISSING=0). EXECUTE. COMPUTE Fall = 1. CREATE Fall = CSUM(Fall). CREATE F_S = CSUM(F_S). CREATE R_S = CSUM(R_S). CREATE O_S = CSUM(O_S). EXECUTE. SORT CASES BY Fall (D). SELECT IF ($casenum = 1). EXECUTE. COMPUTE Proz_F = (100 * F_S) / (F_S + R_S). EXECUTE. Durch diesen Befehl SELECT IF alle Fälle aus der Datei entfernt, bei denen die Variable Zeile nicht den Wert 1 aufweist.

GET FILE='SPEICHER 01. sav' /KEEP= Zeile, S_01. EXECUTE. SELECT IF (Zeile = 1). EXECUTE. COUNT F_S = S_01 (2). EXECUTE. COUNT R_S = S_01 (1). EXECUTE. COUNT O_S = S_01 (0). EXECUTE. RECODE F_S R_S O_S (MISSING=0). EXECUTE. COMPUTE Fall = 1. CREATE Fall = CSUM(Fall). CREATE F_S = CSUM(F_S). CREATE R_S = CSUM(R_S). CREATE O_S = CSUM(O_S). EXECUTE. SORT CASES BY Fall (D). SELECT IF ($casenum = 1). EXECUTE. COMPUTE Proz_F = (100 * F_S) / (F_S + R_S). EXECUTE. In diesem Block werden durch den Befehl COUNT zunächst neue Variablen generiert, die den nach COUNT eingetragenen Namen erhalten. Hier also F_S (soll für Fehler in der Spalte stehen) R_S (richtig in der Spalte) und O_S (ohne Bearbeitung). Nach dem Gleichheitszeichen wird die Variable aufgeführt, in der die in Klammern stehenden Werte gezählt werden sollen.

GET FILE='SPEICHER 01. sav' /KEEP= Zeile, S_01. EXECUTE. SELECT IF (Zeile = 1). EXECUTE. COUNT F_S = S_01 (2). EXECUTE. COUNT R_S = S_01 (1). EXECUTE. COUNT O_S = S_01 (0). EXECUTE. RECODE F_S R_S O_S (MISSING=0). EXECUTE. COMPUTE Fall = 1. CREATE Fall = CSUM(Fall). CREATE F_S = CSUM(F_S). CREATE R_S = CSUM(R_S). CREATE O_S = CSUM(O_S). EXECUTE. SORT CASES BY Fall (D). SELECT IF ($casenum = 1). EXECUTE. COMPUTE Proz_F = (100 * F_S) / (F_S + R_S). EXECUTE. Der Befehl RECODE codiert in allen nachstehend aufgeführten Variablen, hier F_S, R_S und O_S, die in der nachfolgenden Klammer stehenden Werte um. In dem hier gezeigten Fall werden aus fehlenden Werten (MISSING) der Wert Null. Der Sinn dieses Befehls besteht darin, sicher zu stellen, dass keine fehlenden Werte vorliegen, weil in einem solchen Fall das gleich folgende Aufaddieren der Werte einer Spalte genau vor einem fehlenden Wert stoppen würde.

GET FILE='SPEICHER 01. sav' /KEEP= Zeile, S_01. EXECUTE. SELECT IF (Zeile = 1). EXECUTE. COUNT F_S = S_01 (2). EXECUTE. COUNT R_S = S_01 (1). EXECUTE. COUNT O_S = S_01 (0). EXECUTE. RECODE F_S R_S O_S (MISSING=0). EXECUTE. COMPUTE Fall = 1. CREATE Fall = CSUM(Fall). CREATE F_S = CSUM(F_S). CREATE R_S = CSUM(R_S). CREATE O_S = CSUM(O_S). EXECUTE. SORT CASES BY Fall (D). SELECT IF ($casenum = 1). EXECUTE. COMPUTE Proz_F = (100 * F_S) / (F_S + R_S). EXECUTE. In diesem Block sind zwei Befehle enthalten: COMPUTE und CREATE CSUM. Mit COMPUTE wird eine neue Variable generiert, die den Namen Fall erhält. Durch das Gleichheitszeichen wird allen Fällen dieser neuen Variable der danach angegebene Wert, hier 1, zugewiesen. Mit CREATE und CSUM werden alle Werte einer Spalte aufaddiert. Direkt nach CREATE wird die Zielvariable des Aufaddierens angeben.

GET FILE='SPEICHER 01. sav' /KEEP= Zeile, S_01. EXECUTE. SELECT IF (Zeile = 1). EXECUTE. COUNT F_S = S_01 (2). EXECUTE. COUNT R_S = S_01 (1). EXECUTE. COUNT O_S = S_01 (0). EXECUTE. RECODE F_S R_S O_S (MISSING=0). EXECUTE. COMPUTE Fall = 1. CREATE Fall = CSUM(Fall). CREATE F_S = CSUM(F_S). CREATE R_S = CSUM(R_S). CREATE O_S = CSUM(O_S). EXECUTE. SORT CASES BY Fall (D). SELECT IF ($casenum = 1). EXECUTE. COMPUTE Proz_F = (100 * F_S) / (F_S + R_S). EXECUTE. Nach dem Gleichheitszeichen steht CSUM für den Befehl Aufaddieren. Dahinter wird in Klammern die Variable angegeben, deren Werte aufaddiert werden sollen. Wie hier gezeigt, können die Werte einer Variable auch in derselben Variable aufaddiert werden. Zu beachten ist hier, dass dadurch die zuvor in der Variable enthaltenen Werte überschrieben werden und damit nicht mehr vorhanden sind!

GET FILE='SPEICHER 01. sav' /KEEP= Zeile, S_01. EXECUTE. SELECT IF (Zeile = 1). EXECUTE. COUNT F_S = S_01 (2). EXECUTE. COUNT R_S = S_01 (1). EXECUTE. COUNT O_S = S_01 (0). EXECUTE. RECODE F_S R_S O_S (MISSING=0). EXECUTE. COMPUTE Fall = 1. CREATE Fall = CSUM(Fall). CREATE F_S = CSUM(F_S). CREATE R_S = CSUM(R_S). CREATE O_S = CSUM(O_S). EXECUTE. SORT CASES BY Fall (D). SELECT IF ($casenum = 1). EXECUTE. COMPUTE Proz_F = (100 * F_S) / (F_S + R_S). EXECUTE. Mit SORT CASES BY werden anhand der nachfolgend genannten Variable, hier Fall, alle Fälle der Datei sortiert. Die Sortierung kann in zwei verschiedenen Richtungen Vorgenommen werden. Das in Klammern stehende D steht für descend (absteigend), ein A (arise) bewirkt eine aufsteigende Sortierung. Mit SELECT IF (siehe oben) wird hier durch $casenum auf die ganz links stehenden, automatisch generierten Zeilennummern abgehoben. Kurz: Es wir der erste, höchste Werte beibehalten.

GET FILE='SPEICHER 01. sav' /KEEP= Zeile, S_01. EXECUTE. SELECT IF (Zeile = 1). EXECUTE. COUNT F_S = S_01 (2). EXECUTE. COUNT R_S = S_01 (1). EXECUTE. COUNT O_S = S_01 (0). EXECUTE. RECODE F_S R_S O_S (MISSING=0). EXECUTE. COMPUTE Fall = 1. CREATE Fall = CSUM(Fall). CREATE F_S = CSUM(F_S). CREATE R_S = CSUM(R_S). CREATE O_S = CSUM(O_S). EXECUTE. SORT CASES BY Fall (D). SELECT IF ($casenum = 1). EXECUTE. COMPUTE Proz_F = (100 * F_S) / (F_S + R_S). EXECUTE. COMPUTE ist quasi der Universalbefehl für die unterschiedlichsten Berechnungen. Auch hier wird wieder direkt nach dem Befehl die Zielvariable angegeben, in die zu berechnenden Werte eingetragen werden sollen (hier Proz_F). Dann wird die Berechnug nach dem Gleichheitszeichen angegeben: 100 mal F_S, geteilt durch F_S plus R_S. Der einfache Dreisatz zur Berechnung der Fehlerprozente.

GET FILE='SPEICHER 01. sav' /KEEP= Zeile, S_01. EXECUTE. SELECT IF (Zeile = 1). EXECUTE. COUNT F_S = S_01 (2). EXECUTE. COUNT R_S = S_01 (1). EXECUTE. COUNT O_S = S_01 (0). EXECUTE. Auf Basis der bisherigen Erklärungen könnten jetzt für jede einzelne Berechnung die jeweils zu verändernden Werte – per Hand! – eingesetzt werden. Bspw. an diesen Stellen. RECODE F_S R_S O_S (MISSING=0). EXECUTE. Dies wäre etwas komfortabler, als mit Maus und Tastatur, aber immer noch recht mühsam. COMPUTE Fall = 1. CREATE Fall = CSUM(Fall). CREATE F_S = CSUM(F_S). CREATE R_S = CSUM(R_S). CREATE O_S = CSUM(O_S). EXECUTE. Die Lösung: Nutzung von Makros SORT CASES BY Fall (D). SELECT IF ($casenum = 1). EXECUTE. COMPUTE Proz_F = (100 * F_S) / (F_S + R_S). EXECUTE.

SPSS Makros Struktur Makro(grob)struktur Bedeutung, Funktion DEFINE !freq 1 (). Anfang der Makrodefinition mit Name „!FREQ 1“ und Argument „()“. descriptives var = alter fameink. Makroinhalt !ENDDEFINE. Ende der Makrodefinition !freq 1. Makroaufruf 31

Die variablen Teile des Programms werden in einem Makro durch „Platzhalter“ markiert und am Ende des Programms wird in der sog. Makroexpansion festgelegt, welche Werte die „Platzhalter“ in dem jeweiligen Programmdurchlauf annehmen sollen. /* MAKRO zum Einlesen der Beispieldateien DEFINE !EINLESENUEBUNGSTXT (PFAD = !charend ('§')/KLASSE = !charend('§')/PLATZ = !charend ('§') ). GET DATA /TYPE = TXT /FILE = !QUOTE (!PFAD) /DELCASE = LINE /DELIMITERS = "t " /ARRANGEMENT = DELIMITED /FIRSTCASE = 1 /IMPORTCASE = ALL /VARIABLES = V 1 F 7. 2 … Name des Makros: MAKRO_Einlesen_Uebungs. Dateien. sps 32

An Ende des Programmaufrufs werden die Werte, die durch „Platzhalter“ beim Programmdurchlauf einnehmen sollen definiert. !ENDDEFINE. !EINLESENUEBUNGSTXT PFAD = C: Dokumente und EinstellungenKlaus MehlEigene DateienDatenSE_Komplexe_DatenSchool performance_Klasse_A. txt § KLASSE = 'A' § PLATZ = C: Dokumente und EinstellungenKlaus MehlEigene DateienDatenSE_Komplexe_DatenSchool performance_Klasse_A. sav §. Name des Makros: MAKRO_Einlesen_Uebungs. Dateien. sps 33

Was bedeutet „TOKENS“? (engl. „Zeichen) Mit der Option !TOKENS werden die nächsten n Tokens im Makroaufruf dem Argument bzw. den Argumenten zugewiesen. Als Elemente zählen Variablen, Zahlen, Strings usw. : Beschreibung Beispiele Anzahl Tokens und Erläuterungen Variablenliste Var 1 Var 2 Var 3 3 (jeder Variablenname zählt als einzelnes Token) Werteliste 2 5 5. 22 0. 005 4 (jede Zahl zählt als einzelnes Token) Zeichenliste und A , b Kommas 3 (ein Komma wird als separates Token gezählt; Groß-/Kleinschreibung ist unerheblich) 34

Bei !TOKENS sind das Ausrufezeichen und die Anzahl n in einer Klammer wichtig. n entspricht positiven ganzzahligen Werten. Die Option !TOKENS-Option ist also nützlich, wenn die Anzahl der Token bekannt und konstant ist. Bei der Festlegung der Anzahl der Token sind Besonderheiten bei der „Zählweise“ von Token zu berücksichtigen: Beschreibung Beispiele Anzahl Tokens und Erläuterungen Anführungszeichen „Alter. . “ ‚cc 00 cd‘ 2 (Inhalte zwischen paarigen Anführungszeichen bzw. Hochkommatas zählen als ein Token) Zeichenkombinationen 11 A 2 (Zahl vor String) A 11 1 (String vor Zahl) 35

In dem Beispiel Makro MACRO_Einfaches_Beispiel wird nach den Namensargumenten Var 1 und Var 2 unmittelbar nach einem notwendigen =-Zeichen die Option !TOKENS(1) angegeben. Während der sog. Makroexpansion greift !AUSWERTUNG auf die Vorgaben zurück, die durch dieses Argument festgelegt wurden, nämlich eine Variable Var 1 und eine Variable Var 2 bereitzustellen. Die Information „ein Zeichen“ wird daher mit der Zuweisung zur gleichen Anzahl an Variablen zum Argument im Makroaufruf für die Analyse verknüpft. 36

Ein Beispiel: /* Einfaches erstes Beispiel für eine Makro-Programmierung DEFINE !Auswertung (VAR 1 = !TOKENS(1)/ VAR 2 = !TOKENS(1)). GET FILE='C: ProgrammeSPSS1993 US Sozialerhebung (Teilmenge). sav'. EXECUTE. GRAPH /SCATTERPLOTT(BIVAR)= !VAR 1 WITH !VAR 2. !ENDDEFINE. !AUSWERTUNG VAR 1=alter VAR 2= kinder. !AUSWERTUNG VAR 1=alter VAR 2= zeitung. !AUSWERTUNG VAR 1=einkom 91 VAR 2= alter. /* /* /* GRAPH /SCATTERPLOT(BIVAR)=alter WITH kinder /MISSING=LISTWISE. Name des Macros: MACRO_Einfaches_Beispiel 37

In diesem Makro „MACRO_Einfaches_Beispiel“ wird oben festgelegt, dass den beiden Platzhaltern VAR 1 und VAR 2 Zeichen im Umfang von einem Zeichen zugeordnet werden. In den Befehl zum Erstellen eines Scatterplotts werden dann keine Variablennamen, sondern nur die Platzhalter gesetzt. /* Einfaches erstes Beispiel für eine Makro-Programmierung DEFINE !Auswertung (VAR 1 = !TOKENS(1)/ VAR 2 = !TOKENS(1)). GET FILE='C: ProgrammeSPSS1993 US Sozialerhebung (Teilmenge). sav'. EXECUTE. Was an Stelle der Platzhalter bei jedem Durchlauf gesetzt werden soll, wird an dieser Stelle festgelegt. GRAPH /SCATTERPLOTT(BIVAR)= !VAR 1 WITH !VAR 2. !ENDDEFINE. !AUSWERTUNG VAR 1=alter VAR 2= kinder. !AUSWERTUNG VAR 1=alter VAR 2= zeitung. !AUSWERTUNG VAR 1=einkom 91 VAR 2= alter. /* /* /* GRAPH /SCATTERPLOT(BIVAR)=alter WITH kinder /MISSING=LISTWISE. 38

!CHAREND („Zeichen“) – Listen durch einzelnes Zeichen Mittels !CHAREND werden alle Tokens bis zu einem explizit festzulegenden Zeichen in einem Makroaufruf dem Argument zugewiesen und ausgeführt. Bei diesem Zeichen muss es sich um einzelnes Zeichen (String mit der Länge 1) handeln, das zwischen Hochkommata und in Klammern steht. Im Prinzip kann jedes beliebige Zeichen als Trennzeichen eingesetzt werden. Die SPSS Command Syntax Reference (2004) verwendet z. B. einen sog. Slash ‚/‘, um eine Trennung zu signalisieren. Dieser Slash hat also nichts mit dem Trennungszeichen zu tun, das zwischen zwei Argumentdefinitionen stehen muss; um eine Verwechslung zu vermeiden, wird empfohlen, als Zeichen keinen Slash, sondern ein beliebiges anderes Zeichen zu nehmen, bspw. ‚§‘. 39

Bei !CHAREND-Trennungszeichen ist ihre richtige Position absolut entscheidend. Eine falsche Position führt dazu, dass diese Positions- oder auch Namensargumente beim Aufruf des Makros falsche Token-Zusammenstellungen an SPSS übergeben. !CHAREND-Optionen sind v. a. bei positionalen Argumenten nützlich, können jedoch auch bei Namensargumenten eingesetzt werden. DEFINE !Beispiel 1 (key 1 = !CHAREND (‚§‘) / key 2 = !CHAREND (‚§‘) ). frequencies var = !key 1. descriptives var = !key 2. !ENDDEFINE. !Beispiel 1 KEY 1=familienstand ausbild abschluss geschl § KEY 2=alter §. 40

Ein Beispiel dazu: /* Einfaches zweites Beispiel für eine Makro-Programmierung DEFINE !Auswertung 1 (VAR 1 = !TOKENS(1)/ VAR 2 = !TOKENS(1)/VAR 3 =TOKENS(1)). GET FILE='C: ProgrammeSPSS1993 US Sozialerhebung (Teilmenge). sav'. EXECUTE. CROSSTABS /TABLES= !VAR 1 BY !VAR 2 BY !VAR 3 /FORMAT= AVALUE TABLES /CELLS= COUNT EXPECTED ROW COLUMN TOTAL /COUNT ROUND CELL. !ENDDEFINE. !AUSWERTUNG 1 VAR 1= famstand VAR 2 = leben VAR 3 = ethgr. Name des Macros: MACRO_Einfaches_Beispiel 2 41

Eine weitere Möglichkeit die hier Erwähnung finden soll ist die Verwendung sog. positionaler Argumente. Dabei wird, wie in dem folgenden Beispiel gezeigt, durch den Befehl !POS und dem Zusatz !TOKENS die Möglichkeit geschaffen, durch die Benennung der Platzhalter in Form von !1 oder !2 etc. das Programm anzuweisen, den ersten Wert (durch !1), den zweiten Wert (durch !2) etc. aus der Reihe der aufgelisteten Tokens in das Programm aufzunehmen. 42

/* Ein drittes Beispiel für eine Makro-Programmierung DEFINE !Auswertung 1 (!POS = !TOKENS(1)/!POS = !TOKENS(1)). GET FILE='C: ProgrammeSPSS1993 US Sozialerhebung (Teilmenge). sav'. EXECUTE. CROSSTABS /TABLES= !1 BY !2 BY !3 /FORMAT= AVALUE TABLES /CELLS= COUNT EXPECTED ROW COLUMN TOTAL /COUNT ROUND CELL. !ENDDEFINE. !AUSWERTUNG 1 famstand leben ethgr. !AUSWERTUNG 1 famstand todesstr sternzei. Name des Macros: MACRO_Einfaches_Beispiel 3 43

Die bislang vorgestellten Optionen erforderten es, dass die Anzahl und/oder Stellung der Platzhalter in der Definition festlag und bekannt war. Eine oft sehr nützliche Alternative zu dieser Option stellt der Befehl !CHAREND dar. Ein Beispiel für diesen bereits erläuterten Befehls folgt in dem nächsten Makro. Das besondere und neue an diesem nächsten Beispiel ist jedoch die Einführung von einer Schleife, einem sog. Loop. Was bewirken bzw. können solche Loops? Während in den bisherigen Beispielen für jeden Durchlauf des gestarteten Makros die dabei einzusetzenden Variablenwerte festgelegt werden mussten, werden bei einem Loop, genauer mit Hilfe eines sog. List-Processing-Loops eine (nahezu unbegrenzte) Menge von Werten vorgegeben, die dann automatisch der Reihe nach eingesetzt werden. 44

Schematisch lässt sich das Ganze so darstellen: Am Anfang eines solchen Loops steht der Befehl !DO gefolgt von der Bezeichnung des Platzhalters der einzusetzenden Variablen, bspw. !VAR, dann folgt der Befehl !IN und schließlich wird der Platz angegeben, an dem die einzusetzenden Werte oder Zeichen stehen, bspw. (LISTE). Das Ende der Schleife, des Loops wird durch den Befehl !DOEND angegeben: !DO !VAR !IN (LISTE) -Befehle – !DOEND 45

!DO !VAR !IN (LISTE) Select if (ALTER > !VAR) CROSSTABS /TABLES= Gehalt BY Hausbesitz /FORMAT= AVALUE TABLES /CELLS= COUNT EXPECTED ROW COLUMN TOTAL /COUNT ROUND CELL. LISTE = 30 40 50 60 !DOEND In dieser schematischen Darstellung würden also alle vier Werte aus der „Liste“ automatisch nacheinander in die Berechnung eingesetzt werden. 46

/* Ein fünftes Beispiel für eine Makro-Programmierung mit einer Schleife /* SET PRINTBACK=ON MPRINT=ON. DEFINE !Auswertung 3 (LISTE 1 = !CHAREND ('/')/ VAR 1 = !TOKENS(1)). GET FILE='C: ProgrammeSPSS1993 US Sozialerhebung (Teilmenge). sav'. EXECUTE. !DO !WERT 1 !IN (!LISTE 1). CROSSTABS /TABLES= !WERT 1 BY !VAR 1 /FORMAT= AVALUE TABLES /CELLS= COUNT EXPECTED ROW COLUMN TOTAL /COUNT ROUND CELL. !DOEND. !ENDDEFINE. !AUSWERTUNG 3 LISTE 1 = famstand beschäft partei sternzei / VAR 1 = todesstr. Name des Macros: MACRO_Einfaches_Beispiel 5 47

/* Ein fünftes Beispiel für eine Makro-Programmierung mit einer Schleife /* SET PRINTBACK=ON MPRINT=ON. DEFINE !Auswertung 3 (LISTE 1 = !CHAREND ('/')/ VAR 1 = !TOKENS(1)). GET FILE='C: ProgrammeSPSS1993 US Sozialerhebung (Teilmenge). sav'. EXECUTE. !DO !WERT 1 !IN (!LISTE 1). CROSSTABS /TABLES= !WERT 1 BY !VAR 1 /FORMAT= AVALUE TABLES /CELLS= COUNT EXPECTED ROW COLUMN TOTAL /COUNT ROUND CELL. !DOEND. !ENDDEFINE. !AUSWERTUNG 3 LISTE 1 = famstand beschäft partei sternzei alterhei geschw kinder alter gebmonat sternzei ausbild abschlus vaterab mutterab geschl ethgr einkom 91 einkbefr region ort einwohn partei wahl 92 einstell todesstr waffen gras religion leben kindid pille sexualkd prügel sterbehi zeitung tvstunde bigband blugrass country blues musicals klassik folk jazz opern rap hvymetal sport kultur tvshows tvnews tvpbs wissen 4 partner sexfreq wohnen soi gebjahr fameink schulab altergr politik region 4 verheira classic 3 jazz 3 rap 3 blues 3 /VAR 1 = todesstr. Name des Macros: MACRO_Einfaches_Beispiel 5 a 48

Was zunächst sehr kompliziert zu klingen scheint ist jedoch in den meisten Fällen eher einfach und sehr nützlich: Es lassen sich (nahezu) unbegrenzt viele Schleifen miteinander verschachteln: LOOP II Das nächste Makro demonstriert diese Möglichkeit. Zuerst wird das erste Zeichen der Liste 1 eingesetzt, dann das erste Zeichen der Liste 2, dann das zweite Zeichen der Liste 2 usw. Sind alle Zeichen der Liste 2 durch, wird das zweite Zeichen der Liste 1 eingesetzt usw. 49

/* Ein viertes Beispiel für eine Makro-Programmierung mit zwei ineinander /* verschachtelten Schleifen /* SET PRINTBACK=ON MPRINT=ON. GET FILE='C: ProgrammeSPSS1993 US Sozialerhebung (Teilmenge). sav'. EXECUTE. !DO !WERT 1 !IN (!LISTE 1). !DO !WERT 2 !IN (!LISTE 2). CROSSTABS /TABLES= !WERT 1 BY !WERT 2 /FORMAT= AVALUE TABLES /CELLS= COUNT EXPECTED ROW COLUMN TOTAL /COUNT ROUND CELL. !DOEND. Name des Macros: MACRO_Einfaches_Beispiel 4 DEFINE !Auswertung 3 (LISTE 1 = !CHAREND ('/')/ LISTE 2 = !CHAREND ('§')). !ENDDEFINE. !AUSWERTUNG 3 LISTE 1 = famstand beschäft partei / LISTE 2 = todesstr sternzei §. 50

Eine weitere Möglichkeit der Schleifenkonstruktion ist die eines sog. Index-Loop. Beim Index-Loop wird bei einem Zähler mit dem Wert 1 gestartet und im Allgemeinen in n+1 -Schritten solange wiederholt, bis ein bestimmter (Index-) Wert erreicht ist. !DO !var = (Anfang) !TO (Ende) [optional: !BY (Schritt)] - Befehle !DOEND Das folgende Makro zeigt ein Beispiel für einen solchen Index. Loop, mit dem sechs zusätzliche Variablen mit den Namen neu 1 var bis neu 6 var generiert werden: Im Anschluss an dieses Beispiel wird der bislang noch nicht eingeführte Befehl !CONCAT erläutert. 51

/* Ein sechstes Beispiel für eine Makro-Programmierung mit einer Index-Schleife /* SET PRINTBACK=ON MPRINT=ON. DEFINE !LOOP 1 (key 1 = !TOKENS(1)/key 2 = !TOKENS(1)). !DO !i = !KEY 1 !TO !KEY 2. COMPUTE !CONCAT (neu, !i, var) = normal (1). !DOEND. !ENDDEFINE. !LOOP 1 Key 1 = 1 Key 2 = 6. Name des Macros: MACRO_Einfaches_Beispiel 6 52

Stringfunktionen und einige ihrer Variationsmöglichkeiten Syntax für Strings Funktion, Rückmeldung und Beispiel !LENGTH (String) Länge des angegebenen Strings. Bsp. : !LENGTH(Hello). Ergebnis: 5 Aneinanderkettung der zusammenzuführenden Strings. Bsp. : !CONCAT(hel, lo). Ergebnis: Hello Das Argument wird in Anführungszeichen gesetzt. Bsp. : !QUOTE(Hello). Ergebnis: „Hello“ !CONCAT (String 1, String 2, …) !QUOTE (String) !SUBSTR (String, FROM, [Länge]) Abschnitt des Strings, der ab FROM startet und bei nicht festgelegter Länge bis zum Stringende geht Bsp. : !SUBSTR(Hello, 3) Ergebnis: „LLO“ 53

Eine weitere Anwendung von Makros: Das Zusammenführen von ausgesuchten Variablen aus verschiedenen Dateien: • Dazu müssen die einzelnen Dateien nacheinander aufgerufen werden • Dabei werden nur die Variablen geladen, die von Interesse sind • Die Auswahl der Variablen wird in einer (Zwischen-)Datei abgelegt • Der nächste Datensatz wird aufgerufen, die Variablen ausgesucht etc. • Der Datensatz wird mit den Daten in der Zwischendatei verbunden • Wenn alle Datei „durchkämmt“ sind, ist der Datensatz „fertig“ Beispiel: 54

/* Ein siebentes Beispiel für eine Makro-Programmierung zum Zusammenfügen verschiedener Datensätze /* SET PRINTBACK=ON MPRINT=ON. Name des Macros: MACRO_Einfaches_Beispiel 7 GET FILE='C: Dokumente und EinstellungenKlaus MehlEigene DateienDatenSE_Komplexe_Daten1991 US Sozialerhebung. sav' /KEEP = kinder. EXECUTE. COMPUTE YEAR = 1991. FORMATS YEAR (F 1. 0). EXECUTE. SAVE OUTFILE='C: Dokumente und EinstellungenKlaus MehlEigene DateienDatenSE_Komplexe_DatenSPEICHER 01. sav'. EXECUTE. DEFINE !Zusammen 1 (PFAD = !CHAREND ('/')/ WERT 1 = !CHAREND ('§')). GET FILE= !QUOTE(!PFAD) /KEEP = kinder. EXECUTE. COMPUTE YEAR = !WERT 1. FORMATS YEAR (F 1. 0). EXECUTE. ADD FILES /FILE=* /FILE='C: Dokumente und EinstellungenKlaus MehlEigene DateienDatenSE_Komplexe_DatenSPEICHER 01. sav'. EXECUTE. SAVE OUTFILE='C: Dokumente und EinstellungenKlaus MehlEigene DateienDatenSE_Komplexe_DatenSPEICHER 01. sav'. EXECUTE. /* Alternative: MATCH !ENDDEFINE. !Zusammen 1 PFAD = C: Dokumente und EinstellungenKlaus MehlEigene DateienDatenSE_Komplexe_Daten1993 US Sozialerhebung (Teilmenge). sav / WERT 1 = 1993 §. !Zusammen 1 PFAD = C: Dokumente und EinstellungenKlaus MehlEigene DateienDatenSE_Komplexe_DatenMehl Fake. sav / WERT 1 = 2000 §. 55

/* Ein achtes Beispiel für eine Makro-Programmierung zum Berechnen des Mittelwertes /* SET PRINTBACK=ON MPRINT=ON. GET FILE='C: Dokumente und EinstellungenKlaus MehlEigene DateienDatenSE_Komplexe_DatenSPEICHER 01. sav'. EXECUTE. SELECT IF (YEAR = 2000). EXECUTE. COMPUTE Fall = 1. EXECUTE. CREATE SUMFall = CSUM(Fall). EXECUTE. CREATE SUMChild = CSUM(Kinder). EXECUTE. SORT CASES BY SUMfall (D). SELECT IF ($casenum = 1). COMPUTE MEANChild = SUMChild/SUMFall. EXECUTE. RENAME VARIABLES (MEANChild = MEANChild 2000). EXECUTE. SAVE OUTFILE='C: Dokumente und EinstellungenKlaus MehlEigene DateienDatenSE_Komplexe_DatenSPEICHER 02. sav' / KEEP= MEANChild 2000. EXECUTE. /* HIER BEGINNT DAS MAKRO !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Name des Macros: MACRO_Einfaches_Beispiel 8; Fortsetzung nächste Seite ↓ 56

DEFINE !Mittelwerte 1 (LISTE 1 = !CHAREND ('/')). !DO !Jahr !IN (!LISTE 1). GET FILE='C: Dokumente und EinstellungenKlaus MehlEigene DateienDatenSE_Komplexe_DatenSPEICHER 01. sav'. EXECUTE. SELECT IF (YEAR = !Jahr). EXECUTE. COMPUTE Fall = 1. EXECUTE. CREATE SUMFall = CSUM(Fall). CREATE SUMChild = CSUM(Kinder). SORT CASES BY SUMFall (D). SELECT IF ($casenum = 1). COMPUTE MEANChild = SUMChild/SUMFall. EXECUTE. RENAME VARIABLES (MEANChild = !CONCAT(MEANChild, !Jahr)). EXECUTE. MATCH FILES /FILE=* /FILE='C: Dokumente und EinstellungenKlaus MehlEigene DateienDatenSE_Komplexe_DatenSPEICHER 02. sav' /DROP = Fall, SUMChild, YEAR, Kinder. EXECUTE. SAVE OUTFILE='C: Dokumente und EinstellungenKlaus MehlEigene DateienDatenSE_Komplexe_DatenSPEICHER 02. sav'. EXECUTE. !DOEND. SAVE OUTFILE='C: Dokumente und EinstellungenKlaus MehlEigene DateienDatenSE_Komplexe_DatenSPEICHER 02. sav'. EXECUTE. !ENDDEFINE. !Mittelwerte 1 LISTE 1 = 1993 1991 /. 57

Die schematische Logik dieser Variante: Ursprungs-Datei • Auswahl relevanter Variablen • Berechnungen 12345678 Datei als Zwischenablage 12345678 98765432 Match Add Ziel-Datei 58

Wie lassen sich nun aus diese Art und Weise zusammengestellte Dateien weiterverarbeiten? Eine Möglichkeit, die ausführlicher, d. h. nicht mit der maximal möglichen Eleganz vorgestellt wird (weil noch zu komplex), ist das Berechnen von Mittelwerten: ∑ aller Werte : Anzahl der Werte Dazu ist es wichtig, die Funktionen Lag und Lead einzuführen: X Lag Lead 198 . 220 198 305 220 470 305 59

Name der Syntax: Syntaxbeispiel_Zählen_Sortieren_Auswählen Anmerkungen: COMPUTE Fall = 1. EXECUTE. /* ALTERNATIVE: COMPUTE Fall = $casenum. /* SELECT IF (Kinder = 4). IF ($casenum >1) Fall = Lag(Fall, 1) + Fall. EXECUTE. SORT CASES BY Fall (D). /* ALTERNATIV: (A) EXECUTE. SELECT IF ($casenum = 1). EXECUTE. COUNT Anzahl_2 = var 001 (2). EXECUTE. • Bitte vergleichen mit „create“ • „$casenum“ verweist auf die Fallnummern am linken Rand der Datenmaske • Lag(XYZ, 1) = die Zahl gibt den Abstand an: 1 = nächste Zeile; 2 = übernächste Zeile • „D“ = down „A“ = up • Setzt in eine Variable Anzahl_2 die Anzahl der Werte ‚ 2‘ der Variable var 001 ein (siehe auch Syntax 60 Befehlsdefinitionen)

Häufigkeiten zählen mit dem Befehl „COUNT“: Allgemeine Syntax: COUNT Zielvariable = Quellvariable(n) (Werteliste) Zu zählende Werte Beschreibung Einzelwerte 12345 Alle fehlenden Werte missing Systemdefinierte fehlende Werte sysmis Wertebereiche: … bis … 5 thru 10 Wertebereiche: kleinster bis … lowest thru 0 Wertebereiche: … bis größter Wert 100 thru highest 61

ACHTUNG, ganz WICHTIG!!! CREATE Function keywords: CREATE bezieht sich wie folgt auf die Spalten: CSUM Cumulative sum DIFF Difference FFT Fast Fourier transform IFFT Inverse fast Fourier transform LAG Lag LEAD Lead MA Centered moving averages PMA Prior moving averages RMED Running medians SDIFF Seasonal difference T 4253 H Smoothing 62

ACHTUNG, ganz WICHTIG!!! COMPUTE bezieht sich dagegen fast – aber leider nicht immer – wie folgt auf die Zeilen: Befehl COMPUTE 63

COMPUTE target variable=expression Example COMPUTE newvar 1=var 1+var 2. COMPUTE newvar 2=RND(MEAN(var 1 to var 4). COMPUTE logical. Var=(var 1>5). STRING new. String (A 10). COMPUTE new. String=CONCAT((RTRIM(string. Var 1), string. Var 2). Functions and operators available for COMPUTE are described in “Transformation Expressions” on p. 44. ABS(arg) Absolute value. ABS(SCALE) is 4. 7 when SCALE equals 4. 7 or – 4. 7. RND(arg) Round the absolute value to an integer and reaffix the sign. RND(SCALE) is – 5 when SCALE equals – 4. 7. TRUNC(arg) Truncate to an integer. TRUNC(SCALE) is – 4 when SCALE equals – 4. 7. MOD(arg, arg) Remainder (modulo) of the first argument divided by the second. When YEAR equals 1983, MOD(YEAR, 100) is 83. SQRT(arg) Square root. SQRT(SIBS) is 1. 41 when SIBS equals 2. EXP(arg) Exponential. e is raised to the power of the argument. EXP(VARA) is 7. 39 when VARA equals 2. LG 10(arg) Base 10 logarithm. LG 10(VARB) is 0. 48 when VARB equals 3. LN(arg) Natural or Naperian logarithm (base e). LN(VARC) is 2. 30 when VARC equals 10. LNGAMMA(arg) Logarithm (base e) of complete Gamma function. ARSIN(arg) Arcsine. (Alias ASIN. ) The result is given in radians. ARSIN(ANG) is 1. 57 when ANG equals 1. ARTAN(arg) Arctangent. (Alias ATAN. ) The result is given in radians. ARTAN(ANG 2) is 0. 79 when ANG 2 equals 1. SIN(arg) Sine. The argument must be specified in radians. SIN(VARD) is 0. 84 when VARD equals 1. COS(arg) Cosine. The argument must be specified in radians. COS(VARE) is 0. 54 when VARE equals 1. 64

COMPUTE - Befehle SUM(arg list) Sum of the nonmissing values across the argument list. MEAN(arg list) Mean of the nonmissing values across the argument list. SD(arg list) Standard deviation of the nonmissing values across the argument list. VARIANCE(arg list) Variance of the nonmissing values across the argument list. CFVAR(arg list) Coefficient of variation of the nonmissing values across the argument list. The coefficient of variation is the standard deviation divided by the mean. MIN(arg list) Minimum nonmissing value across the argument list. MAX(arg list) Maximum nonmissing value across the argument list. The following arithmetic operators are available: + Addition – Subtraction * Multiplication / Division ** Exponentiation 65

Aufgabe 1: Stellen Sie eine neue Datei zusammen, die Variablen enthält, die Anzahl von 1, 2 und 3 Kindern in den Dateien • 1991 US Sozialerhebung. sav • 1993 US Sozialerhebung (Teilmenge). sav • Mehl Fake. sav wiedergeben: oder: Ein_Kind_1991 Zwei_Kind_1991 Drei_Kind_1991 29 4 34 Jahr Ein_Kind Zwei_Kinder Drei_Kinder 1991 29 4 34 1993 …. 66

Probleme: Wie muss die Grobstruktur des Programms aussehen? Makrodefinition (2 Loops) Erste Schleife (Jahr) Zweite Schleife (Anzahl Kinder) • Variablenauswahl, Werteselektion • Berechnen • Sortieren • Renamen • Matchen (Variablen hinzufügen) • Im Zwischenspeicher ablegen Ende der ersten Schleife • Adden (cases hinzufügen) • Um cases erweiterte Datei ablegen Ende der zweiten Schleife Makroende 67

Regeln für die Vergabe von Variablennamen: • Variablennamen können aus Buchstaben und Ziffern gebildet werden. Erlaubt sind ferner die Sonderzeichen _ (underscore), . (Punkt) sowie die Zeichen @, #, $ Nicht erlaubt sind Leerzeichen sowie spezifische Zeichen, wie !, ? , » und *. • Der Variablenname muss mit einem Buchstaben beginnen. Erlaubt ist ferner das Sonderzeichen @. • Das letzte Zeichen darf kein Punkt und sollte kein _ (underscore) sein, um Konflikte mit speziellen Variablen, die von SPSS-Prozeduren angelegt werden, zu vermeiden. • Der Variablenname darf (ab der Version 12) max 64 Zeichen lang sein. • Variablennamen sind nicht case-sensitive, d. h. die Groß- und Kleinschreibung ist nicht relevant. • Variablennamen dürfen nicht doppelt vergeben werden. • Reservierte Schlüsselwörter können nicht als Variablennamen verwendet werden. Zu den reservierten Schlüsselwörtern zählen: ALL, AND, BY, EQ, GE, GT, LE, LT, NE, NOT, OR, TO, WITH. Beispiele für ungültige Variablennamen: 1 mal 1 Bühl&Zöfel Stand 94 Wagen! 68

Kommen wir jetzt auf das Eingangs-Beispiel d² - Test zurück: • Wie lässt sich für jedes Feld der %-Anteil einer fehlerhaften Bearbeitung berechnen? • Ein erster Schritt wäre es, eine Datei mit allen Fällen der einzelnen Dateien zusammenzustellen, die vollständige Id‘s enthält • Dann, Spalte für Spalte, alle Zeilen einzeln aller Bearbeitungen zu betrachten und zusammenzuzählen, wie oft dort eine 1 (fehlerfrei) oder eine 2 (Fehler) eingetragen wurde. • Schließlich wird die Summe aller Werte > 1 und die Summe aller Werte = 2 ermittelt • Auf dieser Grundlage ergibt sich dann der %-Anteil 69

/* Makro zum Ersetzen/Ausfüllen der Id-Nummern /* SET PRINTBACK=ON MPRINT=ON. CD 'C: Dokumente und EinstellungenKlaus MehlEigene DateienDatenD_Zwei'. ERASE FILE = 'SPEICHER 01. sav'. DEFINE !Vervollstaendigen (LISTE = !CHAREND ('/')). !DO !Datei !IN (!LISTE). GET FILE= !Datei. EXECUTE. RECODE ID (MISSING=0). EXECUTE. IF ((Zeile > 0) & ($casenum > 1)) Id = Id + Lag(Id, 1). EXECUTE. ADD FILES /FILE=* /FILE='SPEICHER 01. sav'. EXECUTE. SAVE OUTFILE= 'SPEICHER 01. sav'. EXECUTE. !DOEND. !ENDDEFINE. !Vervollstaendigen Liste = 'Daten-Mi-10. sav' 'Daten-Mi-11. sav' 'Daten-Mi-12. sav' 'Daten-Mi-13. sav' 'Daten-Mi-14. sav' 'Daten-Mi-15. sav' 'Daten-Mi-16. sav' 'Daten-Mi-17. sav' 'Daten-Mi-18. sav' 'Daten-Mo-01. sav' 'Daten-Mo-02. sav' /. 70

Anhand dieser Datei aller Bearbeitungen gilt es jetzt eine Struktur wie die folgende zu erstellen: Spalte S_01, Zeile 1 des ersten Testteilnehmers Spalte S_01, Zeile 1 des zweiten Testteilnehmers Datei der Daten aller Bearbeitungen Spalte S_01, Zeile 1 des letzten Testteilnehmers 71

Sind auf diese Art und Weise die Werte Zeile 1, Spalte S_01 zusammengestellt, gilt es die Werte ‚ 1‘ und ‚ 2‘ zu erfassen und zusammenzuzählen, etwa auf diesem Weg: COUNT F_S = S_01 (2). EXECUTE. COUNT R_S = S_01 (1). EXECUTE. COUNT O_S = S_01 (0). EXECUTE. S_01 F_S R_S O_S 0 . . 1 1 . 0 . . 1 2 1 . . 72

Um die Summe der F_S, R_S und O_S zusammenzuaddieren gibt es – wie immer – verschiedene Wege. Zunächst müssen die Missing Values in die Werte ‚ 0‘ umkodiert werden: RECODE F_S R_S O_S (MISSING=0). EXECUTE. Dann kann mit dem Befehl: CREATE Fall = CSUM(Fall). CREATE F_S = CSUM(F_S). CREATE R_S = CSUM(R_S). CREATE O_S = CSUM(O_S). EXECUTE. oder 73

Mit der Anweisung: IF ($casenum > 1) F_S = LAG(F_S, 1) + F_S. EXECUTE. gearbeitet werden. Ihnen ist sicher das Aufaddieren einer Variablen ‚Fall‘ aufgefallen – die zuvor auf den Wert ‚ 1‘ gesetzt wurde. Diese Variable dient dazu, die letzte Zeile in der Datei zu bestimmen, um den Sortierbefehl richtig anwenden zu können. Dieser Befehl lautet: S_01 F_S R_S O_S 0 . . 1 1 . 0 . . 1 2 1 . . 74

SORT CASES BY Fall (D). SELECT IF ($casenum = 1). EXECUTE. Mit der ersten Zeile werden die Werte von Fall absteigend (D) sortiert, so dass die höchsten Werte alle in der ersten Zeile stehen. Dann wird die erste Zeile ausgewählt – die anderen sind in diesem Moment verschwunden! Die gewünschte Berechnung erfolgt durch diesen Befehl: COMPUTE Proz_F = (100 * F_S) / (F_S + R_S). EXECUTE. Damit haben wir den Prozentanteil der Fehler beim Bearbeiten der ersten Zeile der Spalte S_01 berechnet. 75

Damit ist aber noch nicht das Ende erreicht. Um zu markieren, welchen Wert wir jetzt berechnet haben, nennen wir die Variable Proz_F um in die Variable Proz. F_S_01 – die Variable Proz_F ist damit nicht mehr im Bestand der Datei!! Schließlich speichern wir in einer Zwischendatei den berechneten Wert und werfen mit DROP alle Variablen raus, die wir nicht benötigen: RENAME VARIABLES (Proz_F = !CONCAT(Proz. F_, !Spalte)). EXECUTE. MATCH FILES /FILE=* /FILE='SPEICHER 02. sav' /DROP = Id, Fall, R_S, O_S, F_S, !Spalte. EXECUTE. SAVE OUTFILE='SPEICHER 02. sav'. EXECUTE. 76