There are two distinct classes of input and output functions. The first set are modeled after the functions available in MATLAB. The second set are modeled after the standard I/O library used by the C programming language and offer more flexibility and control over the output.
When running interactively, Octave normally sends any output intended
for your terminal that is more than one screen long to a paging program,
such as less or more. This avoids the problem of having a
large volume of output stream by before you can read it. With
less (and some versions of more) you can also scan forward
and backward, and search for specific items.
Normally, no output is displayed by the pager until just before Octave
is ready to print the top level prompt, or read from the standard input
(for example, by using the fscanf or scanf functions).
This means that there may be some delay before any output appears on
your screen if you have asked Octave to perform a significant amount of
work with a single command statement. The function fflush may be
used to force output to be sent to the pager (or any other stream)
immediately.
You can select the program to run as the pager by setting the variable
PAGER, and you can turn paging off by setting the value of the
variable page_screen_output to 0.
more
toggles the current state.
"less", "more", or
"pg", depending on what programs are installed on your system.
See section Installing Octave.
When running interactively, Octave sends any output intended for your
terminal that is more than one screen long to the program named by the
value of the variable PAGER.
page_screen_output is nonzero, all output
intended for the screen that is longer than one page is sent through a
pager. This allows you to view one screenful at a time. Some pagers
(such as less---see section Installing Octave) are also capable of moving
backward on the output. The default value is 1.
page_output_immediately is nonzero, Octave sends
output to the pager as soon as it is available. Otherwise, Octave
buffers its output and waits until just before the prompt is printed to
flush it to the pager. The default value is 0.
input.
Since Octave normally prints the value of an expression as soon as it has been evaluated, the simplest of all I/O functions is a simple expression. For example, the following expression will display the value of pi
pi
-| pi = 3.1416
This works well as long as it is acceptable to have the name of the
variable (or `ans') printed along with the value. To print the
value of a variable without printing its name, use the function
disp.
The format command offers some control over the way Octave prints
values with disp and through the normal echoing mechanism.
3^2 + 4^2
is evaluated, the value of ans is 25.
disp ("The value of pi is:"), disp (pi)
-| the value of pi is:
-| 3.1416
Note that the output from disp always ends with a newline.
disp and Octave's
normal echoing mechanism. Valid options are listed in the following
table.
short
long
long e
short e
3.14e+00.
long E
short E
3.14159265358979E+00.
free
none
bank
+
hex
pi when printed in hex format is 400921fb54442d18.
This format only works for numeric values.
bit
pi is
01000000000010010010000111111011 01010100010001000010110100011000(shown here in two 32 bit sections for typesetting purposes) when printed in bit format on a workstation which stores 8 byte real values in IEEE format with the least significant byte first. This format only works for numeric types.
By default, Octave will try to print numbers with at least 5 significant figures within a field that is a maximum of 10 characters wide.
If Octave is unable to format a matrix so that columns line up on the decimal point and all the numbers fit within the maximum field width, it switches to an `e' format.
If format is invoked without any options, the default format
state is restored.
print_answer_id_name is nonzero, variable
names are printed along with the result. Otherwise, only the result
values are printed. The default value is 1.
Octave has three functions that make it easy to prompt users for
input. The input and menu functions are normally
used for managing an interactive dialog with a user, and the
keyboard function is normally used for doing simple debugging.
input ("Pick a number, any number! ")
prints the prompt
Pick a number, any number!
and waits for the user to enter a value. The string entered by the user is evaluated as an expression, so it may be a literal constant, a variable name, or any other valid expression.
Currently, input only returns one value, regardless of the number
of values produced by the evaluation of the expression.
If you are only interested in getting a literal string value, you can
call input with the character string "s" as the second
argument. This tells Octave to return the string entered by the user
directly, without evaluating it first.
Because there may be output waiting to be displayed by the pager, it is
a good idea to always call fflush (stdout) before calling
input. This will ensure that all pending output is written to
the screen before your prompt. See section Input and Output.
keyboard function is executed, Octave prints a prompt and waits
for user input. The input strings are then evaluated and the results
are printed. This makes it possible to examine the values of variables
within a function, and to assign new values to variables. No value is
returned from the keyboard function, and it continues to prompt
for input until the user types `quit', or `exit'.
If keyboard is invoked without any arguments, a default prompt of
`debug> ' is used.
For both input and keyboard, the normal command line
history and editing functions are available at the prompt.
Octave also has a function that makes it possible to get a single character from the keyboard without requiring the user to type a carriage return.
x = kbhit ();
will set x to the next character typed at the keyboard as soon as it is typed.
The save and load commands allow data to be written to and
read from disk files in various formats. The default format of files
written by the save command can be controlled using the built-in
variables default_save_format and save_precision.
Note that Octave can not yet save or load structure variables or any user-defined types.
save command are listed in the following table. Options that
modify the output format override the format specified by the built-in
variable default_save_format.
-ascii
-binary
-float-binary
-mat-binary
-save-builtins
The list of variables to save may include wildcard patterns containing the following special characters:
?
*
[ list ]
! or ^, match all characters except those
specified by list. For example, the pattern `[a-zA-Z]' will
match all lower and upper case alphabetic characters.
Except when using the MATLAB binary data file format, saving global variables also saves the global status of the variable, so that if it is restored at a later time using `load', it will be restored as a global variable.
The command
save -binary data a b*
saves the variable `a' and all variables beginning with `b' to the file `data' in Octave's binary format.
There are two variables that modify the behavior of save and one
that controls whether variables are saved when Octave exits unexpectedly.
save command.
It should have one of the following values: "ascii",
"binary", float-binary, or "mat-binary". The
initial default save format is Octave's text format.
save,
you may specify a list of variables and load will only extract
those variables with names that match. For example, to restore the
variables saved in the file `data', use the command
load data
Octave will refuse to overwrite existing variables unless you use the option `-force'.
If a variable that is not marked as global is loaded from a file when a global symbol with the same name already exists, it is loaded in the global symbol table. Also, if a variable is marked as global in a file and a local symbol exists, the local symbol is moved to the global symbol table and given the value from the file. Since it seems that both of these cases are likely to be the result of some sort of error, they will generate warnings.
The load command can read data stored in Octave's text and
binary formats, and MATLAB's binary format. It will automatically
detect the type of file and do conversion from different floating point
formats (currently only IEEE big and little endian, though other formats
may added in the future).
Valid options for load are listed in the following table.
-force
-ascii
-binary
-mat-binary
Octave's C-style input and output functions provide most of the functionality of the C programming language's standard I/O library. The argument lists for some of the input functions are slightly different, however, because Octave has no way of passing arguments by reference.
In the following, file refers to a file name and fid refers
to an integer file number, as returned by fopen.
There are three files that are always available. Although these files can be accessed using their corresponding numeric file ids, you should always use the symbolic names given in the table below, since it will make your programs easier to understand.
fopen function opens the named file with
the specified mode (read-write, read-only, etc.) and architecture
interpretation (IEEE big endian, IEEE little endian, etc.), and returns
an integer value that may be used to refer to the file later. If an
error occurs, fid is set to -1 and msg contains the
corresponding system error message. The mode is a one or two
character string that specifies whether the file is to be opened for
reading, writing, or both.
The second form of the fopen function returns a vector of file ids
corresponding to all the currently open files, excluding the
stdin, stdout, and stderr streams.
The third form of the fopen function returns the name of a
currently open file given its file id.
For example,
myfile = fopen ("splat.dat", "r", "ieee-le");
opens the file `splat.dat' for reading. If necessary, binary numeric values will be read assuming they are stored in IEEE format with the least significant bit first, and then converted to the native representation.
Opening a file that is already open simply opens it again and returns a separate file id. It is not an error to open a file several times, though writing to the same file through several different file ids may produce unexpected results.
The possible values `mode' may have are
The parameter arch is a string specifying the default data format for the file. Valid values for arch are:
however, conversions are currently only supported for `native' `ieee-be', and `ieee-le' formats.
fclose returns
0. Otherwise, it returns 1.
If len is omitted, fgetl reads until the next newline
character.
If there are no more characters to read, fgetl returns -1.
If len is omitted, fgets reads until the next newline
character.
If there are no more characters to read, fgets returns -1.
This section describes how to call printf and related functions.
The following functions are available for formatted output. They are modelled after the C language functions of the same name, but they interpret the format template differently in order to improve the performance of printing vector and matrix values.
printf function prints the optional arguments under the
control of the template string template to the stream
stdout.
printf, except that the output is
written to the stream fid instead of stdout.
printf, except that the output is returned as a
string. Unlike the C library function, which requires you to provide a
suitably sized string as an argument, Octave's sprintf function
returns the string, automatically sized to hold all of the items
converted.
The printf function can be used to print any number of arguments.
The template string argument you supply in a call provides
information not only about the number of additional arguments, but also
about their types and what style should be used for printing them.
Ordinary characters in the template string are simply written to the output stream as-is, while conversion specifications introduced by a `%' character in the template cause subsequent arguments to be formatted and written to the output stream. For example,
pct = 37;
filename = "foo.txt";
printf ("Processing of `%s' is %d%% finished.\nPlease be patient.\n",
filename, pct);
produces output like
Processing of `foo.txt' is 37% finished. Please be patient.
This example shows the use of the `%d' conversion to specify that a scalar argument should be printed in decimal notation, the `%s' conversion to specify printing of a string argument, and the `%%' conversion to print a literal `%' character.
There are also conversions for printing an integer argument as an unsigned value in octal, decimal, or hexadecimal radix (`%o', `%u', or `%x', respectively); or as a character value (`%c').
Floating-point numbers can be printed in normal, fixed-point notation using the `%f' conversion or in exponential notation using the `%e' conversion. The `%g' conversion uses either `%e' or `%f' format, depending on what is more appropriate for the magnitude of the particular number.
You can control formatting more precisely by writing modifiers between the `%' and the character that indicates which conversion to apply. These slightly alter the ordinary behavior of the conversion. For example, most conversion specifications permit you to specify a minimum field width and a flag indicating whether you want the result left- or right-justified within the field.
The specific flags and modifiers that are permitted and their interpretation vary depending on the particular conversion. They're all described in more detail in the following sections.
When given a matrix value, Octave's formatted output functions cycle through the format template until all the values in the matrix have been printed. For example,
printf ("%4.2f %10.2e %8.4g\n", hilb (3));
-| 1.00 5.00e-01 0.3333
-| 0.50 3.33e-01 0.25
-| 0.33 2.50e-01 0.2
If more than one value is to be printed in a single call, the output functions do not return to the beginning of the format template when moving on from one value to the next. This can lead to confusing output if the number of elements in the matrices are not exact multiples of the number of conversions in the format template. For example,
printf ("%4.2f %10.2e %8.4g\n", [1, 2], [3, 4]);
-| 1.00 2.00e+00 3
-| 4.00
If this is not what you want, use a series of calls instead of just one.
This section provides details about the precise syntax of conversion
specifications that can appear in a printf template
string.
Characters in the template string that are not part of a conversion specification are printed as-is to the output stream.
The conversion specifications in a printf template string have
the general form:
% flags width [ . precision ] type conversion
For example, in the conversion specifier `%-10.8ld', the `-' is a flag, `10' specifies the field width, the precision is `8', the letter `l' is a type modifier, and `d' specifies the conversion style. (This particular type specifier says to print a numeric argument in decimal notation, with a minimum of 8 digits left-justified in a field at least 10 characters wide.)
In more detail, output conversion specifications consist of an initial `%' character followed in sequence by:
printf function, but is recognized to provide
compatibility with the C language printf.
The exact options that are permitted and how they are interpreted vary between the different conversion specifiers. See the descriptions of the individual conversions for information about the particular options that they use.
Here is a table summarizing what all the different conversions do:
scanf for input
(see section Table of Input Conversions).
If the syntax of a conversion specification is invalid, unpredictable things will happen, so don't do this. If there aren't enough function arguments provided to supply values for all the conversion specifications in the template string, or if the arguments are not of the correct types, the results are unpredictable. If you supply more arguments than conversion specifications, the extra argument values are simply ignored; this is sometimes useful.
This section describes the options for the `%d', `%i', `%o', `%u', `%x', and `%X' conversion specifications. These conversions print integers in various formats.
The `%d' and `%i' conversion specifications both print an numeric argument as a signed decimal number; while `%o', `%u', and `%x' print the argument as an unsigned octal, decimal, or hexadecimal number (respectively). The `%X' conversion specification is just like `%x' except that it uses the characters `ABCDEF' as digits instead of `abcdef'.
The following flags are meaningful:
If a precision is supplied, it specifies the minimum number of digits to appear; leading zeros are produced if necessary. If you don't specify a precision, the number is printed with as many digits as it needs. If you convert a value of zero with an explicit precision of zero, then no characters at all are produced.
This section discusses the conversion specifications for floating-point numbers: the `%f', `%e', `%E', `%g', and `%G' conversions.
The `%f' conversion prints its argument in fixed-point notation,
producing output of the form
[-]ddd.ddd,
where the number of digits following the decimal point is controlled
by the precision you specify.
The `%e' conversion prints its argument in exponential notation,
producing output of the form
[-]d.ddde[+|-]dd.
Again, the number of digits following the decimal point is controlled by
the precision. The exponent always contains at least two digits. The
`%E' conversion is similar but the exponent is marked with the letter
`E' instead of `e'.
The `%g' and `%G' conversions print the argument in the style of `%e' or `%E' (respectively) if the exponent would be less than -4 or greater than or equal to the precision; otherwise they use the `%f' style. Trailing zeros are removed from the fractional portion of the result and a decimal-point character appears only if it is followed by a digit.
The following flags can be used to modify the behavior:
The precision specifies how many digits follow the decimal-point
character for the `%f', `%e', and `%E' conversions. For
these conversions, the default precision is 6. If the precision
is explicitly 0, this suppresses the decimal point character
entirely. For the `%g' and `%G' conversions, the precision
specifies how many significant digits to print. Significant digits are
the first digit before the decimal point, and all the digits after it.
If the precision is 0 or not specified for `%g' or
`%G', it is treated like a value of 1. If the value being
printed cannot be expressed precisely in the specified number of digits,
the value is rounded to the nearest number that fits.
This section describes miscellaneous conversions for printf.
The `%c' conversion prints a single character. The `-' flag can be used to specify left-justification in the field, but no other flags are defined, and no precision or type modifier can be given. For example:
printf ("%c%c%c%c%c", "h", "e", "l", "l", "o");
prints `hello'.
The `%s' conversion prints a string. The corresponding argument must be a string. A precision can be specified to indicate the maximum number of characters to write; otherwise characters in the string up to but not including the terminating null character are written to the output stream. The `-' flag can be used to specify left-justification in the field, but no other flags or type modifiers are defined for this conversion. For example:
printf ("%3s%-6s", "no", "where");
prints ` nowhere ' (note the leading and trailing spaces).
Octave provides the scanf, fscanf, and sscanf
functions to read formatted input. There are two forms of each of these
functions. One can be used to extract vectors of data from a file, and
the other is more `C-like'.
The optional argument size specifies the amount of data to read and may be one of
Inf
nr
[nr, Inf]
[nr, nc]
nr * nc elements, returning a matrix with
nr rows. If the number of elements read is not an exact multiple
of nr, the last column is padded with zeros.
If size is omitted, a value of Inf is assumed.
A string is returned if template specifies only character conversions.
The number of items successfully read is returned in count.
In the second form, read from fid according to template, with each conversion specifier in template corresponding to a single scalar return value. This form is more `C-like', and also compatible with previous versions of Octave.
fscanf, except that the characters are taken from the
string string instead of from a stream. Reaching the end of the
string is treated as an end-of-file condition.
fscanf with fid = stdin.
It is currently not useful to call scanf in interactive
programs.
Calls to scanf are superficially similar to calls to
printf in that arbitrary arguments are read under the control of
a template string. While the syntax of the conversion specifications in
the template is very similar to that for printf, the
interpretation of the template is oriented more towards free-format
input and simple pattern matching, rather than fixed-field formatting.
For example, most scanf conversions skip over any amount of
"white space" (including spaces, tabs, and newlines) in the input
file, and there is no concept of precision for the numeric input
conversions as there is for the corresponding output conversions.
Ordinarily, non-whitespace characters in the template are expected to
match characters in the input stream exactly.
When a matching failure occurs, scanf returns immediately,
leaving the first non-matching character as the next character to be
read from the stream, and scanf returns all the items that were
successfully converted.
The formatted input functions are not used as frequently as the formatted output functions. Partly, this is because it takes some care to use them properly. Another reason is that it is difficult to recover from a matching error.
A scanf template string is a string that contains ordinary
multibyte characters interspersed with conversion specifications that
start with `%'.
Any whitespace character in the template causes any number of whitespace characters in the input stream to be read and discarded. The whitespace characters that are matched need not be exactly the same whitespace characters that appear in the template string. For example, write ` , ' in the template to recognize a comma with optional whitespace before and after.
Other characters in the template string that are not part of conversion specifications must match characters in the input stream exactly; if this is not the case, a matching failure occurs.
The conversion specifications in a scanf template string
have the general form:
% flags width type conversion
In more detail, an input conversion specification consists of an initial `%' character followed in sequence by:
scanf finds a conversion
specification that uses this flag, it reads input as directed by the
rest of the conversion specification, but it discards this input, does
not return any valu, and does not increment the count of
successful assignments.
scanf function, but is recognized to provide
compatibility with the C language scanf.
The exact options that are permitted and how they are interpreted vary between the different conversion specifiers. See the descriptions of the individual conversions for information about the particular options that they allow.
Here is a table that summarizes the various conversion specifications:
If the syntax of a conversion specification is invalid, the behavior is undefined. If there aren't enough function arguments provided to supply addresses for all the conversion specifications in the template strings that perform assignments, or if the arguments are not of the correct types, the behavior is also undefined. On the other hand, extra arguments are simply ignored.
This section describes the scanf conversions for reading numeric
values.
The `%d' conversion matches an optionally signed integer in decimal radix.
The `%i' conversion matches an optionally signed integer in any of the formats that the C language defines for specifying an integer constant.
For example, any of the strings `10', `0xa', or `012'
could be read in as integers under the `%i' conversion. Each of
these specifies a number with decimal value 10.
The `%o', `%u', and `%x' conversions match unsigned integers in octal, decimal, and hexadecimal radices, respectively.
The `%X' conversion is identical to the `%x' conversion. They both permit either uppercase or lowercase letters to be used as digits.
Unlike the C language scanf, Octave ignores the `h',
`l', and `L' modifiers.
This section describes the scanf input conversions for reading
string and character values: `%s' and `%c'.
The `%c' conversion is the simplest: it matches a fixed number of characters, always. The maximum field with says how many characters to read; if you don't specify the maximum, the default is 1. This conversion does not skip over initial whitespace characters. It reads precisely the next n characters, and fails if it cannot get that many.
The `%s' conversion matches a string of non-whitespace characters. It skips and discards initial whitespace, but stops when it encounters more whitespace after having read something.
For example, reading the input:
hello, world
with the conversion `%10c' produces " hello, wo", but
reading the same input with the conversion `%10s' produces
"hello,".
Octave can read and write binary data using the functions fread
and fwrite, which are patterned after the standard C functions
with the same names. The are able to automatically swap the byte order
of integer data and convert among ths supported floating point formats
as the data are read.
The optional argument size specifies the amount of data to read and may be one of
Inf
nr
[nr, Inf]
[nr, nc]
nr * nc elements, returning a matrix with
nr rows. If the number of elements read is not an exact multiple
of nr, the last column is padded with zeros.
If size is omitted, a value of Inf is assumed.
The optional argument precision is a string specifying the type of data to read and may be one of
"char"
"char*1"
"integer*1"
"int8"
"signed char"
"schar"
"unsigned char"
"uchar"
"short"
"unsigned short"
"ushort"
"int"
"unsigned int"
"uint"
"long"
"unsigned long"
"ulong"
"float"
"float32"
"real*4"
"double"
"float64"
"real*8"
"integer*2"
"int16"
"integer*4"
"int32"
The default precision is "uchar".
The optional argument skip specifies the number of bytes to skip before each element is read. If it is not specified, a value of 0 is assumed.
The optional argument arch is a string specifying the data format for the file. Valid values are
"native"
"ieee-le"
"ieee-be"
"vaxd"
"vaxg"
"cray"
Conversions are currently only supported for "ieee-be" and
"ieee-le" formats.
The data read from the file is returned in val, and the number of
values read is returned in count
The argument data is a matrix of values that are to be written to the file. The values are extracted in column-major order.
The remaining arguments precision, skip, and arch are
optional, and are interpreted as described for fread.
The behavior of fwrite is undefined if the values in data
are too large to fit in the specified precision.
Since the named file is not opened, by tmpnam, it
is possible (though relatively unlikely) that it will not be available
by the time your program attempts to open it.
freport ()
-| number mode name
-|
-| 0 r stdin
-| 1 w stdout
-| 2 w stderr
-| 3 r myfile
Three functions are available for setting and determining the position of the file pointer for a given file.
SEEK_CUR (current
position), SEEK_SET (beginning), or SEEK_END (end of
file). If origin is omitted, SEEK_SET is assumed. The
offset must be zero, or a value returned by ftell (in which case
origin must be SEEK_SET.
fseek.
fseek (fid, 0, SEEK_SET).
The following example stores the current file position in the variable
marker, moves the pointer to the beginning of the file, reads
four characters, and then returns to the original position.
marker = ftell (myfile); frewind (myfile); fourch = fgets (myfile, 4); fseek (myfile, marker, SEEK_SET);
Go to the first, previous, next, last section, table of contents.