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
Sequence of linearly-spaced elements.
v = linspace(x1, x2) v = linspace(x1, x2, n)
linspace(x1,x2) produces a row vector of 50 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 50 values spaces logarithmically from 10^x1 and 10^x2 inclusive. With a third argument, logspace(x1,x2,n) produces a row vector of n values.
logspace(1,10) 1.0000 1.0235 1.0476 ... 9.5455 9.7701 10.0000
Arrays of X-Y coordinates.
(X, Y) = meshgrid(x, y)
meshgrid(x,y) produces two arrays of x and y coordinates suitable for the evaluation of a function of two variables. The input argument x is copied to the rows of the first output argument, and the input argument y is copied to the columns of the second output argument, so that both arrays have the same size.
(X, Y) = meshgrid(1:5, 2:4) X = 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 Y = 2 2 2 2 2 3 3 3 3 3 4 4 4 4 4 Z = atan2(X, Y) Z = 0.4636 0.7854 0.9828 1.1071 1.1903 0.3218 0.5880 0.7854 0.9273 1.0304 0.2450 0.4636 0.6435 0.7854 0.8961
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
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
Toeplitz matrix.
X = toeplitz(c, r)
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
Inverse cotangent.
y = acot(x)
acot(x) gives the inverse cotangent of x, which is complex if x is.
Inverse hyperbolic cotangent.
y = acoth(x)
acot(x) gives the inverse hyperbolic cotangent of x, which is complex if x is complex or is in the range (-1,1).
Inverse cosecant.
y = acsc(x)
acsc(x) gives the inverse cosecant of x,
Inverse hyperbolic cosecant.
y = acsch(x)
acsch(x) gives the inverse hyperbolic cosecant of x, which is complex if x is.
Inverse secant.
y = asec(x)
asec(x) gives the inverse secant of x, which is complex if x is complex or is in the range (-1,1).
Inverse hyperbolic secant.
y = asech(x)
asech(x) gives the inverse hyperbolic secant of x, which is complex if x is complex or strictly negative.
Cotangent.
y = cot(x)
cot(x) gives the cotangent of x, which is complex if x is.
Hyperbolic cotangent.
y = coth(x)
coth(x) gives the hyperbolic cotangent of x, which is complex if x is.
Cosecant.
y = csc(x)
csc(x) gives the cosecant of x, which is complex if x is.
Hyperbolic cosecant.
y = csch(x)
csch(x) gives the hyperbolic cosecant of x, which is complex if x is.
Secant.
y = sec(x)
sec(x) gives the secant of x, which is complex if x is.
Hyperbolic secant.
y = sech(x)
acot(x) gives the hyperbolic secant of x, which is complex if x is.
Base 2 logarithm.
y = log2(x)
log2(x) gives the base 2 logarithm of x, defined as log2(x)=log(x)/log(2). The result is complex if x is not real positive.
log2([1, 2, 1024, 2000, -5]) 0 1 10 10.9658 2.3219+4.5324j
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]) 1 isreal([2,3+2j]) 0 isreal(exp(pi*1j)) 1
Cross product.
v3 = cross(v1, v2) v3 = cross(v1, v2, dim)
cross(v1,v2) gives the cross products of vectors v1 and v2. v1 and v2 must be row or columns vectors of three components, or matrices containing several such vectors. When there is ambiguity, a third argument dim may be used to specify the dimension of vectors: 1 for column vectors, or 2 for row vectors.
cross([1; 2; 3], [0; 0; 1]) 2 -1 0 cross([1, 2, 3], [4, 0, 0; 0, 2, 0], 2) 0 12 -8 -6 0 2
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
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
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
Greatest common divisor.
q = gcd(a, b)
gcd(a,b) gives the greatest common divisor of integer numbers a and b.
gcd(72, 56) 8
Least common multiple.
q = lcd(a, b)
lcd(a,b) gives the least common multiple of integer numbers a and b.
lcm(72, 56) 504
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
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
Polar to cartesian coordinates transform.
(x, y) = pol2cart(phi, r) (x, y, r) = 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
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
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
Standard deviation.
x = std(v) x = std(v, p) v = std(M) v = std(M, p) v = std(M, p, dim)
std(v) gives the standard deviation of vector v, normalized by length(v)-1. With a second argument, std(v,p) normalizes by length(v)-1 if p is true, or by length(v) if p is false.
std(M) gives a row vector which contains the standard deviation of the columns of M. With a third argument, median(M,p,dim) operates along dimension dim.
std([1, 2, 5, 6, 10, 12]) 4.3359
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
Histogram.
(N, X) = hist(Y) (N, X) = hist(Y, m) N = hist(Y, X)
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.
(N, X) = hist(logspace(1,10), 5) N = 45 21 14 11 9 X = 1.9 3.7 5.5 7.3 9.1
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 neither a row nor a column vector, integration is performed along its columns and the result is a row vector.
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
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
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
Digital 2-d filtering of data.
Y = filter2(X, F) Y = filter2(X, F, shape)
filter2(X,F) filters matrix X with kernel F with a 2-d convolution. The result has the same size as X.
An optional third argument is passed to conv2 to specify another method to handle the borders.
2-d Fast Fourier Transform.
Y = fft2(X) Y = fft2(X, n) Y = fft2(X, m, n)
fft2(X) computes the 2-d Fourier transform of matrix X. The Fast Fourier Transform algorithm is used if the numbers of rows and/or columns are powers of 2.
fft2(X,n) crops and/or pads with zeros matrix X to a square n-by-n matrix before computing the Fourier transform. fft2(X,n,m) produces an m-by-n rectangular matrix.
Inverse 2-d Fast Fourier Transform.
Y = ifft2(X) Y = ifft2(X, n) Y = ifft2(X, m, n)
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.
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.
Value of a polynomial with square matrix argument.
Y = polyvalm(pol, X)
polyvalm(pol,X) evaluates the polynom 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
Polynomial fit.
pol = polyfit(x, y, n)
polyfit(x,y,n) calculates the polynom (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
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.