Algorithms¶
Standard algorithms over data stored in matrices may be found here. Among many others, it is possible to sort a matrix
, find the unique elements, the median of the data, perform the dot product between two matrices, find the maximum value with max, etc.
argintersect¶
-
template<typename R, typename S>
auto castor::argintersect(matrix<R> const &A, matrix<S> const &B)¶ Index of intersection.
[IA,IB] = intersect(A,B) returns index vectors IA and IB such that C = A(IA) and C = B(IB). If there are repeated common values in A or B then the index of the first occurrence of each repeated value is returned.
matrix<> A = {1,2,3}; matrix<> B = {2,3,4}; matrix<std::size_t> IA, IB; std::tie(IA,IB) = argintersect(A,B); disp(eval(A(IA))); disp(eval(B(IB)));
See intersect, argsetdiff, argunique.
argmax¶
-
template<typename T>
matrix<std::size_t> castor::argmax(matrix<T> const &A, int dim)¶ Index of max.
I = argmax(A) returns the index corresponding to the maximum value.
matrix<> A = {{1,2,3},{4,5,6}}; std::size_t I = argmax(A); disp(I);
I = argmax(A,DIM) returns a vector of indices corresponding to the maximum values into operating dimension.
matrix<> A = {{1,2,3},{4,5,6}}; matrix<std::size_t> I = argmax(A,1); matrix<std::size_t> J = argmax(A,2); disp(I); disp(J);
argmin¶
-
template<typename T>
matrix<std::size_t> castor::argmin(matrix<T> const &A, int dim)¶ Index of min.
I = argmin(A) returns the index corresponding to the minimum value.
matrix<> A = {{1,2,3},{4,5,6}}; std::size_t I = argmin(A); disp(I);
I = argmin(A,DIM) returns a vector of indices corresponding to the minimum values into operating dimension.
matrix<> A = {{1,2,3},{4,5,6}}; matrix<std::size_t> I = argmin(A,1); matrix<std::size_t> J = argmin(A,2); disp(I); disp(J);
argsetdiff¶
-
template<typename R, typename S>
matrix<std::size_t> castor::argsetdiff(matrix<R> const &A, matrix<S> const &B)¶ Index of difference.
IA = argsetdiff(A,B) returns index vectors IA such that C = A(IA). If there are repeated values in A that are not in B, then the index of the first occurrence of each repeated value is returned
matrix<> A = {1,2,3,0}; matrix<> B = {2,3,4}; matrix<std::size_t> IA, IB; IA = argsetdiff(A,B); disp(eval(A(IA)));
See setdiff, argintersect, argunique.
argsort¶
-
template<typename T>
matrix<std::size_t> castor::argsort(matrix<T> const &A, int dim = 0)¶ Index of sort.
I = argsort(A) returns a sort index I which specifies how the elements of A were rearranged to obtain the sorted output B = sort(A).
matrix<> A = {{6,5,4},{3,2,1}}; matrix<std::size_t> I = argsort(A); disp(I);
I = argsort(A,DIM) returns a sort index I which specifies how the elements of A were rearranged to obtain the sorted output B = sort(A,DIM) into operating dimension.
matrix<> A = {{6,5,4},{3,2,1}}; matrix<std::size_t> I = argsort(A,1); matrix<std::size_t> J = argsort(A,2); disp(I); disp(J);
The sort ordering is stable. Namely, when more than one element has the same value, the order of the equal elements is preserved in the sorted output B and the indices I relating to equal elements are ascending.
argunique¶
-
template<typename T>
auto castor::argunique(matrix<T> const &A)¶ Index of unique.
[IA,IB] = unique(A) returns index vectors IA and IB such that B = A(IA) and A = B(IB).
matrix<> A = {1,2,1,3,2,3}; matrix<> B = unique(A); matrix<std::size_t> IA, IB; std::tie(IA,IB) = argunique(A); disp(eval(A(IA))); disp(eval(B(IB)));
See unique, argsetdiff, argintersect.
conv¶
-
template<typename T>
matrix<T> castor::conv(matrix<T> const &A, matrix<T> const &B, int dim = 0)¶ Convolution product and polynomial multiplication.
C = conv(A,B) convolves array A and B. The resulting array is vector of length NUMEL(A)+NUMEL(B)-1. If A and B are vectors of polynomial coefficients, convolving them is equivalent to multiplying the two polynomials.
C = conv(A,B,DIM) convolve along dimension DIM if A and B have compatible size.
matrix<float> A = eye(3,4); matrix<float> B = rand(3,10); disp(conv(A,B,2));
See fftconv.
cross¶
-
template<typename R, typename S>
auto castor::cross(matrix<R> const &A, matrix<S> const &B)¶ Matrix cross product.
C = cross(A,B) returns the cross product of the matrix A and B, C=AxB. A and B must have same number of row with 3 columns.
matrix<> A = {{1,0,0},{0,1,0},{0,0,1}}; matrix<> B = {{0,1,0},{0,0,1},{1,0,0}}; matrix<> C = cross(A,B); disp(C);
See dot.
cumprod¶
-
template<typename T>
matrix<T> castor::cumprod(matrix<T> const &A, int dim)¶ Cumulative product of elements.
B = cumprod(A) computes the cumulative product of all elements of A. B is the same size as A.
matrix<> A = {{1,2,3},{4,5,6}}; matrix<> B = cumprod(A); disp(B);
B = cumprod(A,DIM) computes the cumulative product along the dimension DIM. if DIM==0, B is the cumulative product. if DIM==1, B is a vector containing the cumulative product from each column. if DIM==2, B is a vector containing the cumulative product from each row.
matrix<> A = {{1,2,3},{4,5,6}}; matrix<> R = cumprod(A,1); matrix<> C = cumprod(A,2); disp(R); disp(C);
cumsum¶
-
template<typename T>
matrix<T> castor::cumsum(matrix<T> const &A, int dim)¶ Cumulative sum of elements.
B = cumsum(A) computes the cumulative sum of all elements of A. B is the same size as A.
matrix<> A = {{1,2,3},{4,5,6}}; matrix<> B = cumsum(A); disp(B);
B = cumsum(A,DIM) computes the cumulative sum along the dimension DIM. if DIM==0, B is the cumulative sum. if DIM==1, B is a vector containing the cumulative sum from each column. if DIM==2, B is a vector containing the cumulative sum from each row.
matrix<> A = {{1,2,3},{4,5,6}}; matrix<> R = cumsum(A,1); matrix<> C = cumsum(A,2); disp(R); disp(C);
diff¶
-
template<typename T>
matrix<T> castor::diff(matrix<T> const &A, int dim)¶ Difference of elements.
B = diff(A) computes the difference of all elements of A. B is a row vector containing numel(A)-1 elements.
matrix<> A = {{1,2,3},{4,5,6}}; matrix<> B = diff(A); disp(B);
B = cumsum(A,DIM) computes the cumulative sum along the dimension DIM. if DIM==0, B is the difference of all elements. if DIM==1, B is a vector containing the difference from each column. if DIM==2, B is a vector containing the difference from each row.
matrix<> A = {{1,2,3},{4,5,6}}; matrix<> R = diff(A,1); matrix<> C = diff(A,2); disp(R); disp(C);
dot¶
-
template<typename R, typename S>
auto castor::dot(matrix<R> const &A, matrix<S> const &B)¶ Matrix dot product.
C = dot(A,B) returns the dot product of the matrix A and B, C = A.B. A and B must have same number of rows with 3 columns.
matrix<> A = {{1,0,0},{0,1,0},{0,0,1}}; matrix<> B = {{0,1,0},{0,0,1},{1,0,0}}; matrix<> C = dot(A,B); disp(C);
See cross.
fftconv¶
-
template<typename S>
auto castor::fftconv(matrix<S> const &A, matrix<S> const &B, int dim = 0)¶ Convolution product and polynomial multiplication using FFT.
C = fftconv(A,B) convolves array A and B using Fast Fourier Transform that guarantee efficient execution. The resulting array is vector of length NUMEL(A)+NUMEL(B)-1. If A and B are vectors of polynomial coefficients, convolving them is equivalent to multiplying the two polynomials.
C = fftconv(A,B,DIM) convolve along dimension DIM if A and B have compatible size.
matrix<float> A = eye(3,4); matrix<float> B = rand(3,10); disp(fftconv(A,B,2);
gmres¶
Warning
doxygenfunction: Unable to resolve function “gmres” with arguments (matrix<T> const&, matrix<T> const&, double, std::size_t, std::function<matrix<T>(matrix<T> const&)> const&, matrix<T> const&) in doxygen xml output for project “castor” from directory: ../xml. Potential matches:
- template<typename T> matrix<T> gmres(hmatrix<T> const &Ah, matrix<T> const &B, double tol = 1e-6, std::size_t maxit = 10, std::function<matrix<T>(matrix<T> const&)> const &Am1 = std::function<matrix<T>(matrix<T> const&)>(), matrix<T> const &X0 = matrix<T>())
- template<typename T> matrix<T> gmres(hmatrix<T> const &Ah, matrix<T> const &B, double tol, std::size_t maxit, hmatrix<T> const &Ahm1, matrix<T> const &X0 = matrix<T>())
- template<typename T> matrix<T> gmres(hmatrix<T> const &Ah, matrix<T> const &B, double tol, std::size_t maxit, hmatrix<T> const &Lh, hmatrix<T> const &Uh, matrix<T> const &X0 = matrix<T>())
- template<typename T> matrix<T> gmres(matrix<T> const &A, matrix<T> const &B, double tol = 1e-6, std::size_t maxit = 10, std::function<matrix<T>(matrix<T> const&)> const &Am1 = std::function<matrix<T>(matrix<T> const&)>(), matrix<T> const &X0 = matrix<T>(), int info = 1)
- template<typename T> matrix<T> gmres(matrix<T> const &A, matrix<T> const &B, double tol, std::size_t maxit, matrix<T> const &Am1, matrix<T> const &X0 = matrix<T>(), int info = 1)
- template<typename T> matrix<T> gmres(smatrix<T> const &As, matrix<T> const &B, double tol = 1e-6, std::size_t maxit = 10, std::function<matrix<T>(matrix<T> const&)> const &Am1 = std::function<matrix<T>(matrix<T> const&)>(), matrix<T> const &X0 = matrix<T>(), int info = 1)
- template<typename T> matrix<T> gmres(smatrix<T> const &As, matrix<T> const &B, double tol, std::size_t maxit, smatrix<T> const &Asm1, matrix<T> const &X0 = matrix<T>(), int info = 1)
- template<typename T> matrix<T> gmres(std::function<matrix<T>(matrix<T> const&)> const &A, matrix<T> const &B, double tol = 1e-6, std::size_t maxit = 10, matrix<T> const &Am1 = matrix<T>(), matrix<T> const &X0 = matrix<T>(), int info = 1)
- template<typename T> matrix<T> gmres(std::function<matrix<T>(matrix<T> const&)> const &A, matrix<T> const &B, double tol = 1e-6, std::size_t maxit = 10, std::function<matrix<T>(matrix<T> const&)> const &Am1 = std::function<matrix<T>(matrix<T> const&)>(), matrix<T> const &X0 = matrix<T>(), int info = 1)
Warning
doxygenfunction: Unable to resolve function “gmres” with arguments (matrix<T> const&, matrix<T> const&, double, std::size_t, matrix<T> const&, matrix<T> const&) in doxygen xml output for project “castor” from directory: ../xml. Potential matches:
- template<typename T> matrix<T> gmres(hmatrix<T> const &Ah, matrix<T> const &B, double tol = 1e-6, std::size_t maxit = 10, std::function<matrix<T>(matrix<T> const&)> const &Am1 = std::function<matrix<T>(matrix<T> const&)>(), matrix<T> const &X0 = matrix<T>())
- template<typename T> matrix<T> gmres(hmatrix<T> const &Ah, matrix<T> const &B, double tol, std::size_t maxit, hmatrix<T> const &Ahm1, matrix<T> const &X0 = matrix<T>())
- template<typename T> matrix<T> gmres(hmatrix<T> const &Ah, matrix<T> const &B, double tol, std::size_t maxit, hmatrix<T> const &Lh, hmatrix<T> const &Uh, matrix<T> const &X0 = matrix<T>())
- template<typename T> matrix<T> gmres(matrix<T> const &A, matrix<T> const &B, double tol = 1e-6, std::size_t maxit = 10, std::function<matrix<T>(matrix<T> const&)> const &Am1 = std::function<matrix<T>(matrix<T> const&)>(), matrix<T> const &X0 = matrix<T>(), int info = 1)
- template<typename T> matrix<T> gmres(matrix<T> const &A, matrix<T> const &B, double tol, std::size_t maxit, matrix<T> const &Am1, matrix<T> const &X0 = matrix<T>(), int info = 1)
- template<typename T> matrix<T> gmres(smatrix<T> const &As, matrix<T> const &B, double tol = 1e-6, std::size_t maxit = 10, std::function<matrix<T>(matrix<T> const&)> const &Am1 = std::function<matrix<T>(matrix<T> const&)>(), matrix<T> const &X0 = matrix<T>(), int info = 1)
- template<typename T> matrix<T> gmres(smatrix<T> const &As, matrix<T> const &B, double tol, std::size_t maxit, smatrix<T> const &Asm1, matrix<T> const &X0 = matrix<T>(), int info = 1)
- template<typename T> matrix<T> gmres(std::function<matrix<T>(matrix<T> const&)> const &A, matrix<T> const &B, double tol = 1e-6, std::size_t maxit = 10, matrix<T> const &Am1 = matrix<T>(), matrix<T> const &X0 = matrix<T>(), int info = 1)
- template<typename T> matrix<T> gmres(std::function<matrix<T>(matrix<T> const&)> const &A, matrix<T> const &B, double tol = 1e-6, std::size_t maxit = 10, std::function<matrix<T>(matrix<T> const&)> const &Am1 = std::function<matrix<T>(matrix<T> const&)>(), matrix<T> const &X0 = matrix<T>(), int info = 1)
Warning
doxygenfunction: Unable to resolve function “gmres” with arguments (std::function<matrix<T>(matrix<T> const&)> const&, matrix<T> const&, double, std::size_t, std::function<matrix<T>(matrix<T> const&)> const&, matrix<T> const&) in doxygen xml output for project “castor” from directory: ../xml. Potential matches:
- template<typename T> matrix<T> gmres(hmatrix<T> const &Ah, matrix<T> const &B, double tol = 1e-6, std::size_t maxit = 10, std::function<matrix<T>(matrix<T> const&)> const &Am1 = std::function<matrix<T>(matrix<T> const&)>(), matrix<T> const &X0 = matrix<T>())
- template<typename T> matrix<T> gmres(hmatrix<T> const &Ah, matrix<T> const &B, double tol, std::size_t maxit, hmatrix<T> const &Ahm1, matrix<T> const &X0 = matrix<T>())
- template<typename T> matrix<T> gmres(hmatrix<T> const &Ah, matrix<T> const &B, double tol, std::size_t maxit, hmatrix<T> const &Lh, hmatrix<T> const &Uh, matrix<T> const &X0 = matrix<T>())
- template<typename T> matrix<T> gmres(matrix<T> const &A, matrix<T> const &B, double tol = 1e-6, std::size_t maxit = 10, std::function<matrix<T>(matrix<T> const&)> const &Am1 = std::function<matrix<T>(matrix<T> const&)>(), matrix<T> const &X0 = matrix<T>(), int info = 1)
- template<typename T> matrix<T> gmres(matrix<T> const &A, matrix<T> const &B, double tol, std::size_t maxit, matrix<T> const &Am1, matrix<T> const &X0 = matrix<T>(), int info = 1)
- template<typename T> matrix<T> gmres(smatrix<T> const &As, matrix<T> const &B, double tol = 1e-6, std::size_t maxit = 10, std::function<matrix<T>(matrix<T> const&)> const &Am1 = std::function<matrix<T>(matrix<T> const&)>(), matrix<T> const &X0 = matrix<T>(), int info = 1)
- template<typename T> matrix<T> gmres(smatrix<T> const &As, matrix<T> const &B, double tol, std::size_t maxit, smatrix<T> const &Asm1, matrix<T> const &X0 = matrix<T>(), int info = 1)
- template<typename T> matrix<T> gmres(std::function<matrix<T>(matrix<T> const&)> const &A, matrix<T> const &B, double tol = 1e-6, std::size_t maxit = 10, matrix<T> const &Am1 = matrix<T>(), matrix<T> const &X0 = matrix<T>(), int info = 1)
- template<typename T> matrix<T> gmres(std::function<matrix<T>(matrix<T> const&)> const &A, matrix<T> const &B, double tol = 1e-6, std::size_t maxit = 10, std::function<matrix<T>(matrix<T> const&)> const &Am1 = std::function<matrix<T>(matrix<T> const&)>(), matrix<T> const &X0 = matrix<T>(), int info = 1)
See linsolve.
intersect¶
-
template<typename R, typename S>
auto castor::intersect(matrix<R> const &A, matrix<S> const &B)¶ Set intersection of two arrays. C = intersect(A,B) for matrix A and B returns a vector with the values common to the two matrix, with no repetitions. C will be sorted.
matrix<> A = {1,2,3}; matrix<> B = {2,3,4}; matrix<> C = intersect(A,B); disp(C);
See argintersect, setdiff, unique, union2.
kron¶
-
template<typename R, typename S>
auto castor::kron(matrix<R> const &A, matrix<S> const &B)¶ Kronecker tensor product.
kron(A,B) is the Kronecker tensor product of A and B. The result is a large matrix formed by taking all possible products between the elements of A and those of B. For example, if A is 2 by 3, then kron(A,B) is [ A(1,1)*B A(1,2)*B A(1,3)*B A(2,1)*B A(2,2)*B A(2,3)*B ]
matrix<> A = eye(2,3); matrix<> B = ones(3,2); matrix<> C = kron(A,B); disp(C);
See mtimes.
max¶
-
template<typename T>
matrix<T> castor::max(matrix<T> const &A, int dim)¶ Maximum elements of an array.
M = max(A) is the largest element in the array A.
matrix<> A = {{1,2,3},{4,5,6}}; double m = max(A); disp(m);
M = max(A,DIM) operates along the dimension DIM: if DIM==0, M is the maximum element of the array. if DIM==1, M is a vector containing the maximum element from each column. if DIM==2, M is a vector containing the maximum element from each row.
matrix<> A = {{1,2,3},{4,5,6}}; matrix<> R = max(A,1); matrix<> C = max(A,2); disp(R); disp(C);
min¶
-
template<typename T>
matrix<T> castor::min(matrix<T> const &A, int dim)¶ Minimum elements of an array.
M = min(A) is the smallest element in the array A.
matrix<> A = {{1,2,3},{4,5,6}}; double m = min(A); disp(m);
M = min(A,DIM) operates along the dimension DIM: if DIM==0, M is the minimum element. if DIM==1, M is a vector containing the minimum element from each column. if DIM==2, M is a vector containing the minimum element from each row.
matrix<> A = {{1,2,3},{4,5,6}}; matrix<> R = min(A,1); matrix<> C = min(A,2); disp(R); disp(C);
maximum¶
-
template<typename R, typename S>
auto castor::maximum(matrix<R> const &A, matrix<S> const &B)¶ Maximum elements between two arrays.
C = maximum(A,B) returns an array with the largest elements taken from A or B. A and B must have compatible sizes. In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension sizes of the inputs are the same.
matrix<> A = {{1,2,3},{4,5,6}}; matrix<> B = {{6,5,4},{3,2,1}}; matrix<> C = maximum(A,B); matrix<> D = maximum(A,3); disp(C); disp(D);
mean¶
-
template<typename T>
matrix<T> castor::mean(matrix<T> const &A, int dim)¶ Average or mean value.
M = mean(A) is the mean value of all the elements in the array A.
matrix<> A = {{1,2,3},{4,5,6}}; double m = mean(A); disp(m);
M = mean(A,DIM) takes the mean along the dimension DIM of A. if DIM==0, M is the mean value of the array. if DIM==1, M is a vector containing the mean value from each column. if DIM==2, M is a vector containing the mean value from each row.
matrix<> A = {{1,2,3},{4,5,6}}; matrix<> R = mean(A,1); matrix<> C = mean(A,2); disp(R); disp(C);
median¶
-
template<typename T>
matrix<T> castor::median(matrix<T> const &A, int dim)¶ Median value.
M = median(A) is the median value of the elements in A.
matrix<> A = {{1,2,3},{4,5,6}}; double m = median(A); disp(m);
M = median(A,DIM) takes the median along the dimension DIM of A. if DIM==0, M is the mediane value of the array. if DIM==1, M is a vector containing the mediane value from each column. if DIM==2, M is a vector containing the mediane value from each row.
matrix<> A = {{1,2,3},{4,5,6}}; matrix<> R = median(A,1); matrix<> C = median(A,2); disp(R); disp(C);
minimum¶
-
template<typename R, typename S>
auto castor::minimum(matrix<R> const &A, matrix<S> const &B)¶ Minimum elements between two arrays.
C = minimum(A,B) returns an array with the smallest elements taken from A or B. A and B must have compatible sizes. In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension sizes of the inputs are the same.
matrix<> A = {{1,2,3},{4,5,6}}; matrix<> B = {{6,5,4},{3,2,1}}; matrix<> C = minimum(A,B); matrix<> D = minimum(A,3); disp(C); disp(D);
mtimes¶
-
template<typename R, typename S>
auto castor::mtimes(matrix<R> const &A, matrix<S> const &B)¶ Matrix multiply.
mtimes(A,B) is the matrix product of A and B, the number of columns of A must equal the number of rows of B.
matrix<> A = ones(3,1); matrix<> B = ones(1,2); matrix<> C = mtimes(A,B); disp(C);
norm¶
-
template<typename S>
auto castor::norm(matrix<S> const &A, std::string typ, int dim)¶ Vectorial norm applied to all values of a matrix. Vectorial norms are not matrix norm (e.g. Frobenius, SVD, etc.), but norms applied to all element of a matrix, using linear indexing.
norm(X) is the euclidian norm.
matrix<> A = eye(3,4); double nrm = norm(A); disp(nrm);
norm(X,TYP) is the TYP-norm of X : TYP=1 returns the 1-norm of X, TYP=2 returns the 2-norm of X, TYP=”inf” returns the infinite norm of X.
matrix<> A = eye(3,4); double nrm1 = norm(A,"1"); double nrm2 = norm(A,"2"); double nrmI = norm(A,"inf"); disp(nrm1); disp(nrm2); disp(nrmI);
norm(X,TYP,DIM) returns the TYP-norm of X along the dimension DIM.
matrix<> A = eye(3,4); matrix<> R = norm(A,"inf",1); matrix<> C = norm(A,"inf",2); disp(R); disp(C);
prod¶
-
template<typename T>
matrix<T> castor::prod(matrix<T> const &A, int dim)¶ Product of elements.
P = prod(A) is the product of all the elements of the array A.
matrix<> A = {{1,2,3},{4,5,6}}; double p = prod(A); disp(p);
prod(A,DIM) operates along the dimension DIM: if DIM==0, M is the product of all elements. if DIM==1, M is a vector containing the prpduct from each column. if DIM==2, M is a vector containing the product from each row.
matrix<> A = {{1,2,3},{4,5,6}}; matrix<> R = prod(A,1); matrix<> C = prod(A,2); disp(R); disp(C);
setdiff¶
-
template<typename R, typename S>
auto castor::setdiff(matrix<R> const &A, matrix<S> const &B)¶ Set difference of two arrays. C = setdiff(A,B) for matrix A and B returns a vector with the values in A that are not in B, with no repetitions. C will be sorted.
matrix<> A = {1,2,3}; matrix<> B = {2,3,4}; matrix<> C = setdiff(A,B); disp(C);
See argsetdiff, intersect, unique, union2.
sort¶
-
template<typename T>
matrix<T> castor::sort(matrix<T> const &A, int dim = 0)¶ Sort in ascending order.
B = sort(A) sorts the elements of A in ascending order. The sorted output B has the same type and size as A.
matrix<> A = {{6,5,4},{3,2,1}}; matrix<> B = sort(A); disp(B);
B = sort(A,DIM) also specifies a dimension DIM to sort along. if DIM==0, M is the sorted element of the array. if DIM==1, M is a vector containing the sorted elements from each column. if DIM==2, M is a vector containing the sorted elements from each row.
matrix<> A = {{6,5,4},{3,2,1}}; matrix<> R = sort(A,1); matrix<> C = sort(A,2); disp(R); disp(C);
stddev¶
-
template<typename T>
matrix<T> castor::stddev(matrix<T> const &A, int dim)¶ Standard deviation of elements.
S = stddev(A) is the standard deviation of all elements of the array A.
matrix<> A = {{1,2,3},{4,5,6}}; double m = stddev(A); disp(m);
S = stddev(A,DIM) is the standard deviation along the dimension DIM. if DIM==0, M is the standard deviation of the array. if DIM==1, M is a vector containing the standard deviation from each column. if DIM==2, M is a vector containing the standard deviation from each row.
matrix<> A = {{1,2,3},{4,5,6}}; matrix<> R = stddev(A,1); matrix<> C = stddev(A,2); disp(R); disp(C);
sum¶
-
template<typename T>
matrix<T> castor::sum(matrix<T> const &A, int dim)¶ Sum of elements.
S = sum(A) is the sum of all the elements of the array A.
matrix<> A = {{1,2,3},{4,5,6}}; double s = sum(A); disp(s);
S = sum(A,DIM) sums along the dimension DIM. if DIM==0, M is the sum of all element of the array. if DIM==1, M is a vector containing the sum from each column. if DIM==2, M is a vector containing the sum from each row.
matrix<> A = {{1,2,3},{4,5,6}}; matrix<> R = sum(A,1); matrix<> C = sum(A,2); disp(R); disp(C);
tgemm¶
-
template<typename P, typename Q, typename R, typename S, typename T>
void castor::tgemm(P alpha, matrix<Q> const &A, matrix<R> const &B, S beta, matrix<T> &C)¶ In-place matrix product.
tgemm(alpha,A,B,beta,C) performs the in-place matrix-matrix operations C = alpha*A*B + beta*C, where alpha, beta are scalars and A, B, C are matrices with compatible size.
NOTE : This is a naive implementation, you can use the cblas interface proposed in “linalg.hpp” to get better performance.
matrix<> A = {{1,2,3},{4,5,6}}; matrix<> B = eye(3,3); matrix<> C = zeros(2,3); tgemm(1,A,B,1,C); disp(C);
union2¶
-
template<typename R, typename S>
auto castor::union2(matrix<R> const &A, matrix<S> const &B)¶ Set union of two arrays. C = union2(A,B) for matrix A and B, returns a vector with the combined values of the two matrix, with no repetitions. C will be sorted.
matrix<> A = {1,2,3}; matrix<> B = {2,3,4}; matrix<> C = union2(A,B); disp(C);
unique¶
variance¶
-
template<typename T>
matrix<T> castor::variance(matrix<T> const &A, int dim)¶ Variance of elements.
S = variance(X) is the variance of all elements of the array X. If N is the sample size, variance normalizes by N and produces the second moment of the sample about its mean.
matrix<> A = {{1,2,3},{4,5,6}}; double v = variance(A); disp(v);
S = variance(X,DIM) is the variance along the dimension DIM: if DIM==0, M is the variance of the array. if DIM==1, M is a vector containing the variance from each column. if DIM==2, M is a vector containing the variance from each row.
matrix<> A = {{1,2,3},{4,5,6}}; matrix<> R = variance(A,1); matrix<> C = variance(A,2); disp(R); disp(C);