Math Package

The Template Numerical Toolkit is used for numerical computing involving matrix. Special functions in the CEPHES linrary are used for statistical tests. Functions include cos, acos, cosh, sin, sinh, asin, tan, tanh, atan, floor, ceil, sqrt, exp, log log10, stat, mod, pow, rad2deg, deg2rad, rand, linear, spline, interpo, cal2jul, jul2cal, msmooth, psmooth, perlin, corr, lfit, mfit, lu, svd, qr, eigenvalue, cholesky.

.cos(array)

Applies basic C math functions to the array element-wise. Functions of cosh, acos, sin, sinh, asin, tan, tanh, atan, floor, ceil, sqrt, exp, and log are implemented.

.stat(array)

Returns the mean and standard deviation of the array. A 2D array will be treated as 1D vector.

.mod(array, v)

Applies mod function to all array elements.

.mod(arr, par)

Applies mod function to all array elements. The size of the parameter array par must be the same as that of the array arr.

.pow(arr, v)

Applies pow function to all arr elements.

.pow(arr, par)

Applies pow function to all arr elements. The size of the parameter array par must be the same as that of the array arr.

.rad2deg(array)

Converts all array elements from radius to degree.

.deg2rad(array)

Converts all array elements from degree to radius.

.rand(arr[, seed])

Fill array elements with random numbers between 0 and 1. You can set a seed for the random number generator.

.linear(array, n)

Linearly interpolates the array n times, i.e., inserts n interpolcated data bentween grids. If the array has only one vector, the interpolcaiton is one dimensional; otherwise two dimensional.

.spline(array, n)

Cubic spline interpolation of the array for n times, i.e., inserts n interpolcated data bentween grids. If the array has only one vector, the interpolcaiton is one dimensional; otherwise two dimensional.

.interpo(arr, n, method)

Interpolates the array n times, i.e., inserts n interpolcated data bentween grids. If arr has only one vector, the interpolcaiton is one dimensional; otherwise two dimensional. The method is a user supplied callback function that should returns interpolation weighting factors of 0 to 1 for a variable at the first the second grid points respectively.

.cal2jul(year, month, day)

Returns the Julian day number for the Gregorian calender date.

.cal2jul(cal, jul)

Converts Gregorian calender date (in the array cal) to Julian day numbers and saves the results in the array jul. The array cal must has three vectors containing data for year, month, and day.

.jul2cal(jul)

Returns the Gregorian calender date (year, month, and day) for the Julian day.

.jul2cal(jul, cal)

Converts Julian day numbers in the array jul to Gregorian calender date (year, month, and day) and save the results in the array cal.

.msmooth(arr, n)

1D-moving average smooth of data in the array arr. The number of points used for smoothing will be 2n+1.

.psmooth(arr, n, m)

1D-polynomial (power m) smoothing of data in the array arr. The number of points used for smoothing will be 2n+1.

.perlin(arr, n[, callback])

Generates Perlin noise. The arrary arr must be two dimensional filled with random number. If the callback function is provided, the function will try to get persistent parameters for noises of different frequencies from the callback, which should take a number between 1 and n (corresponding to low and high frequencies, respectively) and return a persistent parameter. The input n should be greater 1 and less than 17.

.corr(x, y)

Returns the correlation coefficient between vectors x and y, the significance level at which the null hypothesis of zero correlation is disproved, and the Fisher's number.

.lfit(x, y)

Fits vectors x and y to a straight line y = a + b*x and returns a, b, the chi-square, and the probable uncertainties of a and b.

.mfit(x, y)

Multi-linear fitting of the equation y = a0 + a1*x1 + a2*x2 + ... + an * xn Returns coefficients a0 to an. The input y is a m by 1 vector; and x is a array of m by n.

.lu(A, L, U, P)

For an m-by-n matrix A with m >= n, the LU decomposition is an m-by-n unit lower triangular matrix L, an n-by-n upper triangular matrix U, and a permutation vector piv of length m so that A(P,:) = L*U.

.svd(A, L, U, S)

For an m-by-n matrix A with m >= n, the singular value decomposition is an m-by-n orthogonal matrix U, an n-by-n diagonal matrix S, and an n-by-n orthogonal matrix V so that A = U*S*V'. The singular values, S[k], are ordered so that S[0] >= S[1] >= ... >= S[n-1]. Returns the matrix rank.

.qr(A, L, U, S)

For an m-by-n matrix A with m >= n, the QR decomposition is an m-by-n orthogonal matrix Q and an n-by-n upper triangular matrix R so that A = Q*R. Returns 1 if matrix is full rank, 0 otherwise.

.eigenvalue(A, L, U, S)

Computes eigenvalues and eigenvectors of a real (non-complex) matrix. If A is symmetric, then A = V*D*V' where the eigenvalue matrix D is diagonal and the eigenvector matrix V is orthogonal. That is, the diagonal values of D are the eigenvalues, and V*V' = I, where I is the identity matrix. The columns of V represent the eigenvectors in the sense that A*V = V*D. If A is not symmetric, then the eigenvalue matrix D is block diagonal with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues, a + i*b, in 2-by-2 blocks, [a, b; -b, a].

.cholesky(A, L)

For a symmetric, positive definite matrix A, this function computes the Cholesky factorization, i.e. it computes a lower triangular matrix L such that A = L*L'. If the matrix is not symmetric or positive definite, the function computes only a partial decomposition. Returns 1 if original matrix to be factored was symmetric positive-definite; 0 otherwise.