linalg
This trait is commonly used for breeze.linalg.sum and its kin for summing along a particular axis of a Matrix.
TODO
TODO
Class for classes that are broadcasting their columns.
Class for classes that are broadcasting their columns. That is denseMatrix(::, *) /= denseVector
the type of the tensor
the tensor (or equivalent) being broadcasted
Class for classes that are broadcasting their rows.
Class for classes that are broadcasting their rows. That is denseMatrix(*, ::) /= denseVector
the type of the tensor
the tensor (or equivalent) being broadcasted
A compressed sparse column matrix, as used in Matlab and CSparse, etc.
A compressed sparse column matrix, as used in Matlab and CSparse, etc.
Most implementations based on "Direct Methods for Sparse Linear Systems" by Timothy A. Davis
A map-like tensor that acts like a collection of key-value pairs where the set of values may grow arbitrarily.
A map-like tensor that acts like a collection of key-value pairs where the set of values may grow arbitrarily.
A map-like tensor that acts like a collection of key-value pairs where the set of values may grow arbitrarily.
A DenseMatrix is a matrix with all elements found in an array.
A DenseMatrix is a matrix with all elements found in an array. It is column major unless isTranspose is true, It is designed to be fast: Double- (and potentially Float-)valued DenseMatrices can be used with blas, and support operations to that effect.
A DenseVector is the "obvious" implementation of a Vector, with one twist.
A DenseVector is the "obvious" implementation of a Vector, with one twist. The underlying data may have more data than the Vector, represented using an offset into the array (for the 0th element), and a stride that is how far elements are apart from one another.
The i'th element is at offset + i * stride
A HashVector is a sparse vector backed by an OpenAddressHashArray
Marker trait for exceptions thrown from the breeze.linalg package.
Thrown when trying to solve using a singular matrix.
Exception thrown if a routine has not converged.
In some sense, this is the real root of the linalg hierarchy.
In some sense, this is the real root of the linalg hierarchy. It provides methods for doing operations on a Tensor-like thing. All methods farm out to some implicit or another. We use this when we don't care about the index into the Tensor, or if we don't really have an index.
Perform Principal Components Analysis on input data.
Perform Principal Components Analysis on input data. Handles scaling of the when computing the covariance matrix. Lazily produces the scores (the translation of the data to their new coordinates on the PC axes.
Input is a matrix that has data points as rows. Variable naming and documentation inspired and used directy from the 'princomp' function in R.
We occasionally need a Tensor that doesn't extend NumericOps directly.
We occasionally need a Tensor that doesn't extend NumericOps directly. This is that tensor.
A SliceVector is a vector that is a view of another underlying tensor.
A SliceVector is a vector that is a view of another underlying tensor. For instance:
val m = DenseMatrix(...) m( (1,2), (3,4), (4,5))
will give a SliceVector such that apply/update at index 0 will map to m(1,2), index 1 to m(3,4), etc.
A vector backed by binary search (with breeze.collection.mutable.SparseArray).
A vector backed by binary search (with breeze.collection.mutable.SparseArray). There is a parallel array of ints (in 0 until length) and values, sorted by index value. To quickly access all stored values use the following loop:
var offset = 0 while( offset < v.activeSize) { val index: Int = v.indexAt(offset) val value: E = v.valueAt(offset) offset += 1 }
Add methods to the string class in order to make file reading easier
A Tensor defines a map from an index set to a set of values.
TODO
A Vector represents the mathematical concept of a vector in math.
A VectorBuilder is basically an unsorted Sparse Vector.
A VectorBuilder is basically an unsorted Sparse Vector. Two parallel arrays are maintained, one of indices, and another of values. The indices are not sorted. Moreover, <B> indices are not unique in the index array. Furthermore, apply(i) and update(i, v) are linear in the number of active values in the array. + and - are linear operations: they just append to the end. Component wise multiply, divide, and dot product are also linear, but require creating a HashVector copy. (TODO: maybe a SparseVector?) In general, these should never be used, except for building, or for doing feature vector type things where you just need a sparse vector with a fast dot product with a "real" vector.
Trait that can mixed to companion objects to enable utility methods for creating vectors.
Trait for operators and such used in vectors.
Reducing UFunc that provides implementations for Broadcasted Dense stuff
Trait used for methods that can return a view or a copy.
Usually used as the return type from zipValues
Nearly direct port of http://www.mathworks.com/matlabcentral/fileexchange/27183-lsmr--an-iterative-algorithm-for-least-squares-problems (BSD licensed code)
Nearly direct port of http://www.mathworks.com/matlabcentral/fileexchange/27183-lsmr--an-iterative-algorithm-for-least-squares-problems (BSD licensed code)
http://web.stanford.edu/group/SOL/software/lsmr/
The only difference is that they square the regularization factor.
Computes the LU factorization of the given real M-by-N matrix X such that X = P * L * U where P is a permutation matrix (row exchanges).
Computes the LU factorization of the given real M-by-N matrix X such that X = P * L * U where P is a permutation matrix (row exchanges).
Upon completion, a tuple consisting of a matrix A and an integer array P.
The upper triangular portion of A resembles U whereas the lower triangular portion of A resembles L up to but not including the diagonal elements of L which are all equal to 1.
For 0 <= i < M, each element P(i) denotes whether row i of the matrix X was exchanged with row P(i-1) during computation (the offset is caused by the internal call to LAPACK).
Returns a cumulative sum of the vector (ie cumsum).
all(t) true if all elements of t are non-zero all(f, t) returns true if all elements of t satisfy f
any(t) true if any element of t is non-zero any(f, t) returns true if any element of t satisfies f
Returns the key that has maximum value
Returns a sequence of keys sorted by value
Returns the top k indices with maximum value
Computes y += x * a, possibly doing less work than actually doing that operation
Computes the cholesky decomposition A of the given real symmetric positive definite matrix X such that X = A A.t.
Computes the cholesky decomposition A of the given real symmetric positive definite matrix X such that X = A A.t.
TODO: For higher dimensionalities, the return value really should be a sparse matrix due to its inherent lower triangular nature.
clip(a, lower, upper) returns an array such that all elements are "clipped" at the range (lower, upper)
Computes the condition number of the given real matrix.
Provides casting facilities similar to Numpy's "astype" and Julia's "convert".
Provides casting facilities similar to Numpy's "astype" and Julia's "convert". Does casts of collections from one type to another. For example,
convert(DenseVector(0.1, 1.0, 1.5), Int) == DenseVector(0, 1, 1)
Copy a T.
Copy a T. Most tensor objects have a CanCopy implicit, which is what this farms out to.
Compute the covariance matrix from the given data, centering if necessary.
Compute the covariance matrix from the given data, centering if necessary. Very simple, just does the basic thing.
Vector cross product of 3D vectors a and b.
Reads in a DenseMatrix from a CSV File
Computes the determinant of the given real matrix.
returns a vector along the diagonal of v.
returns a vector along the diagonal of v. Requires a square matrix?
Differences between adjacent elements and discrete derivatives.
breeze 7/15/14
Eigenvalue decomposition (right eigenvectors)
Eigenvalue decomposition (right eigenvectors)
This function returns the real and imaginary parts of the eigenvalues, and the corresponding eigenvectors. For most (?) interesting matrices, the imaginary part of all eigenvalues will be zero (and the corresponding eigenvectors will be real). Any complex eigenvalues will appear in complex-conjugate pairs, and the real and imaginary components of the eigenvector for each pair will be in the corresponding columns of the eigenvector matrix. Take the complex conjugate to find the second eigenvector.
Based on EVD.java from MTJ 0.9.12
Computes all eigenvalues (and optionally right eigenvectors) of the given real symmetric matrix X.
mirrors the columns (left<->right).
mirrors the rows (up down)
Computes the inverse of a given real matrix.
Computes the inverse of a given real matrix. In general, you should avoid using this metho in combination with *. Instead, wherever you might want to write inv(A) * B, you should write A \ B.
Created by dlwh on 11/1/15.
Returns the Kronecker product of two matrices a and b, usually denoted a ⊗ b.
Generates a vector of linearly spaced values between a and b (inclusive).
Generates a vector of linearly spaced values between a and b (inclusive). The returned vector will have length elements, defaulting to 100.
Computes the log of the determinant of the given real matrix.
Computes the log of the determinant of the given real matrix. The value returned is (sign of determinant, log of determinant). This method can be more accurate than just using breeze.linalg.det, if det is very small.
The lower triangular portion of the given real quadratic matrix X.
The lower triangular portion of the given real quadratic matrix X. Note that no check will be performed regarding the symmetry of X.
UFunc for being able to map the keys and values in a value collection to new values.
Computes the minimum.
Minimum and maximum in one traversal, along an axis.
Raises m to the exp'th power via eigenvalue decomposition.
Raises m to the exp'th power via eigenvalue decomposition. Currently requires that m's eigenvalues are real.
Computes the norm of an object.
Computes the norm of an object. Many tensor objects have a norm implementation implicit, which is what this calls.
Normalizes the argument such that its norm is 1.0 (with respect to the argument n).
Normalizes the argument such that its norm is 1.0 (with respect to the argument n). Returns value if value's norm is 0.
Computes the Moore-Penrose pseudo inverse of the given real matrix X.
Computes the Moore-Penrose pseudo inverse of the given real matrix X.
The pseudo inverse is nothing but the least-squares solution to AX=B, hence: d/dX 1/2 (AX-B)2 = AT (AX-B) Solving AT (AX-B) = 0 for X yields AT AX = A^T B
Performs a principal components analysis on the given numeric data matrix and returns the results as an object of class PCA.
Performs a principal components analysis on the given numeric data matrix and returns the results as an object of class PCA.
If the no covariance matrix is supplied, one obtained from the given data is used.
Computes the product
Peak-to-peak, ie the Range of values (maximum - minimum) along an axis.
QR Factorization
QR Factorization
Previous versions of Breeze had qr(m, skipQ), where we could skip the computation in making Q if we didn't want it. That is now supplanted by qr.justR(m)
Supports complete and reduced mode of factorization of matrix A with dimensions (m, n). If mode is complete matrices Q and R have dimensions (m, m), (m, n). If mode is reduced matrices Q and R have dimensions (m, k), (k, n) with k = min(m, n).
Complete QR factorization can be called by qr(A).
Reduced QR factorization can be called by qr.reduced(A). If computation of Q is unnecessary, it can be skipped by qr.reduced.justR(A)
(Q, R) Q - A matrix with orthonormal columns R - The upper-triangular matrix
QR Factorization with pivoting
QR Factorization with pivoting
input: A m x n matrix output: (Q,R,P,pvt) where AP = QR Q: m x m R: m x n P: n x n : permutation matrix (P(pvt(i),i) = 1) pvt : pivot indices
Alias for randomDouble
Gives Gaussian-distributed random Double(s) + randn()...
Gives Gaussian-distributed random Double(s) + randn()... returns a Gaussian random variable with mean 0, variance 1 + randn( n: Int )... returns a DenseVector with n randn's + randn( (n1: Int, n2: Int) )... returns an n1 x n2 DenseMatrix with randn's
Gives a random Double.
Gives a random Double. + randomDouble()... returns a random double, in [0, 1] + randomDouble( n: Int )... returns a DenseVector with n random doubles, in [0, 1] + randomDouble( n: Int, (r1: Double, r2: Double) )... returns a DenseVector with n random doubles, in [r1, r2] + randomDouble( (n1: Int, n2: Int) )... returns an n1 x n2 DenseMatrix with n random doubles, in [0, 1] + randomDouble( (n1: Int, n2: Int), (r1: Double, r2: Double) )... returns an n1 x n2 DenseMatrix with n random doubles, in [r1, r2]
Gives a random Int.
Gives a random Int. + randomInt()... returns a random Int, in [0, 1] + randomInt( n: Int )... returns a DenseVector with n random Ints, in [0, 1] + randomInt( n: Int, (r1: Int, r2: Int) )... returns a DenseVector with n random Ints, in [r1, r2) + randomInt( (n1: Int, n2: Int) )... returns an n1 x n2 DenseMatrix with n random Ints, in [0, 1] + randomInt( (n1: Int, n2: Int), (r1: Int, r2: Int) )... returns an n1 x n2 DenseMatrix with n random Ints, in [r1, r2)
Computes the rank of a matrix.
Computes the rank of a matrix.
The rank of the matrix is computed using the SVD method. The singular values of the SVD which are greater than a specified tolerance are counted.
the rank of the matrix (number of singular values)
Returns the rank of each element in the given vector, adjusting for ties.
breeze 7/4/14
Returns a reversed copy of the DenseVector.
roll the array
Rotates a matrix by 90 * k degrees counter clockwise.
Rotates a matrix by 90 * k degrees counter clockwise. if k is not specified, it defaults to 1.
A generic function (based on the R function of the same name) whose default method centers and/or scales the columns of a numeric matrix.
A generic function (based on the R function of the same name) whose default method centers and/or scales the columns of a numeric matrix.
If ‘scale’ is ‘TRUE’ then scaling is done by dividing the (centered) columns of ‘x’ by their standard deviations if ‘center’ is ‘TRUE’, and the root mean square otherwise. If ‘scale’ is ‘FALSE’, no scaling is done.
method for representing scaleAdd(y, a, x) == y + a * x
method for representing scaleAdd(y, a, x) == y + a * x
This method is designed to eventually replace breeze.linalg.axpy
Return the given DenseVector, Array, or DenseMatrix as a shuffled copy by using Fisher-Yates shuffle.
Return the given DenseVector, Array, or DenseMatrix as a shuffled copy by using Fisher-Yates shuffle. Additionally, can return the given Array as a shuffled copy with the corresponding shuffle index information, or return the given Array as a shuffled copy using the inverse of the given shuffle index information, reversing the shuffle.
Computes the softmax (a.k.a.
Computes the softmax (a.k.a. logSum) of an object. Softmax is defined as \log \sum_i \exp(x(i)), but implemented in a more numerically stable way. Softmax is so-called because it is a differentiable function that tends to look quite a lot like max. Consider log(exp(30) + exp(10)). That's basically 30. We use softmax a lot in machine learning.
split the array
Computes the squared distance between two vectors.
The lower triangular portion of the given real quadratic matrix X with the diagnal elements is zero!
The upper triangular portion of the given real quadratic matrix X with the diagnal elements is zero!
TODO
Computes the SVD of a M-by-N matrix Returns an M-by-M matrix U, a vector of singular values, and a N-by-N matrix V'
Computes the determinant of the given real matrix.
deduplicates the array
The upper triangular portion of the given real quadratic matrix X.
The upper triangular portion of the given real quadratic matrix X. Note that no check will be performed regarding the symmetry of X.
val to determine if breeze is using natives or f2jblas
where(a) returns those indices that are non-zero
where(a) returns those indices that are non-zero
where(cond, a, b) returns the value from a if cond is non-zero, and the value from b otherwise
This package contains everything relating to Vectors, Matrices, Tensors, etc.
If you're doing basic work, you probably want breeze.linalg.DenseVector and breeze.linalg.DenseMatrix, which support most operations. We also have breeze.linalg.SparseVectors and (basic!) support for a sparse matrix (breeze.linalg.CSCMatrix).
This package object contains Matlab-esque functions for interacting with tensors and matrices.