2 Gnu Octave |
Mit
save [Optionen] Dateiname [Variable(n)]
werden die Variablen in die Datei geschrieben, z.B.
A = [ 1 2 3 ; 4 5 6 ; 7 8 9 ]; B = [ 2 3 5 ; 7 11 13; 17 19 23 ]; save myfile.dat A B
Wird die Funktionsform save() verwandt, müssen Optionen, Dateiname und Variablen als Strings angegeben werden, z.B.
save("myfile.dat", "A", "B");
Die Variablennamen können vollständig oder als Pattern (Fragezeichen, Stern) angegeben werden.
Mit
load [Optionen] Dateiname [Variable(n)]
werden die Variablen aus der angegebenen Datei wieder eingelesen, z.B.
load myfile.dat
str = fileread(Dateiname);
x = csvread(Dateiname [ , Optionen ] ); csvwrite(Dateiname, Variable [ , Optionen ] );
Mit
[fid, msg] = fopen(Dateiname, Mode, [ , Architektur]);
wird eine Datei geöffnet. Als Mode können die aus C bekannten
Strings "r" (lesen), "w" (schreiben), "a" (anhängen), "r+" (erst
lesen, dann schreiben), "w+" (erst schreiben, dann lesen) bzw. "a+"
(erst anhängen, dann lesen) verwendet werden.
Die Architektur kann "ieee-le" (IEEE-konform und
little-endian), "ieee-be" (IEEE-konform und big-endian) oder
"native" (maschinenspezifisch) sein.
Der Rückgabewert fid ist ein Integerwert, der in den
nachfolgenden Funktionen genutzt werden kann.
Schlägt das Öffnen der Datei fehl, wird fid=-1
zurückgegeben, msg enthält dann eine Fehlermeldung.
Jede erfolgreich geöffnete Datei muss auch wieder geschlossen werden.
Mit
fclose(fid);
wird eine Datei wieder geschlossen. Die File-Kennung fid kann dann nicht mehr benutzt werden.
Die Funktionen stdin(), stdout() und
stderr() geben fid-Werte für die Standardeingabe,
Standardausgabe und Standardfehlerausgabe zurück. Diese Dateien und
die zugehörigen fid werden von Octave selbst verwaltet.
Im interaktiven Betrieb wird die Standardeingabe durch die
Funktionen zum Kommandozeilen-Editieren gefiltert, die
Standardausgabe durchläuft den Pager.
Die Standardfehlerausgabe durchläuft den Pager nicht, damit werden
Fehler und Prompt-Meldungen sofort dargestellt.
Mit
str = fgetl(fid [ , Länge ] ); str = fgets(fid [ , Länge ] );
wird eine Textzeile aus der Datei gelesen. Optional kann eine
maximale Länge für die Textzeile festgelegt werden.
Die Funktion fgetl() entfernt das abschließende Newline aus
dem zurückgegebenen String, fgets() belässt das Newline im
String.
Wenn kein Text mehr verfügbar ist, wird der numerische Wert -1 zurückgegeben.
Mit
nlines = fskipl(fid, [ , Anzahl ]);
werden Anzahl Zeilen aus einer Datei übersprungen (d.h. die Zeilen werden eingelesen, es erfolgt aber keine Verarbeitung). Ohne Angabe einer Anzahl wird eine Zeile übersprungen. Zurückgegeben wird die Anzahl an übersprungenen Zeilen. Mit der Anzahl-Angabe Inf werden alle Zeilen bis zum Dateiende übersprungen, dies kann zum Zeilen-Zählen benutzt werden.
Die Funktionen
[v1, v2,..., count, errmsg] = sscanf(String, Format, "C"); [val, count, errmsg, pos] = sscanf(String, Format, Größe); [v1, v2,..., count, errmsg] = fscanf(fid, Format, "C"); [val, count, errmsg, pos] = fscanf(fid, Format, Größe); [v1, v2,..., count, errmsg] = scanf(Format, "C"); [val, count, errmsg, pos] = scanf(Format, Größe);
können zum Einlesen von Daten aus einem String (sscanf()), aus einer Datei (fscanf()) oder aus der Standardeingabe (scanf()) verwendet werden.
Die erste Form jeder Funktion weist Skalare zu. In count wird gespeichert, wieviele Zuweisungen erfolgreich waren.
Die Größe kann eine einzelne Zahlenangabe sein, dann wird
ein Spaltenvektor geliefert. Größe Inf bedeutet, dass
soviele Daten wie möglich gelesen werden sollen. Besteht die
Größenangabe aus 2 Werten (der zweite Wert kann Inf
sein), geben diese die Zeilenanzahl und die Spaltenanzahl vor.
Der Wert count wird auf die Anzahl gelesener Werte
gesetzt.
Mit
[Wert, Anzahl] = fread(fid, Größe, Typ, Skip, Architektur);
werden Daten binär gelesen.
Das optionale Argument Größe gibt an, wieviele Elemente zu lesen sind. Angegeben wird entweder ein Skalar (Anzahl der Elemente im Spaltenvektor, Inf für größtmögliche Anzahl) oder ein Zeilenvektor mit zwei Elementen (Zeilenanzahl und Spaltenanzahl), bei dem die Spaltenanzahl Inf sein darf.
Das optionale Argument Typ gibt den Datentyp an:
"char" "char*1" |
Buchstabe |
"schar" "signed char" |
Buchstabe, vorzeichenbehaftet |
"uchar" "unsigned char" |
Buchstabe, vorzeichenlos |
"short" | Kurz-Integer, Größe ist plattformabhängig |
"int" | Integer, Größe ist plattformabhängig |
"long" | Lang-Integer, Größe ist plattformabhängig |
"int8" "integer*1" |
8-Bit-Integer mit Vorzeichen |
"int16" "integer*2" |
16-Bit-Integer mit Vorzeichen |
"int32" "integer*4" |
32-Bit-Integer mit Vorzeichen |
"int64" "integer*8" |
64-Bit-Integer mit Vorzeichen |
"ushort" "unsigned short" |
Kurz-Integer ohne Vorzeichen, Größe ist plattformabhängig |
"uint" "unsigned int" |
Integer ohne Vorzeichen, Größe ist plattformabhängig |
"ulong" "unsigned long" |
Lang-Integer ohne Vorzeichen, Größe ist plattformabhängig |
"uint8" | 8-Bit-Integer ohne Vorzeichen |
"uint16" | 16-Bit-Integer ohne Vorzeichen |
"uint32" | 32-Bit-Integer ohne Vorzeichen |
"uint64" | 64-Bit-Integer ohne Vorzeichen |
"float" | Gleitkommazahl, einfache Genauigkeit, Größe ist plattformabhängig |
"single" "float32" "real*4" |
32-Bit-Gleitkommazahl |
"double" "float64" "real*8" |
64-Bit-Gleitkommazahl |
Beim Einlesen kann automatisch konvertiert werden, die Typ-Angabe "int16=>int32" bewirkt beispielsweise, dass 16-Bit-Integer aus der Datei gelesen werden und als 32-Bit-Integer zurückgegeben werden.
Das Einlesen von Felder ist mit "Anzahl*Typ" möglich, z.B. "32*single".
Das optionale Argument Skip gibt an, wieviele Bytes nach jedem Element oder Block von Elementen übersprungen werden sollen.
Das optionale Argument Architektur kann "native", "ieee-be" oder "ieee-le" sein.
Die Daten werden als Wert zurückgegeben, Anzahl enthält die Anzahl der Werte.
Mit
feof(fid)
kann ermittelt werden, ob beim Lesen bereits das Dateiende gefunden wurde.
Mit
[Fehler, Text] = ferror(fid, [ , "clear" ] );
wird geprüft, ob ein Fehler im Zusammenhang mit fid aufgetreten ist.
Mit
fdisp(fid, Wert);
werden Ausgaben wie mit disp() vorgenommen, aber in die angegebene Datei.
Mit
fputs(fid, String);
wird die Textzeile in die Datei geschrieben.
puts() arbeitet ohne fid und schreibt in die Standardausgabe.
Mit
fprintf(fid, Format, Wert(e) ); printf(Format, Wert(e) );
werden Daten formatiert ausgegeben. Mit fprintf() erfolgt die Ausgabe in die angegebene Datei, mit printf() in die Standardausgabe. Der Format-String enthält konstanten Text und Platzhalter für die auszugebenden Werte, er ist im Abschnitt Werte anzeigen beschrieben.
Mit
string = sprintf(Format, Wert(e) );
wird nicht in eine Datei geschrieben sondern ein String erzeugt.
Enthalten die Werte Matrizen, so werden die Platzhalter
im Format-String zyklisch durchlaufen, bis alle
Matrix-Elemente ausgegeben wurden.
Enthalten die Werte mehrere Matrizen, so wird beim Wechsel
von einer Matriz zur nächsten nicht auf den ersten
Platzhalter zurückgesprungen sondern an der aktuellen Stelle
fortgesetzt.
Mit
Anzahl = fwrite(fid, Daten, Type, Skip, Architektur);
werden Daten geschrieben. Zurückgegeben wird die Anzahl der erfolgreich in die Datei geschriebenen Werte.
Die Matrix Daten enthält die zu schreibenden Daten. Die Daten werden Spalte für Spalte geschrieben.
Mit
ftell(fid)
kann die aktuelle Position innerhalb der Datei ermittelt werden, gezählt vom Dateianfang an.
Mit
fseek(fid, Position [ , Bezugspunkt ] );
kann die aktuelle Position gesetzt werden.
Für den Bezugspunkt sind folgende Werte möglich:
SEEK_SET | Dateianfang |
SEEK_CUR | aktuelle Position |
SEEK_END | Dateiende |
Mit
frewind(fid);
wird die aktuelle Position wieder auf den Dateianfang gesetzt.