NAME

PROTOTYPE

ARGUMENTS

int iDimX

dimension for X-array

int iDimY

dimension for Y-array

int iDimZ

dimension for Z-array

int iDimT

dimension for T-array

char *pcFmt

option string, allowing to predefine up to four array variables and optionally make these visible as input or output fields of dimensions specified with the first four arguments iDimX..iDimT. The first letter pcFmt[0] of pcFmt determines whether array X is input ( pcFmt[0]='i'), output ( pcFmt[0]='o') or only available for internal use ( pcFmt[0]= any other char). Similarly for the next three letters and the arrays Y, Z and T. Likewise, letters '[' and ']' map the corresponding array to input or output fields of the type string.

char *pcProg

string holding program source code

unitptr uHost

host unit

RETURN VALUE:

SYNOPSIS:

DESCRIPTION:

SUPPORTED SYNTAX:

Primitive Data Types:

   const n=10/4, f=10./2;

Example:

   const n=2, pi=4*atan(1);
   static float a[2*n], b[n]={-0.5,0.5}, c[]={pi/2,pi,3*pi/2};
   float *p,r;

   static char s[]="hello world", mystr[4]="abc";
   s[0] = 'H'; s[6] = '\n';

Struct Data Types:

   struct mytype {
      int i=4711, j;
      float af[] = {1,2,3};
      char *string = "hello";
   } u,v[100];

   struct mytype x, y[12];
   ...

   u := x; // now u independent copy!
   u.af[2] = 1234; // access an element

   u = x; // will u only let reference x

   x = mytype();
   for (i=0; i<100; i++) v[i] = mytype();

   INP struct mytype xx;
   OUT struct mytype yy;

   void foo(int i, struct mytype z) {
       z.string += " world";
       z.i = i;
   }
   ...
   foo(34,u);
   // now u.i = 34 and u.string = "hello world"

Input and Output fields:

    OUT { float x,y; char ac[5]; float af[10]; }

Synchronization of Input and Output fields:

Dynamic Arrays:

String Inputs and String Outputs:

Functions:

   float myfun(float x);

Implicit Variables:

Classes:

   class foo x, y[10], z(3,4);

E.g. the following would be illegal:

   INP int iDim;
   class foo z(iDim,4);

   ...
   y[3] = z; // make y[3] reference instance z
   y[4] = foo(1,2); // create y[4] as new instance
   u = z.method(4.56); // invoke method of z
   u = y[3].method(4.56); // the same via y[3]
   y[3] := z; // make y[3] a copy of instance z
   ...

Class instances can occur as members of structs:

   struct mix {
      int i;
      class foo obj;
   } x,y;

   x.obj.method(4.56); // does not work

   class foo p;
   ...
   p = x.obj;
   // now access x.obj via p:
   p = foo(1,2); // instantiation
   p.method(4.56); // invoke foo-method on obj

   static class foo x, y[10], z(3,4);

   static class foo z[]; // has initially 0 elements
   z = resize(20);
   printf("%d\n",dimof(z));

   x = NULL;

Template Classes:

   class foo <thistype,thattype> u(4711);
   ...

Public Functions and Class Containers:

Implicit Declarations:

   // start of program here!
   foo1(void) { i=5; printf("%g\n",i/2); }
   foo2(void) { i=7; printf("%g\n",i/2); }
   foo1(); foo2();

   // start of program here!
   foo1(void) { i=5; printf("%g\n",i/2); }
   int i;
   foo2(void) { i=7; printf("%g\n",i/2); }
   foo1(); foo2();

Operations:

Control Constructs:

Comments:

Built-in Functions:

A few additional functions are provided:

     for (i=bgnof(a); i<endof(a); i++)

Predefined functions with array arguments:

RESERVED WORDS:

The following may not be used as variable identifiers:

STRING AND ARRAY HANDLING:

    char a[] = "hello world";
    pi = 3.14;
    printf("%s\n",a+pi-1);

    sprintf(a,"%s","new text");

     s = strdup(s,n) + p + strdup(s+n);

Printing of Array Elements:

     printf("A vector: %5.2v3f---%vd\n",afVec,afVec);

   A vector: 1.00 2.00
      3.00 4.00
      5.00 6.00
      7.00---1 2 3 4 5 6 7

Dimension Revision Directive:

    static float a[]={1,2,3,4,5}, i=1;
    ...
    myfun((DIM 3) a, (DIM i+1)(a+1))

POINTERS:

    static float *p=NULL,*q="abc";

    p = new(d); // allocation of d elements
    p = resize(n); // resize to n elements
    resize p,q,r = n; // resize several pointers
    p = p + "hello"; // string concatenation
    p += "hello"; // the same effect
    p = a + i; // ref to array el a[i]
    p = (DIM 2) a+i; // dto., but make .p appear as
                      // if only 2-dimensional
    p = vecfun(42); // allocation with result
                         of vector valued function

    p = p + vecfun(42);

   p = NULL;

Pointer Initialization:

   float fac(float i) {
      float *p=new(10+i);
      if (i==1) return 1;
      else return i*fac(i-1);
   }

EXCEPTION HANDLING:

   throw(char *pcErrType, char *pcFmt, ..)

   pcErrType = "ident1:ident2:...identk"

   catch(Arg1) { ... statements ... }
   catch(Arg2) { ... statements ... }
   ...
   catch(Argk) { ... statements ... }
   

1. exceptions signalling bad argument parameters:

    "badarg:type"
    "badarg:value"
    "badarg:array"
    "badarg:array:type"
    "badarg:value:none"
    "badarg:array:dim"
    "badarg:object"

2. exceptions signalling an attempt at a bad operation:

    "badop"
    "badop:div0"
    "badop:index"
    "badop:array"
    "badop:array:dim"
    "badop:array:type"
    "badop:object"

3. exceptions signalling a detected bad result outcome:

   "badres:array"
   "badres:singular"

PROG UNITS AS NST EXCEPTION HANDLERS:

MATRIX ALGEBRA EXTENSIONS:

   A := 2*(A^2+2*B+1)/B;

   A[first..last] := someOtherArray;

   A[dimof(A)-1,0] := A;

   char *pc="hello", *w="world", *r1, *r2;
   r1 = pc + w; // concatenation
   r2 := pc + w; // elementwise addition

   A := 2*eigval(B) - 1;

   scalar := vec1*vec2;

    A := (A + A')^(-2);

Syntax for Matrix Algebra Expressions:

1.:

a bracket must not contain any matrix products or divisions, except those that can be written as powers of a square matrix (e.g., (A*A+1) is forbidden, but (A^2+1) is allowed).

2.:

If a bracket contains a matrix expression, the expression must start with an array (i.e., instead of (2-3*A) we must write (A*(-3)+2) or -(A*3-2)).

Cross Product:

   y := a*b + 4*c*(d-2);

Special Matrix Functions:

   v := fermi(W*v);

col(A,j,n):

j-th column of A; n must equal the column dimension of A

row(A,i,n):

i-th row of A; n must equal the column dimension of A

rect(A,x,y,dx,dy,n):

rectangular submatrix of dx columns and dy rows, starting at column x and row y. Again, n is A's column dimension.

Example:

   row(A,i,n) := row(A,j,n);

Imported Matrix Functions:

   float *vec;
   ...
   vec := foo(); // (1)
   vec = foo(); // (2)

Vector norm computation:

     stdev = | A - |A|[0] | / sqrt(dimof(A));

Handling of Dimension Mismatches:

    f := v1*v2;

EXECUTION OF CREATED UNIT:

ADAPTATION OF CREATED UNIT:

LOAD AND SAVE:

Load and Save for Pointers:

CONTROL MODES:

Note:

PROG_UNIT AS AN OPERATOR UNIT:

PROG_UNIT AS A VIRTUAL OPERATOR UNIT:

CALLING SELECTED NST UNITS:

Note:

Example:

    printf("Iteration %3.f:\n",count++);
    for (j=0; j<NX; j++) {
       Y[j] += X[j];
       if (Y[j)>100) Y[j]=100;
       printf("Y(%3.f) = %7.2f\n",j,Y[j]);
    }
    return;
    INIT:
    count=0;
    RESET:
    for (j=0; j<NX; Y[j++]=0);

DEBUGGING:

print_lines(int iYes)

turn on/off printing of executed programming lines

print_instructions(int iYes)

turn on/off printing of executed instructions

print_stack(int iYes)

turn on/off printing of instruction stack pointer

PERFORMANCE ISSUES:

    for (statement; i < expr; i++) ...

SYSTEM CALLS:

   ls
   wc *

EXTENDING THE SET OF BUILT-IN FUNCTIONS:

    #import sharedLibName

    #import "string.str*"
    #import string.islower

    char *FUNCTIONS[] = {"min<2>","fun<1>","quad_sum<4>",(char*)0};
                       
    float min(float x, float y) { ... }
    float fun(float x) { ... }
    float quad_sum(float x, float y, float z, float t) { ... }

"ident"

(to be distinguished from "indent<0>" for a parameterless function) introduce a constant ident in the name space of the prog_unit, taking its value to be the value of a float variable of the same name that must be exported by the library (the prog_unit will use the value of this variable at the time of its (the prog_unit's) creation. Any later changes will be ignored).

"func(D)"

define for the prog_unit a function func() with a parameter list specified by the string D. D is a usual C-style parameter list declarations without parameter names. The only allowed type identifiers are byte*, char*, int, int*, float and float* (Example: foo(int*,float,char*)). Additionally, the last parameter may be followed by three dots to indicate a variable number of parameters. If there is no intervening comma between the last type specifier and the three dots, this indicates a variable (possibly 0) number of parameters of the last specified type. If there is an intervening comma, this indicates a variable number of float or read-only char* parameters (as explained for the '-'. old-style specifier). The corresponding library function will be passed two arrays:

     piDim[0..iArg-1] dimension of each argument
     ppfArg[0..iArg-1] adress of each argument

Function pointer arguments:

    FUNCTIONS[] = {
      ...
    "myfun(int, float (*)(char*,float), void (*)(void))",
      ...
    }

     foo(4711,f(int,char*)); // a call, not a declaration!
     foo2(f(float*)); // use of another version of f()

Old style function declarations:

"func<?>"

define for the prog_unit a function func() with a variable number of float parameters. The corresponding library function func must be declared as func(int iArg,float *pfArg), with iArg passing the number of parameters found in the prog_unit call, and pfArg[0..iArg-1] providing their values.

"func<S>"

define for the prog_unit a function func() with a parameter list specified by a string S (for details, see below). The corresponding library function will be passed two arrays.

     piDim[0..iArg-1] dimension of each argument
     ppfArg[0..iArg-1] adress of each argument

Argument types for an old-style declaration are:

"."

specifies a single float argument. ppfArg[iArgPos] will be the adress of a copy of its value (i.e., the original value cannot be changed), piDim[iArgPos] will be 0.

";"

specifies a single int argument. ppfArg[iArgPos] will be the adress of a copy of its value (which will be passed as an int; the original value cannot be changed), piDim[iArgPos] will be 0.

"$"

specifies a string argument. ppfArg[iArgPos] will point to the adress of a null-terminated char* string which holds a copy of the original string (i.e., again access is readonly). piDim[iArgPos] will hold the size of the string (including its null-byte) and is, therefore, non-zero.

"*"

specifies a float array argument. ppfArg[iArgPos] will point to the address of the original array, i.e., elements can be read and written. piDim[iArgPos] will hold the dimension of the array. A parameter &Ident will be treated as an array of one element.

"%"

specifies a byte array argument. ppfArg[iArgPos] will point to the address of the original byte array, i.e., elements can be read and written. piDim[iArgPos] will hold the dimension of the array.

"&"

specifies a int array argument. ppfArg[iArgPos] will point to the address of the original int array, i.e., elements can be read and written. piDim[iArgPos] will hold the dimension of the array.

"+"

may occur only as the last letter of S and indicates a variable (including zero) number of additional, trailing float array argument parameters, each with dimension and address passed as decribed for '*'.

"-"

may occur only as the last letter of S and indicates a variable (including 0) number of additional, trailing single float or string array argument parameters (.ie, types '$' or '.'). They can be distinguished by the value of piDim[iArgPos] (0 in conjunction with a non-NULL ppfArg[iArgPos] indicates that a float was provided; all other cases indicate that an array was provided. IMPORTANT NOTE: the called routine always gets passed a float array, even if the caller provided a char string).

"="

may occur only as the last letter of S and indicates a variable (including 0) number of additional, trailing int argument parameters.

"!"

may occur only as the last letter of S and indicates a variable (including 0) number of additional, trailing int array argument parameters, each with dimension and address passed as decribed for '%'.

":"

may occur only as the last letter of S and indicates a variable (including 0) number of additional, trailing byte array argument parameters, each with dimension and address passed as decribed for '%'.

PASSING EXCEPTIONS FROM EXTENSION LIBRARIES:

   void prog_throw(char *pcErrType, char *pcFmt, ..)

DEFINING BUILT-IN EXTENSION LIBRARIES:

Type Conversions:

Avoiding Name Conflicts:

Example:

      char *FUNCTIONS[] = {"__:", /* define name prefix */
                           "I_see",
                           "mul_vec<.*>", sum<?>, strcpy<*$>,
                           (char*)0};

      /* first entry specifies additional prefix "__" for all
         referenced library names that follow.
      */

      float __I_see = 42;
      
      float __mul_vec(int *piDim, float **ppfArg) {
          float fArg0 = ppfArg[0][0]; /* first arg is scalar */
          float *pfArg1= ppfArg[1]; /* 2nd arg is array */
          int i, iDimArg1 = piDim[1]; /* its dimension */
          for (i=0; i<iDimArg1; i++) pfArg1[i] *= fArg0;
          return 0; /* return value not used here */
      }

      float __sum(int iArgs, float *pfArgs) {
          float fSum=0;
          while (--iArgs >= 0) fSum += pfArgs[iArgs];
          return fSum;
      }

      float __strcpy(int *piDim, float **ppfArg) {
          int i, iDim = piDim[0];
          float *pfDest = ppfArg[0];
          char *pcStr = (char*) ppfArg[1];
          int iLen = strlen(pcStr);
          if (iDim>iLen-1) iDim=iLen-1; /* ensure limits */
          for (i=0; i<iDim; i++) *pfDest++ = *pcStr++;
          *pfDest = 0; /* terminating null */
          return i;
      }

Overloading of functions:

     *FUNCTIONS[] = {
        "_0_:", "foo(void)",
        "_1_:", "foo(int)",
        "_2_:", "foo(float)",
        NULL };

     float _0_foo(void) {
        ... here implementation of foo(void) ...
     }
     float _1_foo(int *piDim, int **ppfArg) {
        ... here implementation of foo(int) ...
     }
     float _2_foo(int *piDim, float **ppfArg) {
        ... here implementation of foo(float) ...
     }

Initialization and Clean-up for Extension Libraries:

       nst_prog_loadlib(pcName)

Shared Variables per Loadlib and Prog_unit Instance:

      nst_prog_def_userobj(pAdr,pFree)

      pAdr = nst_prog_userobj()

IMPLEMENTING CLASSES IN IMPORT LIBARIES:

   char *Accnt[]={"account<1>","deposit<1>",
                  "withdraw<1>","balance<>",
                  "FREE_account<>",NULL};

   char **CLASSES[]={Accnt,..more classes..,NULL};

   // the implementation of the functions:
   
   typedef struct account_{
           float fAmount; ... } account_t;

   // the constructor:

   account_t *account(float fInitialAmount) {
      account_t *pData=calloc(1,sizeof(account_t));
      pData->fAmount = fInitialAmount;
      ...
      return pData;
   }
   // the methods:

   float deposit(float fVal,account_t *pD){
      pD->fAmount += fVal; return 0;
   }
   float withdraw(float fVal, account_t *pD) {..}
   float balance(account_t *pD) {return pD->fAmount;}
   void FREE_account(account_t *pD) {free(pD);}

Additional argument type tokens:

"@"

indicates a parameter of an element function that is a reference to an instance of the class to which the element function belongs (for each such argument, the corresponding C function will be passed a handle to the data object of the passed instance). The passed dimension will be 1, the passing mechanism is the same float** array as for * or $ parameters.

"#"

a variable number of @ - arguments, passing mechanism as above.

"a".."z":

another class argument, where the expected class is indicated by the letter and must be from the same loadlib as the class of the called element function. Letters 'a', 'b', ... 'z' denote the first, second, ... 26-th class definition in the CLASSES[] array of the loadlib (the number of classes useable in this way is limited to max. 26).

   ...
   "float fun0(void)",
   "float *fun1(void)",
   "void fun2(float)",
   "class fun3(int)",

   void *fun3(int *piDim, void **ppvArg, void *pD) {..}

    x = y.fun3(42);

Special functions:

SAVE_xxxx<>

indicates that class xxxx has a data save function that must be implemented as char *SAVE_xxxx(FILE*,dataptr) and that should save the data object instance passed with its last argument to the stream passed with its first argument. A return value of NULL should indicate correct operation, everything else is interpreted as an address of an error message.

RESTORE_xxxx<>

indicates that class xxxx has a data restore function that must be implemented as char *RESTORE_xxxx(FILE *fp,dataptr *pPtr). This function is expected to be able to read the data record produced by SAVE_xxx and to initialize the data object that is passed with the last argument appropriately. Note that the last parameter is not the pointer pPtr to the data object but instead the adress &pPtr of that pointer! The reason is that the RESTORE function is expected to create an new data instance when the address pPtr of the data object is NULL (indicating that no instantiation has yet occurred). In this case, the address of the newly created instance must be returned in *pPtr. In all other cases (i.e., pPtr != NULL), the pointer value pPtr *must not be changed*, however, any elements inside the data object can be rebuilt in any way (as required by the read data). The return value of the routine is used to transmit an error status: A return value of NULL should indicate correct operation, everything else is interpreted as a char* address of an error message.

LOAD_xxxx<>

[deprecated, only for backward compatibility] a matching data load function that should be able to restore the state of the class instance from a data record previousy saved by the associated SAVE_xxxx function. Signature is char*(FILE*,dataptr). Unlike the RESTORE function, a LOAD function cannot pass back a newly allocated instance (since the last argument is a dataptr and not a dataptr*). Therefore, classes that have a LOAD function do not permit static declarations of uninstantiated class variables or assignments that involve such variables, since the resulting data files could not be read back by the load function.

DESCRIBE_xxxx<>

indicates presence of a function char *DESCRIBE_xxxx(dataptr) that is expected to return the address to a string holding some descriptive information about the data instance referenced by the passed dataptr (used, for instance, by Neo to display pin info).

CTRL_xxxx<>

specifies a control call handler for the instances of class xxxx. The handler must be implemented with the fixed signature void CTLR_xxxx(int mode, void *obj) (i.e., the first parameter will pass the NST ctrl mode, the last parameter the object handle).

COPY_xxxx<>

indicates presence of a function dataptr COPY_xxxx(dataptr,dataptr) which will copy a class instance referenced by the second argument, optionally utilizing the instance referenced by the first argument (ownership of this instance is passed to the COPY routine). The following requirements must be met by the implementation: when the first argument is is NULL, the return value must be the address of a newly allocated copy; when the second argument is NULL, the reaction must be as if a reference to a default instance had been passed as the second argument (for more details, see the nst_typedef() manpage). When a COPY_xxxx function has been defined, two important things happen: (i), instances of the class can be defined as INP or OUT variables, giving rise to NST pins of the newly defined class and allowing transport of (access to) the corresponding objects via NST wires. (ii) instances of the class can be assigned to each other, e.g., a=b; (will invoke COPY_xxxx(a,b)). For more comments on the implementation of COPY_xxxx and user-defined NST datatypes see the nst_typedef MANPAGE.

COMPATIBLE_xxxx<>

sometimes, even instances from the same class may differ sufficiently that one might want to forbid assignments such as a=b or connections of respective pins by wires. Such restrictions can be built by specifying a int COMPATIBLE_xxxx(dataptr, dataptr) function that compares two instances and returns nonzero, when they are compatible, and 0 otherwise. This will restrict wires and assignments in a corresponding way.

UPDATE_xxxx<>

this entry must be present when the class has array variables that shall be dynamically resizeable from a loadlib routine. In this case, the implementation has to define a function pointer void (*UPDATE_xxxx)(void). The corresponding function call UPDATE_xxxx() has then to be issued by any loadlib function that has resized the memory of one or several of the class array variables (the function ptr will have been set by NST to a notifier function whose call triggers a re-registration of the changed class variable addresses and dimensions).

Element variables:

";"

specifies an int

"."

specifies a float (optional).

"*"

specifies an array of floats.

"&"

specifies an array of int.

"%"

specifies an array of bytes.

"$"

specifies a null terminated string. In this case, the implementation is expected to always hold a null-terminated string at the returned address, unless the returned addres was NULL. The variable will then appear like a dynamic char pointer variable of corresponding, variable length.

   char *Accnt[]={...,"*vec","val",...}
   ...
   typedef struct account_{
           float fAmount;
           float fVec[10];
           float fVal;
   } account_t;

   float *vec(int *piDim, account_t *pD){
         *piDim=10; return &(pD->fVec); }
   float *val(int *piDim, account_t *pD){
         return &(pD->fVal); }
   ...

   static class account a(5);
   ...
   a.vec[3] = 3.56;
   a.val = 4 + a.vec[0];
   ...

   static class foo x,y,z;
   ...

C-Style Interface Specification:

   ":thisarray",
   "thatfun<.&c!>",
   "SAVE_fxy<>",

   "byte* thisarray",
   "thatfun(float,int*,class foo,int* ...)",
   "SAVE_fxy()"

   "thatfun(float x, int *pi,class foo c,int* ..)",

   "foo(float x, int n=5, char *s=NULL, int *p=0)"

   "float" --> "."
   "float*" --> "*"
   "int" --> ";"
   "int*" --> "&"
   "byte*" --> "%"
   "char*" --> "$"
   "class" --> "@"
   "..." --> "-"
   "int ..." --> "="
   "float* ..." --> "+"
   "int* ..." --> "!"
   "byte* ..." --> ":"
   "class ..." --> "#"

Redimensioning of Array Element Variables:

   typedef struct account_{
           float fAmount;
           float *pfVec; // now dynamic!
           float fVal;
   } account_t;

   ..,"resize<1>", "UPDATE_account<>",...

   void (*UPDATE_account)(void) = NULL;
   
   float resize(float iNewDim, account_t *pD) {
      pD->pfVec = realloc(pD->pfVec,
                          ((int)iNewDim)*sizeof(float));
      UPDATE_account();
      return 0;
   }
   ...

PREDEFINED EXTENSION LIBRARIES:

Loadable library on string operations:

string.so

the NST string library wraps for the prog_unit a number of string functions, mostly analogous to the familiar C functions: Available routines include

   strcmp(s1,s2), strncmp(s1,s2,n),
   strcpy(to,from), strncpy(to,from), strcat(s1,s2),
   strstr(s1,s2), strchr(s1,c), strrchr(s2,c),
   strpbrk(s1,s2), memove(s1,s2,n), memset(s1,f,n),
   tolower(c), toupper(c), isdigit(c), isalpha(c),
   islower(c), isupper(c), atof(s), atoi(s),
   strtol(s,&offset,base), strtof(s,&offset),
   strtoken(tok,s,sepset) [cf. below]

       strstr("abcde","cd") = 2
       strstr("abcde","CD") = -1
   

     strtoken(tok,s,d); ... use tok ...
     while (strtoken(tok,"",d)) { ... use tok ...}

Loadable library on low-level file access:

file.so

provides some routines for low-level file access:

       fopen(fileid,m), fclose(fp), feof(fp), stdin,
       stdout, stderr, EOF, ftell(fp), rewind(fp),
       fseek(fp,i,w), SEEK_SET, SEEK_CUR, SEEK_END,
       fflush(fp), fgetc(fp), ungetc(c,fp), fputc(c,fp),
       fgets(s,n,fp), fputs(s,fp), skip_comments(fp,c),
       fprintf(fp,fmt,..), fscanf(fp,fmt,..),
       fprintf_vec(fp, fmt, pfX, split)

      fprintf_vec(stdout,"%g", Y,-1); // print Y vector elements ending w. "\n"
      fprintf_vec(stdout,"%7.3f",Y, 4); // print Y vector elements in block of 4


   

Loadable library on Open-GL solid routines:

solid.so

the NST solid-library now contains a number of wrappers and a FUNCTIONS[]-line to provide a direct interface for the prog_unit to some GL-functions, as well as to some NST-rendering routines built on top of GL. The routines have an effect only when the prog_unit is in the scope of a view3d unit, otherwise they return with no further action. Available routines and constants include

        glRotatef(a,x,y,z), glTranslatef(x,y,z), glScalef(x,y,z),
        glMultMatrixf(M[16]), glPushMatrix(), glPopMatrix(),
        glColor3f(r,g,b), glPolygonMode(w,m),
        GL_POINTS, GL_LINES, GL_FILL, GL_FRONT, GL_BACK,
        nstBox(dx,dy,dz), nstPyramid(dx,dy,dz), nstTetrahedron(h),
        nstCircleSegments(n), nstCylinder(r,h), nstSphere(r),
        nstArrowZ(len,r)
        nstMaterial(m,r,g,b,ambient,diffuse,specular,emission),
        nstLighting(on), nstPuma(th[6]),
        nstDHTrafo(distance,twist,offset,theta),
        nstPoints(V[3n]),nstLineStrip(V[3n]), nstLineLoop(V[3n]),
        nstPolygon2(V[2n]),nstLineStrip2(V[2n]),nstLineLoop2(V[2n])

Loadable library on vector operation utilities:

vector.so

Contains: Routines for sorting indexing and handling sorted vector elements; Routines for creating random sequences without doubles or drop outs; Routines for histogramming; Routines for setting a vector; Routines for complex vectors; Routines for statistic analysis; Unitary vector routines; Routines for shifting vectors and time series representations; Miscellaneous More info see extra manpage vector.so

    qsort(afRes,afX) -- quicksort vector afX[].
    index(afIndex, afX) -- compute index array from data vector.
    percentindex(pfSorted, percent) -- returns interpolated value into sorted array
    findindex(pfIndex, pfX, pfBook, highIdx) -- find and return closest indeces
    remap(pfRes, pfSorted, drop0, dropEnd) -- remap sorted array by interpolation.
    checkorder(pfX) -- check ordering of vector, return bit mask
    permuteindex(afIndex) -- compute random index sequence afIndex[]
    nextindex(afIndex) -- return next index in array and mark used
    histo(pfCount, pfMidpoints, pfX) -- compute histogram of pfX[] elements.
    binning(pfCount, pfMidpoints, pfX) -- bin and count vector elements pfX[]
    histoline(pfLine, pfY, pfMidpoints) -- compute polyline for histogram.
    zero(pfX) -- set vector to zero.
    linspace(pfX, x1, x2) -- return vector pfX[n] of n equally spaced points
    logspace(pfX, x1, x2) -- return vector of n logarithmically
    rand(pfX,l,h) -- return random vector with uniform distribution between [l,h[.
    randn(pfX,std) -- return random vector with normal distribution, width std
    gauss(std) -- return single random variable with gauss distribution,
    quantile(pfRes, pfX) -- compute required quantile levels.
    quantile_i(pfRes, pfX) -- compute required quantile levels by interpolation.
    mean(pfX) -- return mean value of vector pfX[]
    adev(pfX) -- return average deviation from mean value of vector pfX[]
    var(pfX) -- return variance of vector pfX[]
    std(pfX) -- return standard deviation value of vector pfX[]
    moments(pfRes, pfX) -- return several moments and quantiles levels of
    norm0(pfX) -- return maximum norm of vector pfX[] (=max(|x_i|)).
    norm1(pfX) -- return absolute norm of vector pfX[] (=sum(|x_i|)).
    norm2(pfX) -- return Euclidean norm of vector pfX[] (== norm(pfX)).
    sum(pfX) -- return sum of all elements of vector pfX[].
    prod(pfX) -- return product of all elements of vector pfX[].
    min(pfX) -- return minimal element of vector pfX[].
    max(pfX) -- return maximal element of vector pfX[].
    mini(pfX) -- return index of minimal element of vector pfX[].
    maxi(pfX) -- return index of maximal element of vector pfX[].
    sprod(pfX1, pfX2) -- return scalar (inner) product of vectors pfX1[] and pfX2[].
    mprod(pfRik, pfMij, pfMjk, j) -- matrix product pfRik[]=pfRij[] * pfRjk[].
    multadd(pfY, a, pfX, b) -- return vector Y=a*X+b and its norm.
    multaddv(pfY, pfA, pfX, pfB) -- return vector Y=A.*X+B and its norm.
    add(pfDest, pfX1, pfX2) -- return addition vector pfDest[i] = pfX1[]+pfX2[]
    diff(pfDest, pfX1, pfX2) -- return subtraction vector pfDest[] = pfX1[]-pfX2[]
    scale(pfDest, fScale, pfX) -- returns scaled vector pfDest[i] = fScale * pfX[i]
    clip(pfDest, pfX, lowClipValue, highClipValue) -- returns vector pfDest[] cliped
    threshold(pfRes,pfX,threshold) -- threshold operation returns vector with 0 or 1s
    reverse(pfRes, pfX) -- reverses order of vector elements pfX. (pfRes==pfX ok)
    transpose(pfNM, pfMN, n) -- transpose matrix with initially n columns.
    switch_input(pfX, pfVectors, select) -- switch one select-ed section to pfX.
    switch_output(pfVectors, pfX, select) -- copy pfX to one (select-ed) section
    switch(pfDest, pfSrc, select) -- switch_input() or switch_output()
    convolve(pfRes, pfX, pfKernel) -- kernel convolution, only full operations
    convolve_0(pfRes, pfX, pfKernel, kernelRefPos) -- convolution w. zero padding
    convolve_e(pfRes, pfX, pfKernel, kernelRefPos) -- convolution w. edge extention
    convolve_c(pfRes, pfX, pfKernel, kernelRefPos) -- convolution w. cyclic extention
    convolve_(pfRes, pfX, pfKernel, kernelRefPos, mode) -- switched convolution.
    sparse_copy(pfRes,offRes,incRes, pfX,offX,incX, maxCopy) -- sparse copy.
    push(pfX, x) -- shift vector pfX[] right, return last, insert x at pos 0.
    pop(pfX, x) -- return pos 0, shift vector pfX[] left, insert x at end.
    acov(pfACV, pfX) -- compute data auto covariance function.
    acor(pfACV, pfX) -- compute data auto corelation function.
    size(pfX) -- return length of vector.
    popup(string) -- write string to a popup alert window
    "scopy", sparse sparse_copy()
    "cabs", complex absolute
    "cangle", complex angle
    "csquare", complex square
    "eprod", elementwise product
    "elog10", elementwise log base 10
    "elog", elementwise log
    "chirpwave",sin wave with drifting frequency
    "chirpwave_linWL", same with linear drifting wavelength
    "DEG2RAD", Const
    "RAD2DEG", Const
    "linreg", linear least square regresion
    "linmedreg",linear robust median regression
    "set", set
    "cmp_ge", compare greater equal
    "cmp_le", compare less equal
    "cmp_eq", compare equal
    "tic", read elapsed time/ms + reset
    "toc", read time/ms
    "ranks" mid-ranks of unordered set

Loadable library on spectral methods:

spectral.so

Contains: extremly fast real-complex FFT, window operations, power spectra. See spectral.so.

FILE