# Created by Octave 3.2.4, Tue Nov 23 12:51:57 2010 EST <mockbuild@jetta.math.Princeton.EDU.private>
# name: cache
# type: cell
# rows: 3
# columns: 6
# name: <cell-element>
# type: string
# elements: 1
# length: 6
concat
# name: <cell-element>
# type: string
# elements: 1
# length: 733
 -- Function File: X = concat (A, B)
 -- Function File: X = concat (A, B, DIM)
     Concatenate two matrices regardless of their type. Due to the
     implementation of the matrix concatenation in Octave being
     hard-coded for the types it knowns, user types can not use the
     matrix concatenation operator. Thus for the _Galois_ and _Fixed
     Point_ types, the in-built matrix concatenation functions will
     return a matrix value as their solution.

     This function allows these types to be concatenated. If called
     with a user type that is not known by this function, the in-built
     concatenate function is used.

     If DIM is 1, then the matrices are concatenated, else if DIM is 2,
     they are stacked.


# name: <cell-element>
# type: string
# elements: 1
# length: 50
Concatenate two matrices regardless of their type.

# name: <cell-element>
# type: string
# elements: 1
# length: 19
create_lookup_table
# name: <cell-element>
# type: string
# elements: 1
# length: 193
 -- Function File: TABLE = create_lookup_table (X, Y)
     Creates a lookup table betwen the vectors X and Y. If X is not in
     increasing order, the vectors are sorted before being stored.


# name: <cell-element>
# type: string
# elements: 1
# length: 50
Creates a lookup table betwen the vectors X and Y.

# name: <cell-element>
# type: string
# elements: 1
# length: 10
fixedpoint
# name: <cell-element>
# type: string
# elements: 1
# length: 1356
 -- Function File:  fixedpoint ('help')
 -- Function File:  fixedpoint ('info')
 -- Function File:  fixedpoint ('info', MOD)
 -- Function File:  fixedpoint ('test')
 -- Function File:  fixedpoint ('test', MOD)
     Manual and test code for the Octave Fixed Point toolbox. There are
     5 possible ways to call this function.

    `fixedpoint ('help')'
          Display this help message. Called with no arguments, this
          function also displays this help message

    `fixedpoint ('info')'
          Open the Fixed Point toolbox manual

    `fixedpoint ('info', MOD)'
          Open the Fixed Point toolbox manual at the section specified
          by MOD

    `fixedpoint ('test')'
          Run all of the test code for the Fixed Point toolbox.  MOD.

     Valid values for the varibale MOD are

    'basics'
          The section describing the use of the fixed point toolbox
          within Octave

    'programming'
          The section descrining how to use the fixed-point type with
          oct-files

    'example'
          The section describing an in-depth example of the use of the
          fixed-point type

    'reference'
          The refernce section of all of the specific fixed point
          operators and functions

     Please note that this function file should be used as an example
     of the use of this toolbox.


# name: <cell-element>
# type: string
# elements: 1
# length: 56
Manual and test code for the Octave Fixed Point toolbox.

# name: <cell-element>
# type: string
# elements: 1
# length: 5
float
# name: <cell-element>
# type: string
# elements: 1
# length: 203
 -- Function File: Y = float (X)
     Converts a fixed point object to the equivalent floating point
     object. This is equivalent to `X.x' if `isfixed(X)' returns true,
     and returns X otherwise.


# name: <cell-element>
# type: string
# elements: 1
# length: 70
Converts a fixed point object to the equivalent floating point object.

# name: <cell-element>
# type: string
# elements: 1
# length: 5
fsort
# name: <cell-element>
# type: string
# elements: 1
# length: 712
 -- Function File: [S, I] = fsort (X)
     Return a copy of the fixed point variable X with the elements
     arranged in increasing order.  For matrices, `fsort' orders the
     elements in each column.

     For example,

          fsort (fixed(4,0,[1, 2; 2, 3; 3, 1]))
              =>  1  1
                  2  2
                  3  3

     The `fsort' function may also be used to produce a matrix
     containing the original row indices of the elements in the sorted
     matrix.  For example,

          [s, i] = sort ([1, 2; 2, 3; 3, 1])
               => s = 1  1
                      2  2
                      3  3
               => i = 1  3
                      2  1
                      3  2


# name: <cell-element>
# type: string
# elements: 1
# length: 80
Return a copy of the fixed point variable X with the elements arranged
in increa

# name: <cell-element>
# type: string
# elements: 1
# length: 12
lookup_table
# name: <cell-element>
# type: string
# elements: 1
# length: 621
 -- Function File: Y = lookup_table (TABLE, X)
 -- Function File: Y = lookup_table (TABLE, X, INTERP, EXTRAP)
     Using the lookup table created by "create_lookup_table", find the
     value Y corresponding to X. With two arguments the lookup is done
     to the nearest value below in the table less than the desired
     value. With three arguments a simple linear interpolation is
     performed. With four arguments an extrapolation is also performed.
     The exact values of arguments three and four are irrelevant, as
     only there presence detremines whether interpolation and/or
     extrapolation are used.


# name: <cell-element>
# type: string
# elements: 1
# length: 80
Using the lookup table created by "create_lookup_table", find the value
Y corres

