The result of an elemental function has the same shape as its argument(s). Each element of the result is defined by applying the function to the corresponding element of the argument.

The following table is very similar to Table 5.3 in Ousterhout's 1994 classic Tcl and the Tk Toolkit:

Function	Result
abs(x)	Absolute value of x
acos(x)	Arc cosine of x, in the range 0 to π
asin(x)	Arc sine of x, in the range -π/2 to π/2
atan(x)	Arc tangent of x, in the range -π/2 to π/2
atan(y,x)	Arc tangent of y/x, in the range -π to π
atan2(y,x)	Alias for atan
ceil(x)	Smallest integer not less than x
cos(x)	Cosine of x (x in radians)
cosh(x)	Hyperbolic cosine of x
exp(x)	ex, where e is base of natural logarithms
floor(x)	Largest integer not greater than x
fmod(x,y)	x%y
hypot(x,y)	√(x2+y2)
isnan(x)	1 if x is NaN, 0 otherwise
log(x)	logex (natural logarithm of x)
log(x,y)	logyx
log10(x)	log10x
nint(x)	Nearest integer to x
pow(x,y)	xy
random(x)	f32 or f64 random number r such that 0 ≤ r < x
round(x)	Alias for nint
sign(x)	Sign of x,   i.e. (x>0)-(x<0)
sin(x)	Sine of x (x in radians)
sinh(x)	Hyperbolic sine of x
sqrt(x)	√x
tan(x)	Tangent of x (x in radians)
tanh(x)	Hyperbolic tangent of x

The following data-type conversion functions are also elemental:
c8(x)
f32(x)
f64(x)
i8(x)
i16(x)
i32(x)
u8(x)
u16(x)
u32(x)
Here are some examples of their use:

% [nap "f32(97 .. 102)"] all; # convert from i32 to f32
::NAP::43-43  f32  MissingValue: NaN  References: 0  Unit: (NULL)
Dimension 0   Size: 6      Name: (NULL)    Coordinate-variable: (NULL)
Value:
97 98 99 100 101 102
% [nap "u8('abcdef')"]; # Display ASCII codes for 'abcdef'
97 98 99 100 101 102
% [nap "c8(97 .. 102)"]; # Reverse this process
abcdef

A reduction or insert function is one which has the effect of inserting a binary operator between the cells of its argument. If the argument is a vector then its elements are the cells and the result is a scalar. If the argument is a matrix then its rows are the cells and the result is a vector containing the sum of each column. Such functions are termed reductions because the result has a rank which is one less than the argument.

A classic example is the ∑ summation operation, which corresponds to the NAP function sum. This can be used as follows to produce a scalar (rank 0) result by summing a vector (rank 1):

% [nap "sum({0.5 2 -1 8})"]
9.5

% nap "mat = {
{2 5 0}
{6 7 1}
}"
::NAP::49-49
% [nap "sum mat"]
8 12 1
% [nap "sum(mat,1)"]
7 14

The NAP reduction and scan functions are listed in the following table:

Function	Type	Result
count(x[,r])	reduction	Number of non-missing elements in rank-r sub-arrays of x
max(x[,r])	reduction	Maximum of rank-r sub-arrays of x
min(x[,r])	reduction	Minimum of rank-r sub-arrays of x
prod(x[,r])	reduction	Product of rank-r sub-arrays of x
psum(x)	scan	Multi-directional partial-sums of x (see below)
psum1(x[,r])	scan	Uni-directional partial-sums of rank-r sub-arrays of x (see below)
sum(x[,r])	reduction	Sum of rank-r sub-arrays of x

The optional second argument of reduction functions is called the verb-rank (as in J). It specifies the rank of the sub-arrays (cells) to which the process is applied. In the above example the verb-rank was 1, so the matrix was split into vectors (corresponding to each row) before doing the summation. This final summation process is always done by summing along the first (most significant) dimension.

It is possible to specify a verb-rank of 0. This is useful with count() because each (rank 0) element is processed separately. If it is missing the result is 0, otherwise it is 1. So this gives us an elemental function for testing whether values are missing. Note that the rank does not change in this case! E.g.

% [nap "count({4 _ 2 -9}, 0)"]
1 0 1 1

If x is a vector then these two functions give the same result. Let r be this result. Each element of r is defined by

	I
r I =	∑	x i
	i=0

For example:

% nap "x = {2 7 1 3 8 2 5 0 2 5}"
::NAP::14-14
% [nap "psum(x)"] value
2 9 10 13 21 23 28 28 30 35
% [nap "psum1(x)"] value
2 9 10 13 21 23 28 28 30 35

Missing values are treated as zeros. E.g.

% [nap "psum{5 -9 _ 6 4}"]
5 -4 -4 2 6

The following example shows how partial sums can be used to calculate a 3-point moving-average in an efficient manner:

% nap "ps = 0 // psum(x)"
::NAP::25-25
% $ps value
0 2 9 10 13 21 23 28 28 30 35
% [nap "(ps(3 .. 10) - ps(0 .. 7)) / 3.0"] value
3.33333 3.66667 4 4.33333 5 2.33333 2.33333 2.33333

Missing values can be handled as follows:

% nap "x = f64{2 7 1 _ 3 8 2 5 _ 0 2 5}"
::NAP::187-187
% nap "ps = 0 // psum(x)"
::NAP::192-192
% $ps value
0 2 9 10 10 13 21 23 28 28 28 30 35
% nap "psc = 0 // psum(isPresent x)"; # psum of counts
::NAP::203-203
% $psc value
0 1 2 3 3 4 5 6 7 7 8 9 10
% nap "i = 0 .. 9"
::NAP::209-209
% [nap "(ps(i+3) - ps(i)) / (psc(i+3) - psc(i))"] value
3.33333 4 2 5.5 4.33333 5 3.5 2.5 1 2.33333

Function	Result
coordinate_variable(x[,d])	Coordinate variable of dimension d (default 0)
label(x)	Descriptive title
missing_value(x)	Value indicating null or undefined data
nels(x)	Number of elements = prod(shape)
rank(x)	Number of dimensions = nels(shape)
shape(x)	Vector of dimension sizes

Function	Result
sort(x[,r])	Sort rank-r sub-arrays of x into ascending order over most significant dimension
reshape(x)	Spread the elements of x into a vector with shape nels(x)
reshape(x,s)	Reshape the elements of x into an array with shape s
transpose(x)	Reverse the order of dimensions of x
transpose(x,p)	Permute the dimensions of x to the order specified by p

Here are some examples of the use of these functions:

% [nap "sort {6.3 0.5 9 -2.1 0}"]
-2.1 0 0.5 6.3 9
% [nap "sort({{3 0 2}{1 9 1}})"]; # sort each column
1 0 1
3 9 2
% [nap "sort({{3 0 2}{1 9 1}}, 1)"]; # sort each row
0 2 3
1 1 9
% [nap "reshape {{1 3 7}{0 9 2}}"] all
::NAP::217-217  i32  MissingValue: -2147483648  References: 0  Unit: (NULL)
Dimension 0   Size: 6      Name: (NULL)    Coordinate-variable: (NULL)
Value:
1 3 7 0 9 2
% [nap "reshape({6.3 0.5 9 -2.1 0}, {2 4})"] all
::NAP::224-224  f64  MissingValue: NaN  References: 0  Unit: (NULL)
Dimension 0   Size: 2      Name: (NULL)    Coordinate-variable: (NULL)
Dimension 1   Size: 4      Name: (NULL)    Coordinate-variable: (NULL)
Value:
 6.3  0.5  9.0 -2.1
 0.0  6.3  0.5  9.0
% [nap "transpose {{1 3 7}{0 9 2}}"] all
::NAP::228-228  i32  MissingValue: -2147483648  References: 0  Unit: (NULL)
Dimension 0   Size: 3      Name: (NULL)    Coordinate-variable: (NULL)
Dimension 1   Size: 2      Name: (NULL)    Coordinate-variable: (NULL)
Value:
1 0
3 9
7 2

The function solve_linear(A[,B]) solves a system of linear equations defined by matrix A and right-hand-sides B. B can be either a vector or a matrix (representing multiple right-hand sides). If B is omitted then the result is the matrix inverse.

If the system is over-determined (more equations than unknowns) then the result is the solution of the linear least-squares problem. This solution minimizes the sum of the squares of the differences between the left and right-hand sides.

The following system of linear equations is solved by the following example:
  3x − 4y = 20
−5x + 8y = −36

% nap "A = {
{3 -4}
{-5 8}
}"
::NAP::14-14
% nap "B = {20 -36}"
::NAP::17-17
% nap "x = solve_linear(A, B)"
::NAP::20-20
% $x a
::NAP::20-20  f64  MissingValue: NaN  References: 1  Unit: (NULL)
Dimension 0   Size: 2      Name: (NULL)    Coordinate-variable: (NULL)
Value:
4 -2

We can check the result using matrix multiplication:

% [nap "A . x"]
20 -36

The functions correlation and moving_correlation both calculate Pearson product-moment correlations. Function correlation calculates correlations between variables defined by the dimensions of its (one or two) arguments. Function moving_correlation calculates pattern (spacial) correlations between a (vector or matrix) window variable and variables defined by moving a window of the same shape around a larger array of the same rank.

Both functions handle missing values by omitting cases where one or both values are missing. The result consists of two layers. Layer 0 contains the correlation values themselves. Layer 1 contains the corresponding number of (non-missing) cases (sample size n) used to calculate these values.

Both functions produce an f64 result if any of the data is f64, but otherwise the result is f32.

If y is not specified then it defaults to x.

The 1st (most significant) dimensions of x and y must have the same size, since this corresponds to the number of cases. (For time-series this dimension is time.) The remaining dimensions (if any) of x and y are essentially merged into column dimensions, but do appear in the result.

For example, let x be a 80×3 matrix and y a 80×5 matrix. The command

nap "r = correlation(x, y)"

A simple example is:

% [nap "correlation({1 3 _ 6 6}, {6 6 4 2 3})"]
-0.924138 4

The following example is from Table 15.2 (page 274) of Schaum's Outline of Theory and Problems of Statistics, M.R. Spiegel, 1961:

% [nap "correlation{
	{64 57 8}
	{71 59 10}
	{53 49 6}
	{67 62 11}
	{55 51 8}
	{58 50 7}
	{77 55 10}
	{57 48 9}
	{56 52 10}
	{51 42 6}
	{76 61 12}
	{68 57 9}
}"] -f %6.4f
 1.0000  0.8196  0.7698
 0.8196  1.0000  0.7984
 0.7698  0.7984  1.0000

12.0000 12.0000 12.0000
12.0000 12.0000 12.0000
12.0000 12.0000 12.0000

The ranks of x and y must be the same. (The current version supports ranks 1 and 2 only.)

If x and y have the same shape then the result contains a single correlation, calculated by treating the elements of each array as two lists of values.

If x and y have different shapes then the smaller of x and y is a window (chip) array which is moved around in the other array, producing a correlation for each position.
lag₀ is vector of row lags (default: all possible)
lag₁ is vector of column lags (default: all possible)

Function inPolygon(x, y, p) tests whether the points defined by x and y are inside the polygon defined by p. The result is

• -1 if (x,y) is outside the polygon.
• 0 if (x,y) is exactly on an edge (boundry) of the polygon.
• 1 if (x,y) is inside the polygon.

There are currently just two closely related grid functions, invert_grid and invert_grid_no_trim. These can be applied to

• one-dimensional data to define a piecewise-linear mapping as the inverse of a given piecewise-linear mapping.
• two-dimensional data to define a piecewise-bilinear mapping as the inverse of a given piecewise-bilinear mapping.

There is only a minor difference between these two functions. Function invert_grid suppresses edges (rows and columns in 2D case) containing nothing except missing values. Function invert_grid_no_trim does no such trimming.

In the 1D case we have a piecewise-linear mapping from x to y, and we want a piecewise-linear mapping from y to x. The functions are called by
invert_grid(y,ycv)
or
invert_grid_no_trim(y,ycv)
where y is the known mapping (and has a coordinate variable corresponding to x)
and ycv is the desired new y coordinate variable.

The following example starts with a mapping from x to y defined by the two lines joining the three points (0, 0), (2, 1) and (5, 4). The difference between invert_grid and invert_grid_no_trim is shown by attempting to extrapolate to y = −1 with both these functions. Both produce the inverse mapping from y to x defined by the four lines joining the five points (0, 0), (2, 1), (3, 2), (4, 3) and (5, 4). Function invert_grid_no_trim generates the requested point for y = −1 (with x missing) whereas invert_grid suppresses this point.

% nap "y = {0 1 4}"
::NAP::56-56
% $y set coo "{0 2 5}"
% [nap "coordinate_variable(y) /// y"]
0 2 5
0 1 4
% [nap "ycv = -1 .. 4"] value
-1 0 1 2 3 4
% nap "x = invert_grid(y,ycv)"
::NAP::75-75
% $x all
::NAP::75-75  f32  MissingValue: NaN  References: 1  Unit: (NULL)
Link: ::NAP::76-76
Dimension 0   Size: 5      Name: (NULL)    Coordinate-variable: ::NAP::72-72
Value:
0 2 3 4 5
% [nap "coordinate_variable(x) /// x"]
0 1 2 3 4
0 2 3 4 5
% nap "xnt = invert_grid_no_trim(y,ycv)"
::NAP::86-86
% $xnt all
::NAP::86-86  f32  MissingValue: NaN  References: 1  Unit: (NULL)
Link: ::NAP::87-87
Dimension 0   Size: 6      Name: (NULL)    Coordinate-variable: ::NAP::83-83
Value:
_ 0 2 3 4 5
% [nap "coordinate_variable(xnt) /// xnt"]
-1  0  1  2  3  4
 _  0  2  3  4  5

In the 2D case, the functions are called by
invert_grid(y,ycv,x,xcv),
or
invert_grid_no_trim(y,ycv,x,xcv),
where matrix y defines a mapping from ij space to y.
matrix x defines a mapping from ij space to x.
The result is a 3D array whose