stdlib is a library which extends the native LME functions in the following areas:
The following statement makes available functions defined in stdlib:
use stdlib
Cartesian to polar coordinates transform.
(phi, r) = cart2pol(x, y) (phi, r, z) = cart2pol(x, y, z)
(phi,r)=cart2pol(x,y) transforms Cartesian coordinates x
and y to polar coordinates phi and r such that
(phi,r,z)=cart2pol(x,y,z) transform Cartesian coordinates to cylindrical coordinates, leaving z unchanged.
(phi, r) = cart2pol(1, 2) phi = 1.1071 r = 2.2361
Cartesian to spherical coordinates transform.
(phi, theta, r) = cart2sph(x, y, z)
(phi,theta,r)=cart2sph(x,y,z) transforms Cartesian coordinates x,
y, and z to polar coordinates phi, theta,
and r such that
(phi, theta, r) = cart2sph(1, 2, 3) phi = 1.1071 theta = 0.9303 r = 3.7417
Shift the elements of a matrix in a circular way.
B = circshift(A, shift_vert) B = circshift(A, [shift_vert, shift_hor])
circshift(A,sv) shifts the rows of matrix A downward by sv rows. The sv bottom rows of the input matrix become the sv top rows of the output matrix. sv may be negative to go the other way around.
circshift(A,[sv,sh]) shifts the rows of matrix A downward by sv rows, and its columns to the right by sh columns. The sv bottom rows of the input matrix become the sv top rows of the output matrix, and the sh rightmost columns become the sh leftmost columns.
Block-diagonal matrix.
X = blkdiag(B1, B2, ...)
blkdiag(B1,B2,...) creates a block-diagonal matrix with matrix blocks B1, B2, etc. Its input arguments do not need to be square.
blkdiag([1,2;3,4], 5) 1 2 0 3 4 0 0 0 5 blkdiag([1,2], [3;4]) 1 2 0 0 0 3 0 0 4
Companion matrix.
X = compan(pol)
compan(pol) gives the companion matrix of polynomial pol, a square matrix whose eigenvalues are the roots of pol.
compan([2,3,4,5]) -1.5 -2.0 -2.5 1.0 0.0 0.0 0.0 1.0 0.0
Correlation coefficients.
S = corrcoef(X) S = corrcoef(X1, X2)
corrcoef(X) calculates the correlation coefficients of the columns of the m-by-n matrix X. The result is a square n-by-n matrix whose diagonal is 1.
corrcoef(X1,X2) calculates the correlation coefficients of X1 and X2 and returns a 2-by-2 matrix. It is equivalent to corrcoef([X1(:),X2(:)]).
corrcoef([1, 3; 2, 5; 4, 4; 7, 10]) 1 0.8915 0.8915 1 corrcoef(1:5, 5:-1:1) 1 -1 -1 1
Cumulative numerical integration with trapezoidal approximation.
S = cumtrapz(Y) S = cumtrapz(X, Y) S = cumtrapz(X, Y, dim)
cumtrapz(Y) calculates an approximation of the cumulative integral of a function given by the samples in Y with unit intervals. The trapezoidal approximation is used. If Y is neither a row nor a column vector, integration is performed along its columns. The result has the same size as Y. The first value(s) is (are) 0.
cumtrapz(X,Y) specifies the location of the samples. A third argument may be used to specify along which dimension the integration is performed.
cumtrapz([2, 3, 5]) 0 2.5 6.5 cumtrapz([1, 2, 5], [2, 3, 5]) 0 2.5 14.5
Prime factors.
v = factor(n)
factor(n) gives a row vector which contains the prime factors of n in ascending order. Multiple prime factors are repeated.
factor(350) 2 5 5 7
Shift DC frequency of FFT from beginning to center of spectrum.
Y = fftshift(X)
fftshift(X) shifts halves of vector (1-d) or matrix (2-d) X to move the DC component to the center. It should be used after fft or fft2.
Digital 2-d filtering of data.
Y = filter2(F, X) Y = filter2(F, X, shape)
filter2(F,X) filters matrix X with kernel F with a 2-d correlation. The result has the same size as X.
An optional third argument is passed to conv2 to specify another method to handle the borders.
filter2 and conv2 have three differences: arguments F and X are permuted, filtering is performed with a correlation instead of a convolution (i.e. the kernel is rotated by 180 degrees), and the default method for handling the borders is 'same' instead of 'full'.
Hankel matrix.
X = hankel(c, r)
hankel(c,r) creates a Hankel matrix whose first column contains the elements of vector c and whose last row contains the elements of vector r. A Hankel matrix is a matrix whose antidiagonals have the same value. In case of conflict, the first element of r is ignored. The default value of r is a zero vector the same length as c.
hankel(1:3, 3:8) 1 2 3 4 5 6 2 3 4 5 6 7 3 4 5 6 7 8
Histogram.
(N, X) = hist(Y) (N, X) = hist(Y, m) (N, X) = hist(Y, m, dim) N = hist(Y, X) N = hist(Y, X, dim)
hist(Y) gives the number of elements of vector Y in 10 equally-spaced intervals. A second input argument may be used to specify the number of intervals. The center of the intervals may be obtained in a second output argument.
If Y is an array, histograms are computed along the dimension specified by a third argument or the first non-singleton dimension; the result N has the same size except along that dimension.
When the second argument is a vector, it specifies the centers of the intervals.
(N, X) = hist(logspace(0,1), 5) N = 45 21 14 11 9 X = 1.9 3.7 5.5 7.3 9.1
Shift DC frequency of FFT from center to beginning of spectrum.
Y = ifftshift(X)
ifftshift(X) shifts halves of vector (1-d) or matrix (2-d) X to move the DC component from the center. It should be used before ifft or ifft2. It reverses the effect of fftshift.
Prime number test.
b = isprime(n)
isprime(n) returns true if n is a prime number, or false otherwise. If n is a matrix, the test is applied to each element and the result is a matrix the same size.
isprime(7) true isprime([0, 2, 10]) F T F
Test for a real number.
b = isreal(x)
isreal(x) is true if x is a real scalar or a matrix whose entries are all real.
isreal([2,5]) true isreal([2,3+2j]) false isreal(exp(pi*1j)) true
Sequence of linearly-spaced elements.
v = linspace(x1, x2) v = linspace(x1, x2, n)
linspace(x1,x2) produces a row vector of 100 values spaced linearly from x1 and x2 inclusive. With a third argument, linspace(x1,x2,n) produces a row vector of n values.
linspace(1,10) 1.0000 1.0909 1.1818 ... 9.9091 10.0000 linspace(1,2,6) 1.0 1.2 1.4 1.6 1.8 2.0
Sequence of logarithmically-spaced elements.
v = logspace(x1, x2) v = logspace(x1, x2, n)
logspace(x1,x2) produces a row vector of 100 values spaced logarithmically from 10^x1 and 10^x2 inclusive. With a third argument, logspace(x1,x2,n) produces a row vector of n values.
logspace(0,1) 1.0000 1.0235 1.0476 ... 9.5455 9.7701 10.0000
Median.
x = median(v) v = median(M) v = median(M, dim)
median(v) gives the median of vector v, i.e. the value x such that half of the elements of v are smaller and half of the elements are larger.
median(M) gives a row vector which contains the median of the columns of M. With a second argument, median(M,dim) operates along dimension dim.
median([1, 2, 5, 6, inf]) 5
Array of permutations.
M = perms(v)
perm(v) gives an array whose rows are all the possible permutations of vector v.
perms(1:3) 3 2 1 3 1 2 2 3 1 1 3 2 2 1 3 1 2 3
Polar to Cartesian coordinates transform.
(x, y) = pol2cart(phi, r) (x, y, z) = pol2cart(phi, r, z)
(x,y)=pol2cart(phi,r) transforms polar coordinates phi
and r to Cartesian coordinates x and y such that
(x,y,z)=pol2cart(phi,r,z) transforms cylindrical coordinates to Cartesian coordinates, leaving z unchanged.
(x, y) = pol2cart(1, 2) x = 1.0806 y = 1.6829
Polynomial fit.
pol = polyfit(x, y, n)
polyfit(x,y,n) calculates the polynomial (given as a vector of descending power coefficients) of order n which best fits the points given by vectors x and y. The least-square algorithm is used.
pol = polyfit(1:5, [2, 1, 4, 5, 2], 3) pol = -0.6667 5.5714 -12.7619 9.8000 polyval(pol, 1:5) 1.9429 1.2286 3.6571 5.2286 1.9429
Value of a polynomial with square matrix argument.
Y = polyvalm(pol, X)
polyvalm(pol,X) evaluates the polynomial given by the coefficients pol (in descending power order) with a square matrix argument.
polyvalm([1,2,8],[2,1;0,1]) 16 5 0 11
List of primes.
v = primes(n)
primes(n) gives a row vector which contains the primes up to n.
primes(20) 2 3 5 7 11 13 17 19
Sort matrix rows.
(S, index) = sortrows(M) (S, index) = sortrows(M, sel) (S, index) = sortrows(M, sel, dim)
sortrows(M) sort the rows of matrix M. The sort order is based on the first column of M, then on the second one for rows with the same value in the first column, and so on.
sortrows(M,sel) use the columns specified in sel for comparing the rows of M. A third argument dim can be used to specify the dimension of the sort: 1 for sorting the rows, or 2 for sorting the columns.
The second output argument of sortrows gives the new order of the rows or columns as a vector of indices.
sortrows([3, 1, 2; 2, 2, 1; 2, 1, 2]) 2 1 2 2 2 1 3 1 2
Spherical to Cartesian coordinates transform.
(x, y, z) = sph2cart(phi, theta, r)
(x,y,z)=sph2cart(phi,theta,r) transforms polar coordinates phi,
theta, and r to Cartesian coordinates x,
y, and z such that
(x, y, z) = sph2cart(1, 2, 3) x = -0.6745 y = -1.0505 z = 2.7279
Angle between two subspaces.
theta = subspace(A, B)
subspace(A,B) gives the angle between the two subspaces spanned by the columns of A and B.
Angle between two vectors in R^2:
a = [3; 2]; b = [1; 5]; subspace(a, b) 0.7854
Angle between the vector [1;1;1] and the plane spanned by [2;5;3] and [7;1;0] in R^3:
subspace([1;1;1], [2,7;5,1;3,0]) 0.2226
Toeplitz matrix.
X = toeplitz(c, r) X = toeplitz(c)
toeplitz(c,r) creates a Toeplitz matrix whose first column contains the elements of vector c and whose first row contains the elements of vector r. A Toeplitz matrix is a matrix whose diagonals have the same value. In case of conflict, the first element of r is ignored. With one argument, toeplitz gives a symmetric square matrix.
toeplitz(1:3, 1:5) 1 2 3 4 5 2 1 2 3 4 3 2 1 2 3
Numerical integration with trapezoidal approximation.
s = trapz(Y) s = trapz(X, Y) s = trapz(X, Y, dim)
trapz(Y) calculates an approximation of the integral of a function given by the samples in Y with unit intervals. The trapezoidal approximation is used. If Y is an array, integration is performed along the first non-singleton dimension.
trapz(X,Y) specifies the location of the samples. A third argument may be used to specify along which dimension the integration is performed.
trapz([2, 3, 5]) 6.5 trapz([1, 2, 5], [2, 3, 5]) 14.5