The following is a summary of all the various mathematical functions provided in the Real Statistics Resource Pack.
These functions are organized into the following categories:
- Matrix functions
- Simultaneous linear equations
- Prime numbers
- Rational numbers
- Bitwise arithmetic
- Graph theory
- Eigenvalues and eigenvectors
- Other linear algebra functions
- Evaluation of a function
- Numerical differentiation and integration
- Roots of continuous functions
- Local maxima/minima
- Global maximum/minimum
- Complex numbers
- Complex matrices
- Complex linear equations
- Complex eigenvalues and eigenvectors
- Spline interpolation
Matrix functions
| DET(R1) | same as MDETERM(R1). |
| DIAG(R1) | array function that returns a column vector with the values on the diagonal of the matrix in range R1 (esp. useful when R1 is a square matrix) |
| DIAGONAL(R1) | array function that returns a square matrix whose main diagonal consists of the elements in range R1 and has zeros elsewhere |
| IDENTITY(k) | array function that returns a k × k identity matrix; if k is omitted then the size of the highlighted range is used instead |
| SEQ(nrows, ncols, start, incr) | array function that returns an nrows × ncols array containing the sequence of numbers starting from start (default 1) and incrementing by incr (default 1); if nrows and/or ncols are omitted then the dimension(s) of the highlighted range are used instead |
| MCONST(s, nrows, ncols) | array function that returns an nrows × ncols array containing the constant value s; if nrows and/or ncols are omitted then the dimension(s) of the highlighted range are used instead |
| ISCELL(R1) | TRUE if R1 is a single cell and FALSE otherwise |
| ISSQUARE(R1) | TRUE if R1 is a square range and FALSE otherwise |
| LENGTH(R1) | length of matrix in R1 = the square root of the sum of the squares of all the elements in R1 (esp. useful for column or row vectors) |
| NORM(R1) | array function that returns the normalized version of the matrix in range R1 |
| MERGE(R1, R2) | array function which merges ranges R1 and R2, i.e. it returns a range containing the values in R2 to the right of those in R1 |
| TRACE(R1) | trace of the matrix in R1 |
| SSCP(R1) | equivalent to MMULT(TRANSPOSE(R1),R1) |
| MPOWER(R1, k) | array function that returns the square matrix in R1 multiplied by itself k times |
| MPROD(R1, R2, R3, R4) | array function that returns the matrix product of R1, R2, R3 and R4 (or R1, R2, and R3 if R4 is omitted or R1 and R2 if R3 is omitted) |
| MSUB(R1, R2) | array function that returns the matrix difference of R1 minus R2; R1 and R2 must have the same size and shape. For any element in R1 and/or R2 that is not numeric, the corresponding element in the output will be blank. |
| KMULT(R1, R2) | array function that returns the Kronecker product of the matrices in arrays R1 and R2 |
| KSUM(R1, R2) | array function that returns the Kronecker sum of the matrices in arrays R1 and R2 |
Simultaneous linear equations
| ELIM(R1) | array function which outputs the results of Gaussian Elimination on the augmented matrix found in the array R1. The shape of the output is the same as the shape of R1 |
| LINEQU(R1) | array function which returns a column vector with solutions to linear equations defined by R1; returns an error if no solution or the solution is not unique |
By default, each of these functions assumes that an entry with an absolute value less than 0.0001 is equivalent to zero. This value can be changed by using the optional prec argument in ELIM(R1, prec) and LINEQU(R1, prec).
Prime Numbers
| PrimeCount(n, start) | the number of prime numbers between start and n (inclusive) |
| IsPrime(n) | TRUE if n is a prime number |
| NextPrime(n) | next prime number after n |
| PriorPrime(n) | largest prime number smaller than n |
| NthPrime(n) | the nth prime number |
| PrimeList(start, size) | a column array with size number of prime numbers starting with the first prime ≥ start |
| Factors(n) | a column array containing the prime factors of n (with repetitions if necessary) |
| PrimeFactors(n) | an array whose 1st column contains the prime factors of n and whose 2nd column contains the number of repetitions of each prime factor. |
| Divisors(n) | a column array containing the factors of n |
Rational Numbers
FRACS(n): returns an array with three columns. Column 1 contains the values in Qn in decimal form, and the other two columns contain the corresponding h and k values for an h/k in Qn
NFRAC(n) = the number of unique elements in Qn
EULER(n) = Euler’s function at n
FRAC2DEC(n, m) = a text representation of m/n as a decimal where 1 ≤ m < n
FRAC_REP(n, m) = the number of repeating digits in the decimal representation of m/n
FRAC_FIXED(n, m) = the number of fixed digits in the decimal representation of m/n
If m is omitted it defaults to 1.
Bitwise Arithmetic
| BIT_AND(m, n) | bitwise And of the binary values of the integers m and n |
| BIT_OR (m, n) | bitwise Or of the binary values of the integers m and n |
| BIT_XOR (m, n) | bitwise Xor of the binary values of the integers m and n |
| BIT_RSHIFT(m, shift) | bitwise result of shifting the binary equivalent of the integer m shift units to the right (if omitted, shift defaults to 1) |
| BIT_LSHIFT (m, shift) | bitwise result of shifting the binary equivalent of the integer m shift units to the left (if omitted, shift defaults to 1) |
Graph Theory
MSTKruskal(R1, brief): returns an array with the rows from R1 that constitute a minimum spanning tree for R1 using the Kruskal algorithm assuming that brief = FALSE (default).
MSTPrim(R1, brief): returns an array with the rows from R1 that constitute an MST for R1 using the Prim algorithm assuming that brief = FALSE (default).
MSTVectors(R1, brief, p, Rw): returns an n-1 × 3 array where each row in the output consists of two nodes (i.e. row numbers for rows in R1) that represent an edge in an MST for R1 followed by the distance between the nodes (assuming brief = FALSE, the default).
Eigenvalues and Eigenvectors
For an n × n array R1, the following are array functions:
eigVAL(R1, order, check, iter, prec): returns a 3 × n array. The first two rows of the output consist of the real and imaginary parts of the n eigenvalues of the square matrix A corresponding to the data in R1. The third row of the output consists of the values det(A−λI) for each eigenvalue λ.
eigVECT(R1, order, check, iter, prec): returns an n+4 × n array. The first two rows of the output consist of the real and imaginary parts of the n eigenvalues of the square matrix A corresponding to the data in R1. Below each real eigenvalue λ in the first two rows (i.e. in the columns where the second row is zero) is an n × 1 unit eigenvector corresponding to λ. In the second-to-last row of the output are the values det(A−λI). In the last row of the output, below each real eigenvalue λ and eigenvector X is the value max {bi: i = 1 to n} where B = AX− λX.
eigMultVECT(R1, lambda, prec): outputs an array whose columns are mutually orthogonal eigenvectors corresponding to the eigenvalue lambda for the square matrix R1; prec is a small positive number (default .0001) where values ≤ prec are treated as if they were zero.
If order is TRUE, -1 or omitted then the eigenvalues are listed in order from highest in absolute value to smallest. If order is FALSE or 0 then they are listed in order from highest to lowest. Finally, if order = +1 then eigenvalues are not sorted.
The following array functions support square matrices with only real eigenvalues.
eigVALReal(R1, order, check, iter, prec)
eigVECTReal(R1, order, check, iter, prec)
The output is the same as for eigVAL and eigVECT except that the second row of the output (containing the imaginary part of the eigenvectors) is omitted since it is presumed that all the eigenvalues are real and so don’t have an imaginary part. If R1 has a non-real eigenvalue, then the first row of the output will contain the value “imag” for each non-real eigenvalue.
The following array functions are similar to eigVALReal and eigVECTReal, except that they should only be used with symmetric R1.
eigVALSym(R1, order, check, iter, prec)
eigVECTSym(R1, order, check, iter, prec)
Other Linear Algebra Functions
SCHUR(R1, iter, order): returns matrices Q and T such that A = QTQT is a Schur’s factorization of A
SCHURQ(R1, iter, order): returns only matrix Q of the Schur’s factorization of A
SPECTRAL(R1, iter): returns a 2n × n range whose top half is the matrix U and whose lower half is the matrix D in the spectral decomposition of A where A is the matrix of values in range R1.
SVD_U(R1, iter) = U matrix of the singular vector decomposition (SVD) for the matrix A corresponding to range R1, Here A = UDVT where U and V are orthogonal matrices and D is a diagonal matrix.
SVD_D(R1, iter) = D matrix of the SVD for the matrix A corresponding to range R1
SVD_V(R1, iter) = V matrix of the SVD for the matrix A corresponding to range R1
The argument iter specifies the number of iterations used. If omitted it defaults to 100 iterations. order is as for eigVAL (see above).
MSQRT(R1): produces a k × k array which is the square root of the matrix represented by range R1
PseudoInv(R1, iter, prec): returns the pseudo-inverse of the matrix in R1. If iter = 0, then R1 has full rank; if iter > 0 then the SVD approach is used; if iter < 0 then the Gaussian elimination approach is used; values ≤ prec (default .00001) are treated as if they were zero.
For an m × n range R1, we have the following functions. Values smaller than prec are treated as if they were zero
QRFactorR(R1, prec): returns the n × n array R for which A = QR (reduced QR factorization) where A is the matrix in R1. If prec is omitted it defaults to 0.
QRFactorQ(R1, prec): returns the m × n array Q for which A = QR (reduced QR factorization) where A is the matrix in R1.If prec is omitted it defaults to 0.
QRFactor(R1, prec): returns an m+n × n array. The first m rows of the output is Q and the next n rows of the output is R where A = QR (reduced QR factorization) and A is the matrix in range R1. If prec is omitted it defaults to 0.
QRFullR(R1, prec): returns the m × n array R for which A = QR (full QR factorization) where A is the matrix in R1. If prec is omitted it defaults to 0.
QRFullQ(R1, prec): returns the m × m array Q for which A = QR (full QR factorization) where A is the matrix in R1. If prec is omitted it defaults to 0.
QRFull(R1, prec): Produces an m × m+n array. The first m columns of the output is Q and the next n columns of the output is R where A = QR (full QR factorization) and A is the matrix in range R1. If prec is omitted it defaults to 0.
MRANK(R1, prec) = the rank of the matrix specified in range R1. The function treats numbers smaller than prec as if they were zero. If prec is omitted it defaults to .00001.
QRSolve(R1, R2) – assuming R1 is an m × n range describing matrix A and R2 is an m × 1 range describing the column vector C, QRSolve outputs an n × 1 column vector X containing the solution to AX = C
For a k × k array R1
CHOL(R1) = the lower triangular k × k matrix L such that LLT is the Cholesky decomposition of the matrix in R1.
QRInverse(R1) = inverse of the matrix described by range R1 using QR Factorization
Evaluation of a Function
FUNC(x, R1, Rx) = f(x)
FUNC2(x, y, R1, Rx, Ry) = f(x,y)
FUNC3(x, y, z, R1, Rx, Ry, Rz) = f(x,y,z)
R1 is a cell that contains a formula that represents the function f(x), f(x,y), or f(x,y,z) where x is referenced by the address of cell Rx, y is referenced by the address of cell Ry and z is referenced by the address of cell Rz.
If Rx is omitted, then it defaults to the first cell referenced in R1. If Ry is omitted, then it defaults to the second cell referenced in R1. Finally, if Rz is omitted, then it defaults to the third cell referenced in R1.
FUNC2D(R1, xlo, xup, ylo, yup, xincr, yincr, prec, Rx, Ry): returns an array with data for a function f(x,y) expressed in cell R1 for x values in the range xlo to xup in increments of xincr and for y values in the range ylo to yup in increments of yincr.
prec is a small positive number (default 0.00000001). Any row or column heading value that is less than or equal to prec is treated as zero.
Numerical Differentiation and Integration
DERIV(x, R1, incr, Rx) = the derivative f ′(x)
DERIV2(x, R1, incr, Rx) = the second derivative f ″(x)
GRADIENT2(x, y, R1, incr, Rx, Ry): 2 × 1 array containing the gradient of f(x,y)
GRADIENT3(x, y, z, R1, incr, Rx, Ry, Rz): 3 × 1 array containing the gradient of f(x,y,z)
GRADIENT(R0, R1, incr); column array containing the gradient of f(X) at X = the value in column array R0, where R1 contains the expression for f(X).
HESSIAN2(x, y, R1, incr, Rx, Ry): 2 × 2 array containing the Hessian of f(x,y)
HESSIAN3(x, y, z, R1, incr, Rx, Ry, Rz): 3 × 3 array containing the Hessian of f(x,y,z)
INTEGRAL(R1, lower, upper, iter, ttype, Rx) = the integral ∫ f(x) dx between lower and upper. If lower is omitted then -infinity is used, while if upper is omitted then +infinity is used. ttype is the estimation type (0 = Simpson’s rule, 1 = midpoint rule). iter = the number of subintervals (default 10,000).
INTEGRAL2(R1, lox, upx, loy, upy, iterx, itery, Rx, Ry) = ∫∫ f(x,y)dxdy between x = lox and upx, and between y = loy and upy using Simpson’s rule. iterx = the number of subintervals on the x-axis (default 400). itery = the number of subintervals on the y-axis (default 400).
Ei(x) = the exponential integral at x
R1, Rx, Ry, and Rz are as for Evaluation of a Function (see above). incr is the increment value (default .000001).
Roots of Continuous Functions
BISECTION(R1, lower, upper, iter, prec, Rx) = a root of f(x) in the interval [lower, upper] based on the bisection method.
SECANT(R1, x1, x2, iter, prec, Rx) = a root of f(x) based on the secant method and two initial points x = x1 and x = x2.
BRENT(R1, lower, upper, iter, prec, Rx) = a root of f(x) in the interval [lower, upper] based on Brent’s method.
NEWTON(R1, guess, iter, prec, incr, Rx) = a root of f(x) based on Newton’s method using the specified initial guess.
iter (default 100) = the maximum number of iterations. The algorithm will terminate prior to iter iterations when the error is less than some value based on prec (default .0000001). For BISECTION and BRENT the signs of f(lower) and f(upper) should be different. incr is used to calculate the derivative of f(x) and defaults to .000001. R1 and Rx are as for Evaluation of a Function.
NROOTS(R1, lower, upper, nguess, iter, prec, incr, Rx): returns a column array with all the roots of f(x) in the interval (lower, upper) based on Newton’s method.
This function attempts to find all the roots based on nguess (default 50) equally-spaced initial guesses from the interval (lower, upper). If nguess < 0 then the process is the same except that -nguess randomly selected guesses are made from lower to upper.
NEWTON2(R1, R2, guessx, guessy, iter, prec, incr, Rx, Ry): a 1 × 4 row array containing a root x,y of f1(x,y) and f2(x,y) along with the values of these functions at the root, based on Newton’s method using the initial guesses guessx for x and guessy for y. R1 contains the formula for f1(x,y) and R2 contains the formula for f2(x,y). Rx and Ry are as for Evaluation of a Function.
NEWTON3(R1, R2, R3, guessx, guessy, guessz, iter, prec, incr, Rx, Ry, Rz): a 1 × 6 row array containing a root x,y,z of f1(x,y,z), f2(x,y,z) and f3(x,y,z) along with the values of these functions at the root, based on Newton’s method using the initial guesses guessx for x, guessy for y, and guessz for z. R1 contains the formula for f1(x,y,z), R2 contains the formula for f2(x,y,z) and R3 contains the formula for f3(x,y,z). Rx, Ry, and Rz are as for Evaluation of a Function (see above).
Local Maxima/Minima
MNEWTON(R1, guess, iter, prec, incr, Rx): returns a 3 × 1 column array with a critical value c (based on guess), f(c), and the second derivative of f(x) at c, based on Newton’s method.
This function returns a critical value (i.e. a local minimum, maximum, or inflection point) for the function f(x). The second derivative is used to determine the type of critical value.
MNEWTON2(R1, guessx, guessy, iter, prec, incr, Rx, Ry): a 2 × 5 array containing the values x, y that identify a possible local maxima or minima of f(x,y), based on Newton’s method using the initial guesses guessx for x and guessy for y.
The first column of the output contains the values x and y of a critical point. The second column contains the values of the partial derivatives of f(x,y) at these values (which should be close to zero if there is convergence). In addition, the third column contains the value f(x,y) and the type of critical value (local maximum, local minimum, saddle point, or indeterminate). The rest of the output contains the 2 × 2 Hessian matrix (consisting of partial second derivatives).
MNEWTON3(R1, guessx, guessy, guessz, iter, prec, incr, Rx, Ry, Rz): a 3 × 6 array containing the values x, y, z that identify a possible local maxima or minima of f(x,y,z) based on Newton’s method using the initial guesses guessx for x, guessy for y, and guessz for z. The output is similar to that from MNEWTON2, except that the third column also contains the determinant of the 3 × 3. Hessian matrix.
MGRADIENT(R1, Rx, learn, iter, prec, incr): returns a column array with the value of X that minimizes the function f(X) using gradient descent with a fixed learning rate learn (default .1) based on an initial guess of X in the column array Rx where R1 is a cell that contains a formula that represents the function f(X).
MGRADIENTX(R1, Rx, learn, iter, prec, incr, rrate, c): similar to MGRADIENT, except that the initial learning rate learn (default 1) is not fixed but varies based on the backtracking line search approach with rrate set to the learning rate reduction constant (default .5).
BGFS(R1, Rx, learn, iter, prec, incr, rrate, c): returns a column array with the value of X that minimizes the function f(X) using BGFS algorithm based on an initial guess of X in the column array Rx and an initial learning rate learn that gets revised as required using the rrate learning rate reduction, where R1 is a cell that contains a formula that represents the function f(X).
NMEAD(R1, lab, R2, iter, prec): an n+2 column array whose first n values consist of the array X where f(X) is minimized using the Nelder-Mead algorithm, followed by the value f(X) and the number of iterations required until convergence.
Global Maximum/Minimum
FMIN(R1, lower, upper, nguess, iter, prec, incr, Rx) = the global minimum of f(x) in the interval [lower, upper] based on nguess (default 1000) equally spaced intervals.
FMAX(R1, lower, upper, nguess, iter, prec, incr, Rx) = the global maximum of f(x) in the interval [lower, upper] based on nguess (default 1000) equally spaced intervals.
F2MIN(R1, lox, upx, loy, upy, gx, gy, Rx, Ry): a 1 × 3 row array containing the values x, y, f(x,y) that produces the global minimum of f(x,y) in the ellipse whose x-axis is (lox, upx) and y-axis is (loy, upy) with gx equally-spaced intervals on the x-axis and gy equally-spaced intervals on the y-axis. gx and gy default to 200.
F2MAX(R1, lox, upx, loy, upy, gx, gy, Rx, Ry): a 1 × 3 row array containing the values x, y, f(x,y) that produces the global maximum of f(x,y) in the ellipse whose x-axis is (lox, upx) and y-axis is (loy, upy) with gx equally-spaced intervals on the x-axis and gy equally-spaced intervals on the y-axis. gx and gy default to 200.
F3MIN(R1, lox, upx, loy, upy, loz, upz, gx, gy, gz, Rx, Ry, Rz): a 1 × 4 row array containing the values x, y, f(x,y,z) that produces the global minimum of f(x,y,z) in the hyper-ellipse whose x-axis is (lox, upx), y-axis is (loy, upy) and z-axis is (loz, upz) with gx, gy, and gz equally-spaced intervals on the x-axis, y-axis and z-axis. gx, gy, and gz default to 50.
F3MAX(R1, lox, upx, loy, upy, loz, upz, gx, gy, gz, Rx, Ry, Rz): a 1 × 4 row array containing the values x, y, f(x,y,z) that produces the global maximum of f(x,y,z) in the hyper-ellipse whose x-axis is (lox, upx), y-axis is (loy, upy) and z-axis is (loz, upz) with gx, gy, and gz equally-spaced intervals on the x-axis, y-axis and z-axis. gx, gy, and gz default to 50.
Rx, Ry, and Rz are as for Evaluation of a Function (see above).
Roots of a Polynomial
The following is an array function where R1 is an n+1 × 1 range containing the coefficients of a polynomial where a0 (the constant term) is in the first position and an is in the last position (Roots of a Rolynomial).
ROOTS(R1, prec, iter, r, s): outputs an n × 2 range where each row contains one root, and where the first column consists of the real part of the roots and the second column consists of the imaginary part of the roots
Here prec = the precision of the result, i.e. how close to zero is acceptable (default 0.00000001). iter = the maximum number of iterations performed when performing Bairstow’s Method (default 200). r, s = the initial seed values when using Bairstow’s Method (default 0).
CubicRoots(R1): outputs a 3 × 2 array, in which each row contains one unique root of the polynomial x3 + bx2 + cx + d; each root is a 1 × 2 array where the first element represents the real part of the root and the second element represents the imaginary part. R1 is a column range containing the values b, c, d
Complex Numbers
The following are array functions in which z1 and z2 are 1 × 2 ranges which represent complex numbers with c + di, and a and b are real numbers (see Complex Numbers).
| CReal(z1) = c | CAdd(z1, z2) = z1 + z2 | CExp(z1) = exp(z1) = ez1 |
| CImag(z1) = d | CSub(z1, z2) = z1 – z2 | CLn(z1) = ln(z1) |
| CAbs(z1) = |z1| | CMult(z1, z2) = z1 * z2 | CSet(a,b) = a + bi |
| CConj(z1) = c – di | CDiv(z1, z2) = z1 / z2 | CMap(“a+bi”) = a + bi |
| CPower(z1, n) = z1n | CText(z1) = “c+di” |
z1, z2 in CSub(z1, z2) and CMult(z1, z2) can also be real numbers. z1 in CDiv(z1, z2) can also be either a real number. CAdd can take up to 5 complex or real number arguments.
There are also the following functions:
CPolar(z) – converts the complex number z (represented as a 1 × 2 array (a, b) in rectangular form, i.e. a + bi, to polar form, represented as a 1 × 2 array of the form (r, θ)
CRect(u) – converts a complex number in polar form to rectangular form
CRoots(z, n) – returns an array with the nth roots of the complex (or real) number z
Finally, there are the following functions that deal with complex numbers in Excel format (i.e. text in the form “a+bi“)
IMROOTS(s, n) = column array containing the n unique nth roots of the complex number s
IMROUND(s, n) = the complex number equivalent to s with the real and imaginary parts rounded to n decimal places
Complex Matrices
Real Statistics Format
The following are array functions where Y and Z are ranges that represent complex matrices in Real Statistics format, while z is a range that represents a complex (scalar) number and k is a positive integer.
| ZAdd(Y, Z) = Y + Z | ZSub(Y, Z) = Y – Z | ZMult(Y, Z) = Y × Z |
| ZInverse(Z) = Z-1 | ZTranspose(Z) = ZT | ZIdentity(k) = identity |
| ZMultScalar(Y, z) = z × Y | ZConj(Z) = Z* | ZIndex(Z,r,c) = zr,c |
ZReal(Z) = the real part of the complex matrix Z
ZImag(Z) = the imaginary part of the complex matrix Z
ZSet(R, C) = the complex matrix whose real part is R and whose imaginary part is C
ZLen(Z) = the length of the complex vector Z
ZNorm(Z) = the complex matrix Z where all the column vectors in Z are normalized
Excel Format
The following are array functions where Y and Z are arrays containing complex numbers in Excel’s text format (i.e. in the form “a+bi“) and z is a text string containing a complex number in Excel format.
| ZMADD(Y, Z) = Y + Z | ZMSub(Y, Z) = Y – Z | ZMMULT(Y, Z) = Y × Z |
| ZMINVERSE(Z) = Z-1 | ZMDETERM(Y) = |Y| | ZMULTSCALAR(Y, z) = z × Y |
| ZMCONJUGATE(Z) = Z* |
The following array functions translate between the two complex number matrix formats:
ZMap(Z): takes an array Z whose elements are complex numbers in Excel format and outputs an array in Real Statistics A+Bi format
ZText(Z): takes an array Z in A+Bi format and returns an equivalent array whose elements are in Excel complex number format
There is also the array version of the IMROUND function:
ZMROUND(Z, n): returns an array equivalent to Z but with each element rounded off to n decimal places.
Complex Linear Equations
ZLinEqSolve(R1, prec): returns an array with the solution vectors for the system of linear equations defined by the augmented complex matrix found in R1. All entries are in Real Statistics’ complex number format.
IMLinEqSolve(R1, ndigits, prec): returns an array with the solution vectors for the system of linear equations defined by the augmented complex matrix found in R1. If ndigits >= 0 (default 4), then the output uses numbers rounded off to ndigits decimal places. If ndigits < 0 then no rounding is used. All entries are in Excel’s complex number format.
During Gaussian elimination, values less than prec (default .0001) are treated as zero.
Complex Eigenvalues and Eigenvectors
ZEigVAL(R1, check, iter, prec): returns real and complex eigenvalues for the square matrix in R1. Similar to the existing eigVAL function. The key difference is that the order of the eigenvalues is different.
ZEigVECT(R1, check, iter, prec): returns real and complex eigenvalues and eigenvectors for the square matrix in R1. Similar to the existing eigVECT function. The key difference is that complex eigenvectors are included and repeated eigenvalues are handled even for non-symmetric matrices.
IMEigVECT(R1, check, iter, prec): returns real and complex eigenvalues and eigenvectors for the square matrix in R1. Similar to ZEigVECT. The key difference is that complex eigenvalues and eigenvectors are written in Excel’s complex number format.
ZEigMultVECT(R1, re, im, prec): returns the eigenvectors for the eigenvalue re + im*i, which is presumably a repeated eigenvalue. Similar to eigMultVECT. The key difference is that both real and complex eigenvalues (and eigenvectors) are supported.
Spline Interpolation
SPLINE(R0, Rx, Ry): returns a column array with the same number of rows as R0 consisting of the y values that correspond to the x values in R0 and which lie on the spline curve.
Here, Rx and Ry are column arrays with the same number of rows containing the x and y values of the points (x0, y0), …, (xn, yn) through which the spline curve passes and which define the spline curve. R0 is a column array containing x values (usually between the smallest and largest values in Rx).
SPLINE0(incr, Rx, Ry): returns a two-column array whose first column R1 contains the values x0, …, xm where x0 = the smallest value in Rx, xm = the largest value in Rx and for all i, xi = xi-1 + incr; in addition, all the values in Rx, excluding the smallest, are inserted in this column in sorted order (with repeated values if necessary). The second column R2 contains the corresponding spline values, i.e. R2 = SPLINE(R1, Rx, Ry).
Is there a function that outputs the array of spline coefficients used for each segment, or is there a way to obtain these? Knowing them would make derivatives in each segment calculable without need to resort to some numerical scheme.