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

# 5. Data

Entities are the basic objects (constants and variables) in Algae. They contain members and elements. Members contain information about the entity, such as the number of rows in a matrix. An entity's elements, if it has any, contain the data such as the value of a scalar. There are five classes:

``scalar'`
  The ``scalar'` data structure contains a single element, its value, which may have any of the data types described above. Its members are:

  ``class'`
    The string ``"scalar"'`.

  ``type'`
    The type (like ``"integer"'` or ``"real"'`).

  Notice that a scalar is not the same as a one-element vector or matrix.

``vector'`
  The ``vector'` entity contains a one-dimensional array of elements. Its members are:

  ``class'`
    The string ``"vector"'`.

  ``type'`
    The type (like ``"integer"'` or ``"real"'`).

  ``density'`
    Either ``"dense"'` or ``"sparse"'`.

  ``ne'`
    The number of elements.

  ``nn'`
    The number of non-zero elements.

  ``eid'`
    The element labels.

  The element labels of a vector are themselves a vector.

``matrix'`
  The ``matrix'` data structure contains two-dimensional arrays of elements. It contains zero or more rows and columns. The members of a matrix are:

  ``class'`
    The string ``"matrix"'`.

  ``type'`
    The type (like ``"integer"'` or ``"real"'`).

  ``symmetry'`
    One of ``"general"'`, ``"symmetric"'`, or ``"hermitian"'`.

  ``density'`
    One of ``"dense"'`, ``"sparse"'` or ``"sparse_upper"'`.

  ``nr'`
    The number of rows.

  ``nc'`
    The number of columns.

  ``nn'`
    The number of nonzero elements. For matrices with "sparse_upper" density, this number does not include the elements on the diagonal, all of which are stored. Sorry.

  ``rid'`
    The row labels.

  ``cid'`
    The column labels.

  The row and column labels of a matrix are vectors. The row label vector has the same number of elements as its matrix has rows, and likewise for the column label.

``table'`
  The ``table'` object is like a bucket that can contain any number of other objects.

  Several functions return tables. For example, the `eig` function returns a table that contains the matrices `values` and `vectors`.

  The entities contained in a table are members of it, so they can be extracted using the `.` operator. Thus `eig(A).values` returns the eigenvalues of ``A'`.

``function'`
  Functions are entities just like scalars and matrices, and can be operated on in the same manner. Functions have two members: ``class'`, which is `"function"`, and ``ilk'`, which is either `"user"` or `"builtin"`.

The `scalar`, `vector`, and `matrix` classes are known collectively as arrays. These are the only classes that contain elements, and all have the member `type` that specifies the data type. There are four types:

``integer'`
  On most machines this is a 32-bit integer, like 42 or -273.

``real'`
  This is a floating point number like 3.1415. It is stored in 64 bits on most machines.

``complex'`
  This is a complex number having both real and imaginary parts.

``character'`
  This is a character string like ``"Hello"'`.

Scalar constants are specified in a manner similar to that used in other programming languages. Numeric constants can be given in decimal form, such as ``32'` or ``32.0'`, or in scientific notation, such as ``3.2E1'`. In the latter notation, the letters ``e'` and ``E'` may be used interchangeably to prefix the exponent. White space (space, tab, etc.) is significant in that context, of course, so that ``1.2e+3'` (1200.0) is definitely not the same as ``1.2e +3'` (4.2).

A ``character'` constant is a sequence of one or more characters surrounded by matching double-quotes. Within the quotes, the backslash character may be used to introduce "escape sequences" for unusual characters like `newline`. For example, the string ``"\""'` is a string containing a single character (the right double-quote). The following escape sequences may be used:

`\a`
  bell
`\b`
  backspace
`\e`
  escape
`\f`
  formfeed
`\n`
  newline
`\r`
  carriage return
`\t`
  tab
`\v`
  vertical tab
`\ooo`
  octal number
`\xhh`
  hexadecimal number

The escape sequence `\ooo` consists of a backslash followed by one, two, or three octal digits, which are taken to specify the value of the desired character. For example, `\33` is the ASCII "escape" character (which is also given by `\e`). Likewise, the sequence `\xhh` consists of a backslash followed by ``x'`, followed by one or two hexadecimal digits, which specify the value of the desired character. For example, `\x1b` also specifies the ASCII "escape" character.

If the character following the backslash is not one of those specified above, then that character is taken literally. For example, `\"` specifies the double-quote character--not the end of the character constant.

Matrices may be generated by specifying their elements within brackets. Commas separate elements within rows and semicolons separate the rows. Thus `[1,2;3,4]` specifies the matrix

    [ 1  2 ]
    [ 3  4 ]

A vector may be generated by using either of the forms ``i:j'` or ``i:j:k'`. It is obtained by starting with the value ``i'` and incrementing by ``k'` (or 1 if the first form is used) while remaining between ``i'` and ``j'`, inclusive. (Notice that this is not the same format used by MATLAB.) For example, `[1:8:2]` is the same as `[1,3,5,7]`. All elements within a matrix have the same type (``integer'`, ``real'`, etc.); conversion will be performed automatically if possible.

The terms within the brackets may be constants, variables, or expressions. For example, `[1+2,3]` is the same as `[3,3]`. Matrices may be involved, as long as their dimensions are appropriate. For example, if the variable ``A'` is defined to be equal to the square matrix ``[1,2;3,4]'`, then a new column could be appended to it with the expression `[A,[5;6]]` to yield

    [ 1  2  5 ]
    [ 3  4  6 ]

Matrices may be partitioned by specifying the desired row and column numbers within brackets. For example, if ``A'` is a previously defined matrix then `A[1;1]` specifies a scalar having the value of the element in the first row and the first column of ``A'`. The semicolon within the parentheses separates the row specifiers from the column specifiers.

Members of data structures are referred to by using the member operator ``.'`. For example, the number of rows in a matrix is stored in the member `nr`, so `A.nr` returns the number of rows in the matrix `A`. The member operator associates left to right, so that `A.type.type` returns the string `"character"`.

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

This document was generated by K. Scott Hunziker on February, 22 2004 using texi2html