All versions of Octave include a number of built-in data types, including real and complex scalars and matrices, character strings, and a data structure type.

It is also possible to define new specialized data types by writing a small amount of C++ code. On some systems, new data types can be loaded dynamically while Octave is running, so it is not necessary to recompile all of Octave just to add a new type. See section Dynamically Linked Functions for more information about Octave's dynamic linking capabilities. section User-defined Data Types describes what you must do to define a new data type for Octave.

The standard built-in data types are real and complex scalars and matrices, ranges, character strings, and a data structure type. Additional built-in data types may be added in future versions. If you need a specialized data type that is not currently provided as a built-in type, you are encouraged to write your own user-defined data type and contribute it for distribution in a future release of Octave.

Octave's built-in numeric objects include real and complex scalars and
matrices. All built-in numeric data is currently stored as double
precision numbers. On systems that use the IEEE floating point format,
values in the range of approximately
can be stored, and the relative precision is approximately
The exact values are given by the variables `realmin`

,
`realmax`

, and `eps`

, respectively.

Matrix objects can be of any size, and can be dynamically reshaped and resized. It is easy to extract individual rows, columns, or submatrices is using a variety of powerful indexing features. See section Index Expressions.

See section Numeric Data Types, for more information.

A character string in Octave consists of a sequence of characters enclosed in either double-quote or single-quote marks. Internally, Octave currently stores strings as matrices of characters. All the indexing operations that work for matrix objects also work for strings.

See section Strings, for more information.

Octave's data structure type can help you to organize related objects of different types. The current implementation uses an associative array with indices limited to strings, but the syntax is more like C-style structures.

See section Data Structures, for more information.

Someday I hope to expand this to include a complete description of
Octave's mechanism for managing user-defined data types. Until this
feature is documented here, you will have to make do by reading the code
in the ``ov.h'`, ``ops.h'`, and related files from Octave's
``src'` directory.

The following functions allow you to determine the size of a variable or
expression. These functions are defined for all objects. They return
-1 when the operation doesn't make sense. For example, Octave's
data structure type doesn't have rows or columns, so the `rows`

and
`columns`

functions return -1 for structure arguments.

__Function File:__**columns***(*`a`)-
Return the number of columns of
`a`.

__Function File:__**rows***(*`a`)-
Return the number of rows of
`a`.

__Function File:__**length***(*`a`)-
Return the number of rows of
`a`or the number of columns of`a`, whichever is larger.

__Function File:__**size***(*`a`,`n`)-
Return the number rows and columns of
`a`.With one input argument and one output argument, the result is returned in a 2 element row vector. If there are two output arguments, the number of rows is assigned to the first, and the number of columns to the second. For example,

size ([1, 2; 3, 4; 5, 6]) => [ 3, 2 ] [nr, nc] = size ([1, 2; 3, 4; 5, 6]) => nr = 3 => nc = 2

If given a second argument of either 1 or 2,

`size`

will return only the row or column dimension. For examplesize ([1, 2; 3, 4; 5, 6], 2) => 2

returns the number of columns in the given matrix.

__Function File:__**isempty***(*`a`)-
Return 1 if
`a`is an empty matrix (either the number of rows, or the number of columns, or both are zero). Otherwise, return 0.

Go to the first, previous, next, last section, table of contents.