octave_packages/fixed-0.7.10/doc-cache

   1 # Created by Octave 3.6.1, Tue Apr 03 18:18:25 2012 UTC <root@t61>
   2 # name: cache
   3 # type: cell
   4 # rows: 3
   5 # columns: 6
   6 # name: <cell-element>
   7 # type: sq_string
   8 # elements: 1
   9 # length: 6
  10 concat
  11
  12
  13 # name: <cell-element>
  14 # type: sq_string
  15 # elements: 1
  16 # length: 733
  17  -- Function File: X = concat (A, B)
  18  -- Function File: X = concat (A, B, DIM)
  19      Concatenate two matrices regardless of their type. Due to the
  20      implementation of the matrix concatenation in Octave being
  21      hard-coded for the types it knowns, user types can not use the
  22      matrix concatenation operator. Thus for the _Galois_ and _Fixed
  23      Point_ types, the in-built matrix concatenation functions will
  24      return a matrix value as their solution.
  25
  26      This function allows these types to be concatenated. If called
  27      with a user type that is not known by this function, the in-built
  28      concatenate function is used.
  29
  30      If DIM is 1, then the matrices are concatenated, else if DIM is 2,
  31      they are stacked.
  32
  33
  34
  35
  36 # name: <cell-element>
  37 # type: sq_string
  38 # elements: 1
  39 # length: 50
  40 Concatenate two matrices regardless of their type.
  41
  42
  43
  44 # name: <cell-element>
  45 # type: sq_string
  46 # elements: 1
  47 # length: 19
  48 create_lookup_table
  49
  50
  51 # name: <cell-element>
  52 # type: sq_string
  53 # elements: 1
  54 # length: 193
  55  -- Function File: TABLE = create_lookup_table (X, Y)
  56      Creates a lookup table betwen the vectors X and Y. If X is not in
  57      increasing order, the vectors are sorted before being stored.
  58
  59
  60
  61
  62 # name: <cell-element>
  63 # type: sq_string
  64 # elements: 1
  65 # length: 50
  66 Creates a lookup table betwen the vectors X and Y.
  67
  68
  69
  70 # name: <cell-element>
  71 # type: sq_string
  72 # elements: 1
  73 # length: 10
  74 fixedpoint
  75
  76
  77 # name: <cell-element>
  78 # type: sq_string
  79 # elements: 1
  80 # length: 1356
  81  -- Function File:  fixedpoint ('help')
  82  -- Function File:  fixedpoint ('info')
  83  -- Function File:  fixedpoint ('info', MOD)
  84  -- Function File:  fixedpoint ('test')
  85  -- Function File:  fixedpoint ('test', MOD)
  86      Manual and test code for the Octave Fixed Point toolbox. There are
  87      5 possible ways to call this function.
  88
  89     `fixedpoint ('help')'
  90           Display this help message. Called with no arguments, this
  91           function also displays this help message
  92
  93     `fixedpoint ('info')'
  94           Open the Fixed Point toolbox manual
  95
  96     `fixedpoint ('info', MOD)'
  97           Open the Fixed Point toolbox manual at the section specified
  98           by MOD
  99
 100     `fixedpoint ('test')'
 101           Run all of the test code for the Fixed Point toolbox.  MOD.
 102
 103      Valid values for the varibale MOD are
 104
 105     'basics'
 106           The section describing the use of the fixed point toolbox
 107           within Octave
 108
 109     'programming'
 110           The section descrining how to use the fixed-point type with
 111           oct-files
 112
 113     'example'
 114           The section describing an in-depth example of the use of the
 115           fixed-point type
 116
 117     'reference'
 118           The refernce section of all of the specific fixed point
 119           operators and functions
 120
 121      Please note that this function file should be used as an example
 122      of the use of this toolbox.
 123
 124
 125
 126
 127 # name: <cell-element>
 128 # type: sq_string
 129 # elements: 1
 130 # length: 56
 131 Manual and test code for the Octave Fixed Point toolbox.
 132
 133
 134
 135 # name: <cell-element>
 136 # type: sq_string
 137 # elements: 1
 138 # length: 5
 139 float
 140
 141
 142 # name: <cell-element>
 143 # type: sq_string
 144 # elements: 1
 145 # length: 203
 146  -- Function File: Y = float (X)
 147      Converts a fixed point object to the equivalent floating point
 148      object. This is equivalent to `X.x' if `isfixed(X)' returns true,
 149      and returns X otherwise.
 150
 151
 152
 153
 154 # name: <cell-element>
 155 # type: sq_string
 156 # elements: 1
 157 # length: 70
 158 Converts a fixed point object to the equivalent floating point object.
 159
 160
 161
 162 # name: <cell-element>
 163 # type: sq_string
 164 # elements: 1
 165 # length: 5
 166 fsort
 167
 168
 169 # name: <cell-element>
 170 # type: sq_string
 171 # elements: 1
 172 # length: 712
 173  -- Function File: [S, I] = fsort (X)
 174      Return a copy of the fixed point variable X with the elements
 175      arranged in increasing order.  For matrices, `fsort' orders the
 176      elements in each column.
 177
 178      For example,
 179
 180           fsort (fixed(4,0,[1, 2; 2, 3; 3, 1]))
 181               =>  1  1
 182                   2  2
 183                   3  3
 184
 185      The `fsort' function may also be used to produce a matrix
 186      containing the original row indices of the elements in the sorted
 187      matrix.  For example,
 188
 189           [s, i] = sort ([1, 2; 2, 3; 3, 1])
 190                => s = 1  1
 191                       2  2
 192                       3  3
 193                => i = 1  3
 194                       2  1
 195                       3  2
 196
 197
 198
 199
 200 # name: <cell-element>
 201 # type: sq_string
 202 # elements: 1
 203 # length: 80
 204 Return a copy of the fixed point variable X with the elements arranged
 205 in increa
 206
 207
 208
 209 # name: <cell-element>
 210 # type: sq_string
 211 # elements: 1
 212 # length: 12
 213 lookup_table
 214
 215
 216 # name: <cell-element>
 217 # type: sq_string
 218 # elements: 1
 219 # length: 621
 220  -- Function File: Y = lookup_table (TABLE, X)
 221  -- Function File: Y = lookup_table (TABLE, X, INTERP, EXTRAP)
 222      Using the lookup table created by "create_lookup_table", find the
 223      value Y corresponding to X. With two arguments the lookup is done
 224      to the nearest value below in the table less than the desired
 225      value. With three arguments a simple linear interpolation is
 226      performed. With four arguments an extrapolation is also performed.
 227      The exact values of arguments three and four are irrelevant, as
 228      only there presence detremines whether interpolation and/or
 229      extrapolation are used.
 230
 231
 232
 233
 234 # name: <cell-element>
 235 # type: sq_string
 236 # elements: 1
 237 # length: 80
 238 Using the lookup table created by "create_lookup_table", find the value
 239 Y corres
 240
 241
 242
 243
 244