[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |

It is easy to define a matrix of values in Octave. The size of the matrix is determined automatically, so it is not necessary to explicitly state the dimensions. The expression

a = [1, 2; 3, 4] |

results in the matrix

/ \ | 1 2 | a = | | | 3 4 | \ / |

Elements of a matrix may be arbitrary expressions, provided that the dimensions all make sense when combining the various pieces. For example, given the above matrix, the expression

[ a, a ] |

produces the matrix

ans = 1 2 1 2 3 4 3 4 |

but the expression

[ a, 1 ] |

produces the error

error: number of rows must match near line 13, column 6 |

(assuming that this expression was entered as the first thing on line 13, of course).

Inside the square brackets that delimit a matrix expression, Octave looks at the surrounding context to determine whether spaces and newline characters should be converted into element and row separators, or simply ignored, so an expression like

a = [ 1 2 3 4 ] |

will work. However, some possible sources of confusion remain. For example, in the expression

[ 1 - 1 ] |

the ``-'` is treated as a binary operator and the result is the
scalar 0, but in the expression

[ 1 -1 ] |

the ``-'` is treated as a unary operator and the result is the
vector `[ 1, -1 ]`

. Similarly, the expression

[ sin (pi) ] |

will be parsed as

[ sin, (pi) ] |

and will result in an error since the `sin`

function will be
called with no arguments. To get around this, you must omit the space
between `sin`

and the opening parenthesis, or enclose the
expression in a set of parentheses:

[ (sin (pi)) ] |

Whitespace surrounding the single quote character (``''`, used as a
transpose operator and for delimiting character strings) can also cause
confusion. Given `a = 1`

, the expression

[ 1 a' ] |

results in the single quote character being treated as a
transpose operator and the result is the vector `[ 1, 1 ]`

, but the
expression

[ 1 a ' ] |

produces the error message

error: unterminated string constant |

because not doing so would cause trouble when parsing the valid expression

[ a 'foo' ] |

For clarity, it is probably best to always use commas and semicolons to separate matrix elements and rows.

When you type a matrix or the name of a variable whose value is a matrix, Octave responds by printing the matrix in with neatly aligned rows and columns. If the rows of the matrix are too large to fit on the screen, Octave splits the matrix and displays a header before each section to indicate which columns are being displayed. You can use the following variables to control the format of the output.

__Built-in Function:__`val`=**output_max_field_width***()*__Built-in Function:__`old_val`=**output_max_field_width***(*`new_val`)Query or set the internal variable that specifies the maximum width of a numeric output field.

**See also:**format, output_precision.

__Built-in Function:__`val`=**output_precision***()*__Built-in Function:__`old_val`=**output_precision***(*`new_val`)Query or set the internal variable that specifies the minimum number of significant figures to display for numeric output.

**See also:**format, output_max_field_width.

It is possible to achieve a wide range of output styles by using
different values of `output_precision`

and
`output_max_field_width`

. Reasonable combinations can be set using
the `format`

function. See section Basic Input and Output.

__Built-in Function:__`val`=**split_long_rows***()*__Built-in Function:__`old_val`=**split_long_rows***(*`new_val`)Query or set the internal variable that controls whether rows of a matrix may be split when displayed to a terminal window. If the rows are split, Octave will display the matrix in a series of smaller pieces, each of which can fit within the limits of your terminal width and each set of rows is labeled so that you can easily see which columns are currently being displayed. For example:

octave:13> rand (2,10) ans = Columns 1 through 6: 0.75883 0.93290 0.40064 0.43818 0.94958 0.16467 0.75697 0.51942 0.40031 0.61784 0.92309 0.40201 Columns 7 through 10: 0.90174 0.11854 0.72313 0.73326 0.44672 0.94303 0.56564 0.82150

Octave automatically switches to scientific notation when values become
very large or very small. This guarantees that you will see several
significant figures for every value in a matrix. If you would prefer to
see all values in a matrix printed in a fixed point format, you can set
the built-in variable `fixed_point_format`

to a nonzero value. But
doing so is not recommended, because it can produce output that can
easily be misinterpreted.

__Built-in Function:__`val`=**fixed_point_format***()*__Built-in Function:__`old_val`=**fixed_point_format***(*`new_val`)Query or set the internal variable that controls whether Octave will use a scaled format to print matrix values such that the largest element may be written with a single leading digit with the scaling factor is printed on the first line of output. For example,

octave:1> logspace (1, 7, 5)' ans = 1.0e+07 * 0.00000 0.00003 0.00100 0.03162 1.00000

Notice that first value appears to be zero when it is actually 1. For this reason, you should be careful when setting

`fixed_point_format`

to a nonzero value.

4.1.1 Empty Matrices |

[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |

A matrix may have one or both dimensions zero, and operations on empty
matrices are handled as described by Carl de Boor in An Empty
Exercise, SIGNUM, Volume 25, pages 2-6, 1990 and C. N. Nett and W. M.
Haddad, in A System-Theoretic Appropriate Realization of the Empty
Matrix Concept, IEEE Transactions on Automatic Control, Volume 38,
Number 5, May 1993.
Briefly, given a scalar `s`, an `m` by
`n` matrix `M(mxn)`

, and an `m` by `n` empty matrix
`[](mxn)`

(with either one or both dimensions equal to zero), the
following are true:

s * [](mxn) = [](mxn) * s = [](mxn) [](mxn) + [](mxn) = [](mxn) [](0xm) * M(mxn) = [](0xn) M(mxn) * [](nx0) = [](mx0) [](mx0) * [](0xn) = 0(mxn) |

By default, dimensions of the empty matrix are printed along with the
empty matrix symbol, ``[]'`. The built-in variable
`print_empty_dimensions`

controls this behavior.

__Built-in Function:__`val`=**print_empty_dimensions***()*__Built-in Function:__`old_val`=**print_empty_dimensions***(*`new_val`)Query or set the internal variable that controls whether the dimensions of empty matrices are printed along with the empty matrix symbol,

``[]'`. For example, the expressionzeros (3, 0)

will print

ans = [](3x0)

Empty matrices may also be used in assignment statements as a convenient way to delete rows or columns of matrices. See section Assignment Expressions.

When Octave parses a matrix expression, it examines the elements of the list to determine whether they are all constants. If they are, it replaces the list with a single matrix constant.

[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] |

This document was generated on *December, 26 2007* using *texi2html 1.76*.