| 
                Function name
               | 
              
                Description
               | 
            
            
              | 
                abs(real/complex)
               | 
               Absolute value  | 
            
            
              | 
                arg(real/complex)
               | 
               phase (result wraps at 180/-180 degrees)  | 
            
            
              | 
                arg_rad(real/complex)
               | 
               phase (radians). Result wraps at pi/-pi radians  | 
            
            
              | 
                atan(real/complex)
               | 
               Arc tangent  | 
            
            
              | 
                cos(real/complex)
               | 
               Cosine | 
            
            
              | 
                db(real/complex)
               | 
               dB(x) = 20 * log10 (mag(x)) | 
            
            
              | 
                diff(real)
               | 
               Return derivative of argument  | 
            
            
              | 
                exp(real/complex)
               | 
               Exponential | 
            
            
              | 
                fft(real [, string])
               | 
               Fast Fourier Transform  | 
            
            
              | 
                FIR(real, real [, real])
               | 
               Finite Impulse Response digital filter  | 
            
            
              | 
                Floor(real)
               | 
               Returns argument truncated to next lowest integer | 
            
            
              | 
                GroupDelay(real/complex)
               | 
               Returns group delay of argument | 
            
            
              | 
                Histogram(real, real)
               | 
               Returns histogram of argument  | 
            
            
              | 
                Iff(real, any, any)
               | 
               Returns a specified value depending on the outcome of a test | 
            
            
              | 
                IIR(real, real [, real])
               | 
               Infinite Impulse Response digital filter  | 
            
            
              | 
                im, imag(real/complex)
               | 
               Return imaginary part of argument  | 
            
            
              | 
                integ(real)
               | 
               Returns integral of argument  | 
            
            
              | 
                Interp(real, real [, real, real])
               | 
               Interpolates argument to specified number of evenly spaced points  | 
            
            
              | 
                IsComplex(any)
               | 
               Returns TRUE if argument is complex  | 
            
            
              | 
                length(any)
               | 
               Returns number of elements in vector.  | 
            
            
              | 
                ln(real/complex)
               | 
               Natural logarithm  | 
            
            
              | 
                log, log10(real/complex)
               | 
               Base 10 logarithm | 
            
            
              | 
                mag, magnitude(real/complex)
               | 
               Magnitude (same as abs()) | 
            
            
              | 
                maxidx(real/complex)
               | 
               Returns index of vector where largest value is held  | 
            
            
              | 
                Maxima(real [, real, string])
               | 
               Returns locations of maxima of specified vector  | 
            
            
              | 
                mean(real/complex)
               | 
               Returns statistical mean of all values in vector  | 
            
            
              | 
                Mean1(real [, real, real])
               | 
               Returns mean of data in given range | 
            
            
              | 
                minidx(real/complex)
               | 
               Returns index of vector where smallest value is held  | 
            
            
              | 
                Minima(real [, real, string])
               | 
               Returns locations of minima of specified vector  | 
            
            
              | 
                norm(real/complex)
               | 
               Returns argument scaled so that its largest value is unity.  | 
            
            
              | 
                ph, phase(real/complex)
               | 
               Returns phase of argument | 
            
            
              | 
                phase_rad(real/complex)
               | 
               As ph() but result always in radians | 
            
            
              | 
                Range(real/complex [, real, real])
               | 
               Returns range of vector  | 
            
            
              | 
                re, real(real/complex)
               | 
               Return real part of argument  | 
            
            
              | 
                Ref(real/complex)
               | 
               Returns reference of argument  | 
            
            
              | 
                Rms(real)
               | 
               Returns accumulative RMS value of argument  | 
            
            
              | 
                RMS1(real [, real, real])
               | 
               Returns RMS of argument over specified range | 
            
            
              | 
                rnd(real)
               | 
               Returns random number  | 
            
            
              | 
                RootSumOfSquares(real [, real, real])
               | 
               Returns root sum of squares of argument over specified range  | 
            
            
              | 
                sign(real)
               | 
               Return sign of argument  | 
            
            
              | 
                sin(real/complex)
               | 
               Sine  | 
            
            
              | 
                sqrt(real/complex)
               | 
               Square root | 
            
            
              | 
                tan(real/complex)
               | 
               Tangent  | 
            
            
              | 
                Truncate(real [, real, real])
               | 
               Returns vector that is a sub range of supplied vector | 
            
            
              | 
                unitvec(real)
               | 
               Returns vector of specified length whose elements are all 1  | 
            
            
              | 
                vector(real)
               | 
               Returns vector of specified length with each element equal to its index  | 
            
            
              | 
                XFromY(real, real [, real])
               | 
               Returns array of values specifying horizontal locations where specified vector crosses given y value  | 
            
            
              | 
                YFromX(real, real [, real])
               | 
              
                Returns array of values specifying the vertical value of the specified vector at the given x value.
               |