&NUMBER(TYPE, NUM(1), NUM(2), .......)

This function has an option keyword, TYPE, and a set of strings which are normally numbers. Here, the valid forms of the function are:

     &NUMBER(?, STRING)
     &NUMBER(REAL, RN)
     &NUMBER(INTEGER,  RN)
     &NUMBER(SIN,  RN)
     &NUMBER(SIND,  RN)
     &NUMBER(COS,  RN)
     &NUMBER(COSD, RN)
     &NUMBER(TAN,  RN)
     &NUMBER(TAND,  RN)
     &NUMBER(ACOS,  RN)
     &NUMBER(ASIN,  RN)
     &NUMBER(ATAN, RN)
     &NUMBER(ATAN2, X, Y )
     &NUMBER(SQRT,  RN)
     &NUMBER(LN,  RN)
     &NUMBER(EXP,  RN)
     &NUMBER(ABS,  RN)
     &NUMBER(MIN,  RN(1), RN(2), ...)
     &NUMBER(MAX,   RN(1), RN(2), ...)
     &NUMBER(MEAN,   RN(1), RN(2), ...)
     &NUMBER(SORT,  RN(1), RN(2), ...)
     &NUMBER(INTERPOLATE,   X, X(1), ... Y(n))
     &NUMBER(NORM,   RN(1), RN(2), ...)
     &NUMBER(DOT,   RN(1), RN(2), ...)
     &NUMBER(UNIT_VEC,   RN(1), RN(2), ...)
     &NUMBER(CROSS,   RN(1), RN(2), ...)
     &NUMBER(SCALE,  SF, RN(1), ...)
     &NUMBER(ADDV,   SF, RN(1), ...)
     &NUMBER(3PTS2Q, P1(1), P1(2),  ... P3(3))
     &NUMBER(VECG2L, Q VG(1), VG(2), VG(3) )
     &NUMBER(VECL2G, Q VL(1), VL(2), VL(3) )

The result produced depends, of course, upon the value of TYPE. The first option, ?, is different from the others, in that it returns a value of .TRUE. if the string is a valid number or .FALSE. if it is not. All of the others return a set of numbers.

As an example of how these functions operate, consider the following:

     &NUMBER(REAL, (2+3)**8/2.)

This function will read the string "(2+3)**8/2." and convert it to a number, and then convert this number back into a string with eight significant figures. It is this final string which will be passed to the command interpreter. The function with a type of INTEGER operates in a similar manner, except that here, the result will be an integer. The idea behind these two is that in some cases a string representing a number may become too long to convert; therefore, strings can be "compressed" with this function.

The first several TYPEs take a single number as input and return a single number. The particular conversion which occurs with most values of TYPE is rather obvious from the name. In particular, SIN, COS, TAN produce strings with the value of the trigonometric functions of the same name and with the argument in radians. The trigonometric functions which end in D assume that the argument will be in degrees. The functions ATAN, ATAN2, ACOS, and ASIN are inverse trigonometric functions, and ATAN2 returns the angle who's tan is X/Y. The angles returned here are in radians. The types of LN, EXP, SQRT, and ABS produce the natural logarithm, the exponential, the square root, and the absolute value respectively.

The remainder of TYPEs take more than a single number as arguments. The MAX and MIN return the extremes of the arguments. A type of MEAN returns the mean of a set of numbers, while a a type of SORT sorts a set of numbers in ascending order. INTERPOLATE takes the first number as the desired "X" value, the next N/2 numbers as an array of Xs and the last N/2 numbers as an array of Ys. It returns the Y values which corresponds to the first number input. Of course, the X values must be in increasing order.

The next remainder of TYPEs allow one to treat strings as vectors of numbers. For a type of NORM, MOSES will return a string which is the square root of the sum of the squares of the numerical arguments. For a TYPE of DOT, the number of numerical arguments must be divisible by two, and it returns the inner product of two vectors represented by the 2*n numbers. With UNIT_VEC the value returned is the input vector scaled by its length. With SCALE, the first number is a multiplier and the function will return N numbers which represent the remaining numbers multiplied by the first. ADDV takes the first number and uses it as a scalar multiplier for the first N/2 numbers and it vectorially adds the result to the second N/2 numbers.

The last three functions deal with matrices and vectors. The TYPE 3PTS2Q returns a direction cosine matrix. Here P1, P2, and P3 are the coordinates of three points (You need nine numbers here). The "origin" of the local system is at P1. The vector from P1 to P2 points "in the direction of the local X axis, and the vector from P1 to P3 points in the direction of the local Z axis. This direction cosine matrix will transform local vectors into global ones. The TYPE VECG2L transforms a vector in global coordinates to local ones and VECL2G performs the inverse. Here Q is a direction cosine matrix (there are nine numbers for Q) VG is a vector in global coordinates and VL is a vector in local coordinates.