1 INTRODUCTION

[y] = BatchMode()
 BatchMode() returns 1 if this Tela process is in batch mode
   (command line switch -b), otherwise 0.

[y] = CheckReadOnlyMode(;x)
 CheckReadOnlyMode() returns 1 if this Tela process checks that function
   input arguments are not modified by the function. The check is done by
   default, but if it causes problems (bugs in Tela) you can turn it off
   using CheckReadOnlyMode(off).
   CheckReadOnlyMode returns the old mode setting.

[f] = FFT(u; dim)
 FFT(u) gives the complex Fast Fourier Transform of u.
   If u's rank is more than one, the transform is computed
   only along the first dimension (many independent 1D
   transforms).

   FFT(u,dim) computes the FFT along the specified dimension.
   The first dimension is labeled 1 and so on.

   The forward FFT is defined as

   FFT(u)_j = sum(c_k * exp(-i*(j-1)*(k-1)*2*pi/n), k=1..n)

   where i = sqrt(-1).
   

[y] = HeavisideTheta(x)
 y = HeavisideTheta(x) returns 1 if x>=0 and 0 if x<0.
   x must be real. If x is array, the operation is applied componentwise.

[y] = Im(x)
 y = Im(x) computes the imaginary part of a complex quantity x.
   If x is real or integer, the result is zero.
   If x is an array, the operation is applied componentwise.

[L;U,P] = LU(A)
 [L,U,P] = LU(A) computes the LU factorization of matrix A.
   The factorization is A = P**L**U, where P is a permutation
   matrix, L is lower triangular with unit diagonal and U is
   upper triangular.
   [lu] = LU(A) leaves the factors L and U packed in one matrix.
   [lu,p] = LU(A) returns also the pivoting info vector p.
   (Notice that this p is related to the permutation matrix P
   but is not the same. You need this form of LU if you want to
   use LUbacksubst later on.)

[x] = LUbacksubst(lu,p,b)
 LUbacksubst(lu,p,b) solves the linear system A**x == b,
   where A has been previously LU-decomposed using LU:
   [lu,p] = LU(A).

[y] = Re(x)
 y = Re(x) computes the real part of a complex quantity x.
   If x is real or integer, it is returned as such.
   If x is an array, the operation is applied componentwise.

[U;S,V] = SVD(A)
 [U,S,V] = SVD(A) computes the singular value
   decomposition of matrix A: A = U**S**V'.
   U and V are unitary and S is diagonal.
   SVD(A) as such returns the vector of singular values.

[y] = SilentMode()
 SilentMode() returns 1 if this Tela process is in silent mode
   (command line switch -s), otherwise 0.

[Bx,By,Bz] = T87(Kp,x,y,z)
 [Bx,By,Bz] = T87(Kp,x,y,z) computes the Tsyganenko-87 model
   magnetic field. The non-truncated version of the model is used.
   Inputs: Kp, the Kp index; x,y,z, GSM coordinates
   in Earth radii. Outputs: total magnetic field in nanotesla in
   GSM coordinates.

[Bx,By,Bz] = T89(Kp,x,y,z)
 [Bx,By,Bz] = T89(Kp,x,y,z) computes the Tsyganenko-89 model
   magnetic field. Inputs: Kp, the Kp index; x,y,z, GSM coordinates
   in Earth radii. Outputs: total magnetic field in nanotesla in
   GSM coordinates.

[y] = VerboseMode(;x)
 VerboseMode() returns 1 if this Tela process is in verbose mode
   (command line switch -v), otherwise 0.
   VerboseMode(on) and VerboseMode(off) set the verbose mode on
   and off, respectively. They return the old mode setting.

[y] = all(x)
 all(x) returns 1 if all elements of x are nonzero,
   and 0 otherwise.
   x must be an integer array or scalar.

[] = annotate(primitive...)
 annotate("primitive"[,options]) adds MTV annotations to the previous
   graph. The plot command(s) and the annotate command(s) must appear
   inside hold(on) ... hold(off) in order to work correctly.

[y] = any(x)
 any(x) returns 1 if at least one element of x is nonzero,
   and 0 otherwise.
   x must be a integer array or scalar.

[phi] = arg(z)
 arg(z) returns the argument of a complex quantity
   (in radians). The result is between -pi and pi.
   If z is a complex array, the operation is applied
   componentwise.

[y] = atan(x)
 y = atan(x) computes the arc tangent of x.
   If x is complex, the result is complex, otherwise real.
   If x is an array, the operation is applied componentwise.

[z] = atan2(y,x)
 z = atan2(y,x) computes the arcus tangent of y/x using the signs
   of both arguments to determine the quadrant of the return value.
   The input argument must be integer or real scalars and the
   return value is real.

[y] = autoglobal(...)
 autoglobal("sym1","sym2",...) sets the 'autoglobal' attribute
   to given symbols. The symbols are then globally accessible
   from inside packages and functions without need to explicitly
   declaring them global. Constants such as pi carry the autoglobal
   attribute automatically, but with this function it is possible
   for the user to define more autoglobal symbols.

   Warning: This function is for experts only. It is not advisable
   to say autoglobal("x"), for instance, because many existing code
   may then break down.

[] = autosource(fn...)
 autosource("file.t","name1","name2",...) tags symbols
   name1, name2,... such that the command source("file.t")
   is effectively executed when any of the symbols name
   is used. This is load-on-demand.

[] = bar(x,y,z...)
 bar(grouplabels,data,barnames[,options]) produces a bar chart.
   Example 1:

       bar(strmat("DEC","HP"),#(111,150.6),"Speed")

[y] = ceil(x)
 ceil(x) returns the smallest integer which is larger than x.
   x must be integer or real scalar or array. If it is an array,
   the operation is applied componentwise.

[B] = chol(A)
 B=chol(A) returns the Cholesky decomposition of a
   positive definite square matrix A: B'**B == A.
   A may be integer, real or complex valued.
   Only the upper half of A is referenced, the lower half
   is assumed to be Hermitian symmetric.

[y] = conj(x)
 y = conj(x) computes the complex conjugate of x.
   Real and integer arguments are returned as such.
   If x is an array, the operation is applied componentwise.

[] = contour(z...)
 contour(z[,options]) plots the matrix z as a filled contour plot.

[] = contour3(z...)
 contour3(z[,options]) plots the 3D array as a
   "volume" plot. Currently this only means that all
   six faces of the volume are contoured and colored
   according to options.

[t] = cputime(;p)
 cputime() returns the CPU time in seconds used by the current
   tela session. cputime(p) returns CPU time from performance data
   array p, previously obtained from perf().

[lat,longit] = ecctogeo(latmag,longmag)
 [lat,long] = ecctogeo(latecc,longecc) transforms eccentric
   geomagnetic latitude and longitude to geographic latitude and longitude.
   All angles in degrees.

[x1,y1,z1] = ecctogeoXYZ(x,y,z)
 [x1,y1,z1] = ecctogeoXYZ(x,y,z) transforms eccentric dipole
   point (x,y,z) to geographic coordinates (x1,y1,z1).

[D;V] = eig(A)
 eig(A) returns the eigenvalues of a square matrix A.
   [D,V] = eig(A) returns the eigenvalues in D and the
   right eigenvectors as columns of V. The eigenvectors
   satisfy A**V == D*V.

[] = eval(s)
 eval("string") executes string as a Tela command, as it had been
   typed from the keyboard.
   The evaluation is done in global context. The symbols appearing
   in the string refer to the global ones.

[y] = evalexpr(s)
 evalexpr("expression") executes string as a Tela command,
   returning its value in y.
   The evaluation is done in global context. The symbols appearing
   in the string refer to the global ones.

[] = export_matlab(fn...)
 export_matlab("file") saves all variables in Tela
   workspace in "file". Any previous contents of "file"
   are overwritten. The data are written in MATLAB
   binary format.

   export_matlab("file","var1","var2"...) saves only the
   specified variables. Notice that you have to give the
   variable names as strings.

   The resulting MAT-file can be read using the
   MATLAB 'load' command.
   
   Limitations (bugs): It is not possible to export
   local variables. If you try, the global ones will
   be written, if they have numeric values. Use
   export_matlab2 to achieve this, and to have explicit
   control of variable naming.
   

[] = export_matlab2(fn...)
 export_matlab2("file", var1,"name1", var2,"name2"...)
   saves objects var1,var2... in MATLAB binary format in "file".
   The objects will be named "name1", "name2"... .
   Any previous contents of "file" are overwritten.
   workspace in "file". Any previous contents of "file"
   is overwritten.

   The resulting MAT-file can be read using the
   MATLAB 'load' command.
   

[A] = eye(n)
 eye(n) returns the (integer) unit matrix of order n.
   n must be a non-negative scalar integer.
   eye(V) where V is a two-element integer vector with
   both elements equal and positive works also, thus
   you can also use eye(size(A)).

[] = fclose(fnum)
 fclose(fnum) closes file with given identification number.
   The fnum must have been previously obtained from fopen.

[] = fformat(fnum,str...)
 fformat(fnum,"format-string",arg1,arg2,...) is similar to format,
   except that it does not output to stdout but to opened file.

[y] = find(x)
 I=find(V) returns the index vector I=(i) for which
   V[i] is nonzero. V must be an integer array. The length
   of I is equal to the number of nonzeros in V.
   If V is multidimensional, it is used in flattened form.

[y] = floor(x)
 floor(x) returns the largest integer which is smaller than x.
   x must be integer or real scalar or array. If it is an array,
   the operation is applied componentwise.

[fnum] = fopen(name,mode)
 fopen("filename",mode) opens a file and returns
   its identifier (integer). The mode parameter can be
   "r" or "w" for reading and writing, respectively.
   If the open is not succesful, -1 is returned.

[] = format(str...)
 format("format-string",arg1,arg2,...) prints "format-string"
   to standard output, replacing occurrences of `format-spec`
   with consecutive args. `Format-spec` is either empty, i.e. ``,
   or of the form

       `[-]w[.d]`.

   Here w is the field width (unsigned integer) and d is the number
   of significant digits, also unsigned integer. By default the
   argument is printed left-justified, but the optional minus sign
   dictates right justification. The backquote character `  can be
   produced by writing it three times: ```.
   
   Hint: You can add any number of spaces before the closing backquote,
   for example `20.7    `.
   These spaces do not affect the output. This feature can be used
   to justify source code lines.

[] = fprintf(fnum,formatstr...)
 fprintf(fnum,"format-string",arg1,arg2,...) is an interface to the C
   fprintf function. The format string should have a percent slot
   for every arg. The args may be integer or real scalars or strings.
   The file identifier fnum must have been obtained from fopen.

   Notice: The stream is not flushed after every fprintf operation,
   but a flush occurs whenever you switch from using fprintf to
   fformat on the same file. Therefore avoid mixing fprintf and fformat
   on the same file if performance is an issue for you!
   

[latmag,longmag] = geotoecc(lat,longit)
 [latmag,longmag] = geotoecc(lat,long) transforms geographic
   latitude and longitude to eccentric geomagnetic latitude and longitude.
   All angles in degrees.

[x1,y1,z1] = geotoeccXYZ(x,y,z)
 [x1,y1,z1] = geotoeccXYZ(x,y,z) transforms geographic
   point (x,y,z) to eccentric dipole coordinates (x1,y1,z1).

[latmag,longmag] = geotomag(lat,longit)
 [latmag,longmag] = geotomag(lat,long) transforms geographic
   latitude and longitude to geomagnetic dipole latitude and longitude.
   All angles in degrees.

[x1,y1,z1] = geotomagXYZ(x,y,z)
 [x1,y1,z1] = geotomagXYZ(x,y,z) transforms geographic
   point (x,y,z) to geomagnetic dipole coordinates (x1,y1,z1).

[X,Y] = grid(x,y)
 [X,Y] = grid(x,y) produces matrices X,Y that are formed from vectors x,y
   such that X[i,j] = x[i] for all j, and Y[i,j] = y[j] for all i.

[X,Y,Z] = grid3(x,y,z)
 [X,Y,Z] = grid3(x,y,z) produces 3D arrays X,Y,Z that ar
   formed from vectors x,y,z such that
   X[i,j,k] = x[i] for all j,k,
   Y[i,j,k] = y[j] for all i,k, and
   Z[i,j,k] = z[k] for all i,j.

[B] = herm(A; P)
 herm(A) is the same as conj(transpose(A)).
   herm(A,P) is the same as conj(transpose(A,P)).
   You can abbreviate "herm(A)" as "A'".

[] = hide(...)
 hide("sym-name",...) sets the 'hidden' attribute to
   specified symbols.

[;ndata,xdata] = hist(x...)
 hist(x) produces a histogram of vector x.
   The range min(x)..max(x) is divided in bins, and the
   number of x values in each bin is counted. The count determines
   the height of each bin.

   hist(x) uses 10 bins, hist(x,n) uses n bins.
   hist(x,n,a) starts from x=a.
   hist(x,n,a,b) ignores x values outside interval a..b.
   Rest of the args may contain other MTV options.
   [ndata,xdata] = hist(args) returns the count and abscissa vectors
   but does not draw anything. bar(xdata,ndata,"lab") can be used to draw
   the histogram later. Graphics options are ignored in this case.

[] = hold(flag)
 hold(on) and hold(off) set the graphics hold mode on and off.
   When hold is on, all graphics commands will be accumulated and
   performed only until hold(off).
   If hold(on) is called many times in succession, also hold(off)
   must be called as many times until the plots are produced.
   For example, if

   function f() {hold(on); plot1(); plot2(); hold(off)};

   and it is called as

   hold(on); f(); plot3(); hold(off);

   then all three plots are actually combined in one plot.

[result] = holdmode(;flag)
 holdmode(overlay) causes held plots to be combined in same figure.
   holdmode(paging) shows them as sequential pages in one window.
   holdmode(stacking) draws them as subplots in one window.
   holdmode() returns the current setting.

[] = import(filename)
 import("file") tries to load the contents of "file" in Tela workspace.
   All files accepted by load are also accepted by import. In addition,
   import accepts more general HDF files and MATLAB binary files.
   Create these files using the MATLAB 'save' command.

   Restrictions:
   1) Only MATLAB files created on a similar architecture can be
   correctly imported. If this rule is not followed, the imported
   data will be garbage!
   2) MATLAB4.0 and higher saves arrays with more than 10000 elements
   as various integer formats, if all elements are whole numbers.
   Tela cannot read these files. A workaround is to perturb one element
   in MATLAB before saving so that it is not exactly integer.

   For filename conventions, see load.

[x] = import1(filename; label)
 import1("file") reads one object from "file". The imported
   object is returned. "File" can be one of the following:

   1) HDF file, in which case the first Scientific Data Set (SDS)
      is imported. The form import1("file.hdf","label") reads SDS
      with label "label", which is not necessarily the first one.

   2) D-style ASCII file of the following format:

        (line 1)   D=Nt dim1 dim2 ... dimN
        (any number M of blank lines or lines starting with '#')
        (line M+2) data1 data2 ....

       where N is the rank of the dataset and t is an optionial
       type specification letter: t may be either 'r', 'i', or 'c'
       for real, integer and complex data, respectively. If t is
       missing, real data are asssumed.

   3) Plain ASCII file of nrows x ncols real numbers. If nrows or
      ncols is 1, it will be returned as a vector, otherwise as a
      matrix. Missing entries are treated as zeros. This format
      is similar to Matlab's load for ASCII, except that '#'
      comments are accepted in the beginning.
       

[B] = inv(A)
 inv(A) returns the inverse of a square matrix A.
   A may be integer, real or complex valued.
   A may also be a scalar, in which case its reciprocal
   is returned.

[f] = invFFT(u; dim)
 invFFT() is the inverse of FFT():

   invFFT(u)_j = (1/n) * sum(c_k * exp(i*(j-1)*(k-1)*2*pi/n), k=1..n)

   Differences to FFT: sign of i is plus, scale factor 1/n.
   

[y] = isCfunction(x)
 isCfunction(x) returns 1 if x is a C-tela function.
   and 0 otherwise.

[y] = isTfunction(x)
 isTfunction(x) returns 1 if x is a function written in Tela
   and 0 otherwise.

[y] = isarray(x)
 isarray(x) returns 1 if x is an array and 0 if it is not.

[y] = ischar(x)
 ischar(x) returns 1 if x is a character and 0 otherwise.

[y] = iscomplex(x)
 iscomplex(x) returns 1 if x is a complex array or scalar,
   and 0 if it is real or integer or a nonnumeric object.

[y] = isdefined(x)
 isdefined(x) returns 1 if x is not undefined and 0 if
   it is undefined. Optional function arguments are undefined
   if not assigned by the caller; isdefined can be used
   inside the function to test whether this is the case.

[y] = isfloat(x)
 isfloat(x) returns 1 if x is a floating point array
   or scalar, and 0 otherwise. Notice the difference between
   isfloat and isreal. isreal(x) is 1 for integer objects,
   while isfloat(x) is 0.

[y] = isfunction(x)
 isfunction(x) returns 1 if x is a function
   (Tela-function, C-tela function or intrinsic function)
   and 0 otherwise.

[y] = isint(x)
 isint(x) returns 1 if x is integer scalar or array
   and 0 if it is not.

[y] = ismatrix(x)
 ismatrix(x) returns 1 if x is a matrix (2D array)
   and 0 if it is not.

[y] = isreal(x)
 isreal(x) returns 1 if x is numerical non-complex
   array or scalar, and 0 otherwise.

[y] = isscalar(x)
 isscalar(x) returns 1 if x is scalar and 0 if it is not.

[y] = isstr(x)
 isstr(x) returns 1 if x is a character or string
   and 0 otherwise.

[y] = isstring(x)
 isstring(x) returns 1 if x is a string and 0 otherwise.

[y] = isundefined(x)
 isundefined(x) returns 1 if x is not undefined and 0 if
   it is undefined. Optional function arguments are undefined
   if not assigned by the caller; isdefined can be used
   inside the function to test whether this is the case.

[y] = isvector(x)
 isvector(x) returns 1 if x is a vector and 0 if it is not.

[L] = length(x)
 length(x) returns the total number of elements in array x.
   If x is scalar, length(x) is 1. If x is undefined, an error
   results.

[x] = linsolve(A,b)
 linsolve(A,b) solves the linear system A**x == b.
   If A is square, the result x is roughly the same as
   computing inv(A)**b (however, using linsolve is
   faster and numerically more accurate). If A is not
   square, a least-square problem is solved. If the system
   is overdetermined, the solution x minimizes the quantity
   |A**x - b|. If the system is underdetermined, the
   solution x minimizes |x| among all x that satisfy
   A**x==b.
   The second argument may be a vector or a matrix.
   If it is a matrix, several linear systems are effectively
   solved simultaneously.

[] = load(filename)
 load("file") loads the contents of "file"
   in Tela workspace.
   "file" must have been previously created using
   the 'save' command; it must be in a certain
   HDF format.

   Filename conventions:
   If the filename starts with "/", "./" or "..",
   it is considered absolute. Otherwise it is searched
   along TELAPATH. This applies to other file
   operations as well.
   
   The counterpart of load is save.
   To read more general HDF files and ASCII files,
   see import1.
   To load more general HDF files and MATLAB binary
   files, see import.

[theta,phi] = m2i(Kp,x,y)
 [theta,phi] = m2i(Kp,x,y) maps the equatorial plane point (x,y,z=0)
   to the northern ionosphere. Inputs: Kp, the Kp index; x,y,z, GSM
   coordinates in Earth radii. Outputs: colatitude and longitude in
   magnetic coordinates in degrees.

[lat,longit] = magtogeo(latmag,longmag)
 [lat,long] = magtogeo(latmag,longmag) transforms geomagnetic
   latitude and longitude to geographic latitude and longitude.
   All angles in degrees.

[x1,y1,z1] = magtogeoXYZ(x,y,z)
 [x1,y1,z1] = magtogeoXYZ(x,y,z) transforms geomagnetic dipole
   point (x,y,z) to geographic coordinates (x1,y1,z1).

[...] = matlab_call(fname...)
 [a,b,c,...] = matlab_call("fname",d,e,f,...)
   calls a Matlab function in a currently running background
   Matlab process. Input arguments (any number) d,e,f,...
   are sent to Matlab prior to call, and output arguments
   (any number) a,b,c,... are collected and returned to Tela
   after the function has completed.

[retval] = matlab_eval(str)
 matlab_eval("command") sends "command" to currently
   running Matlab background process. It returns 1
   if succesful 0 if an error occurred.

[y] = matlab_get(name)
 matlab_get("MatrixName") asks a currently running background
   Matlab process for a variable named "MatrixName", and returns
   its value.

[] = matlab_put(name,value)
 matlab_put("MatrixName",x) tries to interpret x as
   a Matlab matrix and sends it to currently running
   background Matlab process. The matrix is assigned to
   variable "MatrixName" in Matlab side.
   matlab_put returns 1 if successful and 0 if not.

[] = matlab_start(;startcmd)
 matlab_start() starts a new Matlab process on background.
   You can send to it commands with matlab_eval.
   matlab_start("startcmd") uses "startcmd" to start up
   Matlab. The default "startcmd" is "matlab".
   If matlab_start() has already been called, a new call
   is harmless and does nothing.

[] = matlab_stop()
 matlab_stop() stops a currently running Matlab process.

[C] = matprod(A,B; Aflag,Bflag)
 matprod(A,B) returns the matrix product of A and B.
   If at least one of A and B is scalar, matprod(A,B) is the
   same as their ordinary product A*B. If both A and B
   are arrays, their "inner" dimensions must agree.
   That is, the last dimension of A must equal the first
   dimension of B.
   You can abbreviate matprod(A,B) as A**B.

   Optional args: matprod(A,B,aflag,bflag) can be used to
   transpose or Hermitian-conjugate the factors before the
   product. 'n' means no operation, 't' means transpose and
   'h' means Hermitian conjugate. For example,

   matprod(A,B,'h') = A'**B = herm(A)**B
   matprod(A,B,'n','t') = A**B.' = A**transpose(B)

   Normally you need not use matprod explicitly, but you
   can use the operator **, which is internally translated
   to matprod. Hermitian conjugates and transposes in
   connection with ** produce the corresponding 'h' and
   't' options in matprod. For example,

   A'**B        generates       matprod(A,B,'h')
   A.'**B'      generates       matprod(A,B,'t','h')
   A**B.'       generates       matprod(A,B,'n','t')

   and so on. The runtime is optimal for all these operations.

[result] = menu(title...)
 choice = menu("title","choice1","choice2",...) displays
   a menu of choices and returns the number entered by
   the user.

[] = mesh(z...)
 mesh(z[,options]) plots the matrix z as a 3D mesh.

[y] = ones(...)
 ones(n,m...) returns an integer array with all elements
   equal to 1 of size n x m x ... .

   ones(V) where V is an integer vector, and thus
   ones(size(A)) work also.

[] = pcolor(z...)
 pcolor(z[,options]) plots the matrix z as a pseudocolor density plot.

[] = plot(...)
 plot(x1,y1,[options1], x2,y2,[options2],...) is the basic 2D plot function.
   Each vector yi is plotted versus the corresponding xi. All curves yi are
   displayed in the same figure. The option sequences must consist of keyword-
   value pairs. Example:

       x = 0:0.1:4*pi;
       plot(x,sin(x), "linewidth",3,"linecolor",2);

   The abscissa x may be missing, in which case the default of 1:length(y)
   is used. The ordinates y may be matrices; then each row produces one
   curve. If also abscissa x is matrix, the x-value may be different for each
   curve.

[] = plot3(x,y,z...)
 plot3(x,y,z[,options]) produces parametric space curves.
   The quantities x,y,z must have equal ranks, and they can
   be either vectors or matrices. If they are vectors, only
   one space curve is drawn. If they are matrices, the number
   of curves produces equals the number of rows.

[] = plotopt(s)
 plotopt("-3d -colorps -landscape...") sets a set of PlotMTV command
   line options for subsequent graphics commands (global setting).

[] = printf(formatstr...)
 printf("format-string",arg1,arg2,...) is an interface to the C
   printf function. The format string should have a percent slot
   for every arg. The args may be integer or real scalars or strings.

[y] = prod(x)
 y = prod(x) multiplies all the elements of x, is x is an array.
   If x is scalar, it is returned as such.

[y] = rank(x)
 rank(A) returns the number of dimensions of array A.
   The rank of a scalar is 0. The rank of a nonnumeric
   object, including undefined value, is -1. The rank function
   never generates an error.

[y] = round(x)
 round(x) returns the nearest integer.
   x must be integer or real scalar or array. If it is an array,
   the operation is applied componentwise.

[] = save(fn...)
 save("file") saves all variables in Tela workspace
   in "file". Any previous contents of "file" is
   overwritten. The data are written as Scientific
   Data Sets in HDF format.
   save("file","var1","var2"...) saves only the
   specified variables. Notice that you have to give
   the variable names as strings.

   Limitations (bugs): It is not possible to save
   local variables, since they are not bound to
   symbols. If you try, the global one, if any,
   will be saved.
   

[s] = sformat(formatstr...)
 sformat("format-string",arg1,arg2,...) is similar to format,
   except that it does not output to stdout but returns a string
   variable.

[] = showcompiled(filename...)
 showcompiled("filename.ct",f1,f2,...) compiles functions
   f1,f2,... to C-tela code, creating "filename.ct".
   If no suffix is given in "filename", the suffix
   ".ct" will be assumed.
   showcompiled(f1,f2,...) displays on standard output.

[y] = sign(x)
 y = sign(x) returns 1 if x>0, 0 if x==0, and -1 if x<0.
   x must be real. If x is array, the operation is applied componentwise.

[...] = size(x)
 [n,m,...] = size(A) finds out the dimensions of array A.
   The number of n,m... must not exceed rank(A). If rank(A)==0
   (that is, A is scalar), n=size(A) sets 1 to n.
   V = size(A) assigns the dimension vector [n,m,..] to V.
   If A is scalar, V is set to 1, if A is vector, V becomes
   a one-element vector.

[result] = smenu(title...)
 choice = smenu("title","choice1","choice2",...) displays
   a menu of choices and returns the "choice" string corresponding
   to the number entered by the user.

[] = source(fn)
 source("file.t") loads the tela code from given file.

[] = source_silent(fn)
 source_silent("file.t") is similar to source("file.t"),
   but it does not complain if e.g. the file does not exist.

[s] = sprintf(formatstr,arg)
 sprintf("format-string",arg1,arg2,...) is an interface to the C
   sprintf function. The format string should have a percent
   slot for every arg. The args may be integer or real scalars
   or strings.

[y] = streq(s1,s2)
 streq("string1","string2") returns 1 if the argument
   strings are exactly equal and 0 otherwise. If one of
   the args is not a string, the result is also 0.

[x] = strmat(...)
 strmat("string1","string2",...) makes a string matrix
   ouf of individual strings. The strings need not be same length,
   they are padded with zeros (invisible) if they are not.

[x] = strmat2(str; sep)
 strmat2("string") creates a string matrix from "string"
   interpreting the newline character as row ending marker.
   strmat2("string",sep) uses separator sep instead of
   newline char; sep may be either character or string.
   If sep is a string, any character that is a member of sep
   is taken to be a separator. If the rows have unequal lengths,
   they are padded with zeros.

[y] = strstarteq(s1,s2)
 strstarteq("string1","string2") returns 1 if the argument
   strings are equal on the first min(length(s1),length(s2))
   characters and 0 otherwise.
   If one of the the args is not a string, the result is also 0.

[y] = sum(x)
 y = sum(x) sums all the elements of x, is x is an array.
   If x is scalar, it is returned as such.

[] = tic()
 tic() marks the CPU time at which it was invoked.
   To measure CPU time, use tic() and toc().

[t] = toc()
 toc() gives the CPU seconds used since the last call to tic().

[B] = transpose(A; P)
 B = transpose(A) returns a transpose of array A: B[i,j,k...l] = A[l...k,j,i].
   B = transpose(A,P) where P is integer vector transposes the indices in the
   permutation defined by P.
   For example if A has rank 3, B = transpose(A,[2,1,3]) causes the assignment
   B[j,i,k] = A[i,j,k] to be carried out. B = transpose(A) would in this case
   correspond to B[k,j,i] = A[i,j,k].

   You can abbreviate "transpose(A)" by "A.'".

[] = unhide(...)
 hide("sym-name",...) unsets the 'hidden' attribute to
   specified symbols.

[] = vplot(x,y,vx,vy...)
 vplot(x,y,vx,vy[,options]) produces a 2D vector plot of the vector
   field (vx,vy). All arguments x,y,vx and vy must be 2D integer or
   real arrays and of the same size. Each 2D vector will be positioned
   at (x[i,j],y[i,j]) and its direction will be (vx[i,j],vy[i,j]) where
   (i,j) run over rows and columns of the matrices.

[] = whos(;hidden)
 whos() displays names of variables together with their
   types and values, if short. 'Hidden' symbols are not shown.
   whos("hidden") shows also hidden symbols.