This is algae.info, produced by makeinfo version 4.3 from algae.texinfo.

INFO-DIR-SECTION Programming Languages
START-INFO-DIR-ENTRY
* algae: (algae).		Another Matrix Programming Language
END-INFO-DIR-ENTRY


File: algae.info,  Node: Function Index,  Prev: Concept Index,  Up: Top

Function Index
**************

* Menu:

* abs:                                   abs.
* acos:                                  acos.
* acosh:                                 acosh.
* all:                                   all.
* arg:                                   arg.
* asin:                                  asin.
* asinh:                                 asinh.
* atan:                                  atan.
* atan2:                                 atan2.
* atanh:                                 atanh.
* atof:                                  atof.
* autosrc:                               autosrc.
* backsub:                               backsub.
* band:                                  band.
* bdiag:                                 bdiag.
* brent:                                 brent.
* btrans:                                btrans.
* builtin:                               builtin.
* cd:                                    cd.
* ceil:                                  ceil.
* char:                                  char.
* chol:                                  chol.
* circshift:                             circshift.
* class:                                 class.
* close:                                 close.
* combine:                               combine.
* complement:                            complement.
* conj:                                  conj.
* cos:                                   cos.
* cosh:                                  cosh.
* cram:                                  cram.
* dense:                                 dense.
* diag:                                  diag.
* dice:                                  dice.
* diff:                                  diff.
* digits:                                digits.
* eig:                                   eig.
* equal:                                 equal.
* equilibrate:                           equilibrate.
* erf:                                   erf.
* erfc:                                  erfc.
* eval:                                  eval.
* exception:                             exception.
* exec:                                  exec.
* exit:                                  exit.
* exp:                                   exp.
* exsparse:                              exsparse.
* factor:                                factor.
* fft:                                   fft.
* file:                                  file.
* fill:                                  fill.
* filter:                                filter.
* find:                                  find.
* first:                                 first.
* floor:                                 floor.
* form:                                  form.
* fprintf:                               fprintf.
* fread:                                 fread.
* full:                                  full.
* fwrite:                                fwrite.
* gcd:                                   gcd.
* get:                                   get.
* get_path:                              get_path.
* getdyn:                                getdyn.
* getenv:                                getenv.
* getmat:                                getmat.
* gpskca:                                gpskca.
* grep:                                  grep.
* hermitian:                             hermitian.
* ident:                                 ident.
* ifft:                                  ifft.
* imag:                                  imag.
* imax:                                  imax.
* imin:                                  imin.
* info:                                  info.
* integer:                               integer.
* intersection:                          intersection.
* inv:                                   inv.
* iram:                                  iram.
* isort:                                 isort.
* label:                                 label.
* last:                                  last.
* lcm:                                   lcm.
* leastsq:                               leastsq.
* line:                                  line.
* linspace:                              linspace.
* load:                                  load.
* log:                                   log.
* log10:                                 log10.
* logspace:                              logspace.
* lose:                                  lose.
* magic:                                 magic.
* matrix:                                matrix.
* max:                                   max.
* members:                               members.
* merge:                                 merge.
* message:                               message.
* min:                                   min.
* mksparse:                              mksparse.
* monte:                                 monte.
* mult:                                  mult.
* norm:                                  norm.
* npsol:                                 npsol.
* ode4:                                  ode4.
* pick:                                  pick.
* plot:                                  plot.
* primef:                                primef.
* primes:                                primes.
* print:                                 print.
* printf:                                printf.
* product:                               product.
* prof:                                  prof.
* provide:                               provide.
* put:                                   put.
* putdyn:                                putdyn.
* putmat:                                putmat.
* rand:                                  rand.
* randn:                                 randn.
* read:                                  read.
* readnum:                               readnum.
* real:                                  real.
* replot:                                replot.
* require:                               require.
* reverse:                               reverse.
* roots:                                 roots.
* round:                                 round.
* save:                                  save.
* scalar:                                scalar.
* search_path:                           search_path.
* select:                                select.
* seq:                                   seq.
* set:                                   set.
* shape:                                 shape.
* show:                                  show.
* sign:                                  sign.
* sin:                                   sin.
* sinh:                                  sinh.
* solve:                                 solve.
* sort:                                  sort.
* source:                                source.
* sources:                               sources.
* sparse:                                sparse.
* spline:                                spline.
* split:                                 split.
* splot:                                 splot.
* sprintf:                               sprintf.
* sqrt:                                  sqrt.
* srand:                                 srand.
* src:                                   src.
* ssi:                                   ssi.
* string:                                string.
* strip:                                 strip.
* substr:                                substr.
* sum:                                   sum.
* surprise:                              surprise.
* svd:                                   svd.
* symmetric:                             symmetric.
* system:                                system.
* tan:                                   tan.
* tanh:                                  tanh.
* test:                                  test.
* time:                                  time.
* tmp_file:                              tmp_file.
* tolower:                               tolower.
* toupper:                               toupper.
* transform:                             transform.
* trapz:                                 trapz.
* tril:                                  tril.
* triu:                                  triu.
* umin:                                  umin.
* union:                                 union.
* unlabel:                               unlabel.
* unplot:                                unplot.
* vector:                                vector.
* what:                                  what.
* who:                                   who.
* zero:                                  zero.