breeze

linalg

package linalg

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.

Linear Supertypes
LinearAlgebra, AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. linalg
  2. LinearAlgebra
  3. AnyRef
  4. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Type Members

  1. sealed trait Axis extends AnyRef

    This trait is commonly used for breeze.linalg.

  2. class CSCMatrix[V] extends Matrix[V] with MatrixLike[V, CSCMatrix[V]]

    A compressed sparse column matrix, as used in Matlab and CSparse, etc.

  3. trait CSCMatrixOps_Double extends AnyRef

    This is an auto-generated trait providing operators for CSCMatrix

  4. trait CSCMatrixOps_Float extends AnyRef

    This is an auto-generated trait providing operators for CSCMatrix

  5. trait CSCMatrixOps_Int extends AnyRef

    This is an auto-generated trait providing operators for CSCMatrix

  6. trait Counter[K, V] extends Tensor[K, V] with CounterLike[K, V, Map[K, V], Counter[K, V]]

  7. trait Counter2[K1, K2, V] extends Tensor[(K1, K2), V] with Counter2Like[K1, K2, V, [V]Map[K1, V], Counter[K2, V], Counter2[K1, K2, V]]

  8. trait Counter2Like[K1, K2, V, +M1[VV] <: Map[K1, VV], +T <: Counter[K2, V], +This <: Counter2[K1, K2, V]] extends TensorLike[(K1, K2), V, This]

    A map-like tensor that acts like a collection of key-value pairs where the set of values may grow arbitrarily.

  9. trait CounterLike[K, V, +M <: Map[K, V], +This <: Counter[K, V]] extends TensorLike[K, V, This] with Serializable

    A map-like tensor that acts like a collection of key-value pairs where the set of values may grow arbitrarily.

  10. trait CounterOps extends AnyRef

  11. final class DenseMatrix[V] extends Matrix[V] with MatrixLike[V, DenseMatrix[V]] with Serializable

    A DenseMatrix is a matrix with all elements found in an array.

  12. trait DenseMatrixMultOps_Double extends DenseMatrixOps_Double

    This is an auto-generated trait providing multiplication for DenseMatrix

  13. trait DenseMatrixMultOps_Float extends DenseMatrixOps_Float

    This is an auto-generated trait providing multiplication for DenseMatrix

  14. trait DenseMatrixMultOps_Int extends DenseMatrixOps_Int

    This is an auto-generated trait providing multiplication for DenseMatrix

  15. trait DenseMatrixMultiplyStuff extends DenseMatrixOps_Double with DenseMatrixMultOps_Double

  16. trait DenseMatrixOps_Double extends DenseMatrixOps_Double_Generic

    This is an auto-generated trait providing operators for DenseMatrix.

  17. trait DenseMatrixOps_Double_Generic extends LowPriorityDenseMatrix

    This is an auto-generated trait providing operators for DenseMatrix.

  18. trait DenseMatrixOps_Float extends DenseMatrixOps_Float_Generic

    This is an auto-generated trait providing operators for DenseMatrix.

  19. trait DenseMatrixOps_Float_Generic extends LowPriorityDenseMatrix

    This is an auto-generated trait providing operators for DenseMatrix.

  20. trait DenseMatrixOps_Int extends DenseMatrixOps_Int_Generic

    This is an auto-generated trait providing operators for DenseMatrix.

  21. trait DenseMatrixOps_Int_Generic extends LowPriorityDenseMatrix

    This is an auto-generated trait providing operators for DenseMatrix.

  22. class DenseVector[E] extends StorageVector[E] with VectorLike[E, DenseVector[E]] with Serializable

    A DenseVector is the "obvious" implementation of a Vector, with one twist.

  23. trait DenseVectorOps_Double extends DenseVectorOps_Double_Generic

    This is an auto-generated trait providing operators for DenseVector.

  24. trait DenseVectorOps_Double_Generic extends AnyRef

    This is an auto-generated trait providing operators for DenseVector.

  25. trait DenseVectorOps_Float extends DenseVectorOps_Float_Generic

    This is an auto-generated trait providing operators for DenseVector.

  26. trait DenseVectorOps_Float_Generic extends AnyRef

    This is an auto-generated trait providing operators for DenseVector.

  27. trait DenseVectorOps_HashVector_Double extends AnyRef

    This is an auto-generated trait providing operators for DenseVector and HashVector

  28. trait DenseVectorOps_HashVector_Float extends AnyRef

    This is an auto-generated trait providing operators for DenseVector and HashVector

  29. trait DenseVectorOps_HashVector_Int extends AnyRef

    This is an auto-generated trait providing operators for DenseVector and HashVector

  30. trait DenseVectorOps_Int extends DenseVectorOps_Int_Generic

    This is an auto-generated trait providing operators for DenseVector.

  31. trait DenseVectorOps_Int_Generic extends AnyRef

    This is an auto-generated trait providing operators for DenseVector.

  32. trait DenseVectorOps_SparseVector_Double extends AnyRef

    This is an auto-generated trait providing operators for DenseVector and SparseVector

  33. trait DenseVectorOps_SparseVector_Float extends AnyRef

    This is an auto-generated trait providing operators for DenseVector and SparseVector

  34. trait DenseVectorOps_SparseVector_Int extends AnyRef

    This is an auto-generated trait providing operators for DenseVector and SparseVector

  35. trait DenseVector_GenericOps extends AnyRef

  36. trait DenseVector_SpecialOps extends DenseVectorOps_Double

  37. class HashVector[E] extends Vector[E] with VectorLike[E, HashVector[E]]

    A HashVector is a sparse vector backed by an OpenAddressHashArray

  38. trait HashVectorOps_Double extends AnyRef

    This is an auto-generated trait providing operators for HashVector.

  39. trait HashVectorOps_Float extends AnyRef

    This is an auto-generated trait providing operators for HashVector.

  40. trait HashVectorOps_Int extends AnyRef

    This is an auto-generated trait providing operators for HashVector.

  41. trait LinearAlgebra extends AnyRef

    Basic linear algebraic operations.

  42. trait LowPriorityCounter2 extends AnyRef

  43. trait LowPriorityDenseMatrix extends LowPriorityDenseMatrix1

  44. trait LowPriorityDenseMatrix1 extends AnyRef

  45. trait Matrix[E] extends MatrixLike[E, Matrix[E]]

  46. trait MatrixConstructors[Vec[T] <: Matrix[T]] extends AnyRef

  47. class MatrixEmptyException extends IllegalArgumentException

  48. trait MatrixLike[E, +Self <: Matrix[E]] extends Tensor[(Int, Int), E] with TensorLike[(Int, Int), E, Self]

  49. trait MatrixMultOps_Double extends AnyRef

    This is an auto-generated trait providing multiplication for Matrix

  50. trait MatrixMultOps_Float extends AnyRef

    This is an auto-generated trait providing multiplication for Matrix

  51. trait MatrixMultOps_Int extends AnyRef

    This is an auto-generated trait providing multiplication for Matrix

  52. class MatrixNotSquareException extends IllegalArgumentException

  53. class MatrixNotSymmetricException extends IllegalArgumentException

  54. class MatrixSingularException extends RuntimeException

    Thrown when trying to solve using a singular matrix.

  55. class NormCacheDecorator[E] extends Vector[E]

    This decorator automatically caches the norm and sums of a vector and invalidates the cache whenever the vector is updated.

  56. class NotConvergedException extends RuntimeException

    Exception thrown if a routine has not converged.

  57. trait NumericOps[+This] extends AnyRef

    In some sense, this is the real root of the linalg hierarchy.

  58. sealed trait QuasiTensor[K, V] extends AnyRef

    We occasionally need a Tensor that doesn't extend NumericOps directly.

  59. class SliceMatrix[K1, K2, V] extends Matrix[V]

  60. class SliceVector[K, V] extends Vector[V]

    A SliceVector is a vector that is a view of another underlying tensor.

  61. class SparseVector[E] extends StorageVector[E] with VectorLike[E, SparseVector[E]] with Serializable

    A Binary-search backed vector.

  62. trait SparseVectorOps_Double extends AnyRef

    This is an auto-generated trait providing operators for SparseVector

  63. trait SparseVectorOps_Float extends AnyRef

    This is an auto-generated trait providing operators for SparseVector

  64. trait SparseVectorOps_Int extends AnyRef

    This is an auto-generated trait providing operators for SparseVector

  65. trait StorageVector[E] extends Vector[E] with Storage[E]

  66. trait Tensor[K, V] extends TensorLike[K, V, Tensor[K, V]]

    A Tensor defines a map from an index set to a set of values.

  67. trait TensorLike[K, V, +This <: Tensor[K, V]] extends QuasiTensor[K, V] with NumericOps[This]

  68. trait Vector[E] extends VectorLike[E, Vector[E]]

    A Vector represents the mathematical concept of a vector in math.

  69. class VectorBuilder[E] extends NumericOps[VectorBuilder[E]] with Serializable

    A VectorBuilder is basically unsorted Sparse Vector.

  70. trait VectorBuilderOps_Double extends AnyRef

  71. trait VectorConstructors[Vec[T] <: Vector[T]] extends AnyRef

    Trait that can mixed to companion objects to enable utility methods for creating vectors.

  72. trait VectorLike[E, +Self <: Vector[E]] extends Tensor[Int, E] with TensorLike[Int, E, Self]

    Trait for operators and such used in vectors.

  73. trait VectorOps_Double extends AnyRef

    This is an auto-generated trait providing operators for Vector.

  74. trait VectorOps_Float extends AnyRef

    This is an auto-generated trait providing operators for Vector.

  75. trait VectorOps_Int extends AnyRef

    This is an auto-generated trait providing operators for Vector.

  76. sealed trait View extends AnyRef

    Trait used for methods that can return a view or a copy.

Value Members

  1. object Axis

  2. object CSCMatrix extends MatrixConstructors[CSCMatrix] with CSCMatrixOps_Int with CSCMatrixOps_Float with CSCMatrixOps_Double

  3. object Counter extends CounterOps with Serializable

  4. object Counter2 extends LowPriorityCounter2

  5. object DenseMatrix extends LowPriorityDenseMatrix with DenseMatrixOps_Int with DenseMatrixOps_Float with DenseMatrixOps_Double with DenseMatrixMultOps_Int with DenseMatrixMultOps_Float with DenseMatrixMultOps_Double with DenseMatrixMultiplyStuff with MatrixConstructors[DenseMatrix] with Serializable

  6. object DenseVector extends VectorConstructors[DenseVector] with DenseVector_GenericOps with DenseVectorOps_Int with DenseVectorOps_Float with DenseVectorOps_Double with DenseVectorOps_SparseVector_Double with DenseVectorOps_SparseVector_Float with DenseVectorOps_SparseVector_Int with DenseVectorOps_HashVector_Double with DenseVectorOps_HashVector_Float with DenseVectorOps_HashVector_Int with DenseVector_SpecialOps with Serializable

  7. object HashVector extends HashVectorOps_Int with HashVectorOps_Float with HashVectorOps_Double

  8. def LU[T](X: Matrix[T])(implicit td: (T) ⇒ Double): (DenseMatrix[Double], Array[Int])

    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).

    Definition Classes
    LinearAlgebra

  9. object LinearAlgebra extends LinearAlgebra

  10. object Matrix extends MatrixConstructors[Matrix] with MatrixMultOps_Double with MatrixMultOps_Float with MatrixMultOps_Int

  11. object MutableInnerProductSpaceDenseMatrixDouble

    Import this to provide access to a DenseMatrix[Double] as a MutableInnerProductSpace, so it can be used in optimization.

  12. object NotConvergedException extends Serializable

  13. object NumericOps

  14. object SparseVector extends SparseVectorOps_Int with SparseVectorOps_Float with SparseVectorOps_Double with Serializable

  15. object Tensor

  16. object Vector extends VectorOps_Int with VectorOps_Double with VectorOps_Float

  17. object VectorBuilder extends VectorBuilderOps_Double with Serializable

  18. object View

  19. def axpy[A, X, Y](a: A, x: X, y: Y)(implicit axpy: CanAxpy[A, X, Y]): Unit

    Computes y += x * a, possibly doing less work than actually doing that operation

  20. def canLoadNativeBlas: Boolean

    Attempts to load the NativeBlas libraries.

    Attempts to load the NativeBlas libraries. Returns false if we can't.

    returns

  21. def cholesky(X: Matrix[Double]): DenseMatrix[Double]

    Computes the cholesky decomposition A of the given real symmetric positive definite matrix X such that X = A A.

    Computes the cholesky decomposition A of the given real symmetric positive definite matrix X such that X = A A.t.

    XXX: For higher dimensionalities, the return value really should be a sparse matrix due to its inherent lower triangular nature.

    Definition Classes
    LinearAlgebra

  22. def copy[T](t: T)(implicit canCopy: CanCopy[T]): T

    Copy a T.

    Copy a T. Most tensor objects have a CanCopy implicit, which is what this farms out to.

  23. def cross[V1](a: DenseVector[V1], b: DenseVector[V1])(implicit ring: Ring[V1], man: ClassManifest[V1]): DenseVector[V1]

    Vector cross product of 3D vectors a and b.

    Vector cross product of 3D vectors a and b.

    Definition Classes
    LinearAlgebra

  24. def det[T](X: Matrix[T])(implicit td: (T) ⇒ Double): Double

    Computes the determinant of the given real matrix.

    Computes the determinant of the given real matrix.

    Definition Classes
    LinearAlgebra

  25. def diag[V](t: DenseVector[V])(implicit arg0: ClassManifest[V], arg1: DefaultArrayValue[V]): DenseMatrix[V]

    Creates a Diagonal dense matrix from this vector.

    Creates a Diagonal dense matrix from this vector.

    TODO make a real diagonal matrix class

    V
    t
    returns

  26. def diag[V](m: DenseMatrix[V]): DenseVector[V]

    returns a vector along the diagonal of v.

    returns a vector along the diagonal of v. Requires a square matrix?

    V

    m

    the matrix

  27. def eig(m: Matrix[Double]): (DenseVector[Double], DenseVector[Double], DenseMatrix[Double])

    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

    Definition Classes
    LinearAlgebra

  28. def eigSym(X: Matrix[Double], rightEigenvectors: Boolean): (DenseVector[Double], Option[DenseMatrix[Double]])

    Computes all eigenvalues (and optionally right eigenvectors) of the given real symmetric matrix X.

    Computes all eigenvalues (and optionally right eigenvectors) of the given real symmetric matrix X.

    Definition Classes
    LinearAlgebra

  29. def inv[T](X: Matrix[T])(implicit td: (T) ⇒ Double): DenseMatrix[Double]

    Computes the inverse of a given real matrix.

    Computes the inverse of a given real matrix.

    Definition Classes
    LinearAlgebra

  30. def kron[V1, V2, M, RV](a: DenseMatrix[V1], b: M)(implicit mul: BinaryOp[V1, M, OpMulScalar, DenseMatrix[RV]], asMat: <:<[M, Matrix[V2]], man: ClassManifest[RV], dfv: DefaultArrayValue[RV]): DenseMatrix[RV]

    Returns the Kronecker product of the two matrices a and b, usually denoted a ⊗ b.

    Returns the Kronecker product of the two matrices a and b, usually denoted a ⊗ b.

    Definition Classes
    LinearAlgebra

  31. def linspace(a: Double, b: Double, length: Int = 100): DenseVector[Double]

    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.

  32. def logAndNormalize[T, Axis, V, Result](value: T, axis: Axis)(implicit collapse: CanCollapseAxis[T, Axis, V, V, Result], view: (V) ⇒ NumericOps[V], red: UReduceable[V, Double], map: CanMapValues[V, Double, Double, V], op: BinaryOp[V, Double, OpSub, V]): Result

    logs and then logNormalizes the argument along axis such that each softmax is 0.

    logs and then logNormalizes the argument along axis such that each softmax is 0.0. Returns value if value's softmax is -infinity

  33. def logAndNormalize[V](value: V)(implicit view: (V) ⇒ NumericOps[V], red: UReduceable[V, Double], map: CanMapValues[V, Double, Double, V], op: BinaryOp[V, Double, OpSub, V]): V

    logs and then logNormalizes the argument such that the softmax is 0.

    logs and then logNormalizes the argument such that the softmax is 0.0. Returns value if value's softmax is -infinity

  34. def logNormalize[T, Axis, V, Result](value: T, axis: Axis)(implicit collapse: CanCollapseAxis[T, Axis, V, V, Result], view: (V) ⇒ NumericOps[V], red: UReduceable[V, Double], map: CanMapValues[V, Double, Double, V], op: BinaryOp[V, Double, OpSub, V]): Result

    logs and then logNormalizes the argument along axis such that each softmax is 0.

    logs and then logNormalizes the argument along axis such that each softmax is 0.0. Returns value if value's softmax is -infinity

  35. def logNormalize[V, K](value: V)(implicit view: (V) ⇒ NumericOps[V], red: UReduceable[V, Double], op: BinaryOp[V, Double, OpSub, V]): V

    logNormalizes the argument such that the softmax is 0.

    logNormalizes the argument such that the softmax is 0.0. Returns value if value's softmax is -infinity

  36. def lowerTriangular[T](X: Matrix[T])(implicit arg0: Semiring[T], arg1: ClassManifest[T], arg2: DefaultArrayValue[T]): DenseMatrix[T]

    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.

    Definition Classes
    LinearAlgebra

  37. val max: URFunc[Double, Double]

    Computes the max, aka the infinity norm.

  38. val mean: URFunc[Double, Double]

    A breeze.generic.URFunc for computing the mean of objects

  39. val meanAndVariance: URFunc[Double, (Double, Double)]

    A breeze.generic.URFunc for computing the mean and variance of objects.

    A breeze.generic.URFunc for computing the mean and variance of objects. This uses an efficient, numerically stable, one pass algorithm for computing both the mean and the variance.

  40. val min: URFunc[Double, Double]

    Computes the minimum.

  41. def norm[T](t: T, v: Double)(implicit canNorm: CanNorm[T]): Double

    Computes the norm of an object.

    Computes the norm of an object. Many tensor objects have a CanNorm implicit, which is what this calls.

  42. def normalize[T, Axis, V, Result](value: T, axis: Axis, n: Double)(implicit collapse: CanCollapseAxis[T, Axis, V, V, Result], div: BinaryOp[V, Double, OpDiv, V], canNorm: CanNorm[V]): Result

    Normalizes the argument along each axis such that each row along the axis has norm 1.

    Normalizes the argument along each axis such that each row along the axis has norm 1.0 (with respect to the argument n). Each column is unchanged if it's norm is 0

  43. def normalize[T, U >: T](t: T, n: Double)(implicit div: BinaryOp[T, Double, OpDiv, U], canNorm: CanNorm[T]): U

    Normalizes the argument such that its norm is 1.

    Normalizes the argument such that its norm is 1.0 (with respect to the argument n). Returns value if value's norm is 0.

  44. package operators

  45. def pinv[V](X: DenseMatrix[V])(implicit cast: (V) ⇒ Double): DenseMatrix[Double]

    Computes the Moore-Penrose pseudo inverse of the given real matrix X.

    Computes the Moore-Penrose pseudo inverse of the given real matrix X.

    Definition Classes
    LinearAlgebra

  46. def pinv(X: DenseMatrix[Double]): DenseMatrix[Double]

    Computes the Moore-Penrose pseudo inverse of the given real matrix X.

    Computes the Moore-Penrose pseudo inverse of the given real matrix X.

    Definition Classes
    LinearAlgebra

  47. def pow(m: DenseMatrix[Double], exp: Double): DenseMatrix[Double]

    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.

    m
    exp

    Definition Classes
    LinearAlgebra

  48. def qr(A: DenseMatrix[Double], skipQ: Boolean = false): (DenseMatrix[Double], DenseMatrix[Double])

    QR Factorization

    QR Factorization

    A

    m x n matrix

    skipQ

    (optional) if true, don't reconstruct orthogonal matrix Q (instead returns (null,R))

    returns

    (Q,R) Q: m x m R: m x n

    Definition Classes
    LinearAlgebra

  49. def qrp(A: DenseMatrix[Double]): (DenseMatrix[Double], DenseMatrix[Double], DenseMatrix[Int], Array[Int])

    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

    Definition Classes
    LinearAlgebra

  50. def rank(m: DenseMatrix[Double], tol: Option[Double] = None): Int

    Computes the rank of a DenseMatrix[Double].

    Computes the rank of a DenseMatrix[Double].

    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.

    m

    matrix for which to compute the rank

    tol

    optional tolerance for singular values. If not supplied, the default tolerance is: max(m.cols, m.rows) * eps * sigma_max, where eps is the machine epsilon and sigma_max is the largest singular value of m.

    returns

    the rank of the matrix (number of singular values)

    Definition Classes
    LinearAlgebra

  51. def ranks[V](x: Vector[V])(implicit arg0: Ordering[V]): Array[Double]

    Returns the rank of each element in the given vector, adjusting for ties.

    Returns the rank of each element in the given vector, adjusting for ties.

    Definition Classes
    LinearAlgebra

  52. val softmax: URFunc[Double, Double]

    Computes the softmax (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.

  53. val stddev: URFunc[Double, Double]

    Cmoputes the standard deviation by calling variance and then sqrt'ing

  54. val sum: URFunc[Double, Double]

  55. package support

  56. def svd(mat: DenseMatrix[Double]): (DenseMatrix[Double], DenseVector[Double], DenseMatrix[Double])

    Computes the SVD of a m by n matrix Returns an m*m matrix U, a vector of singular values, and a n*n matrix V'

    Computes the SVD of a m by n matrix Returns an m*m matrix U, a vector of singular values, and a n*n matrix V'

    Definition Classes
    LinearAlgebra

  57. def upperTriangular[T](X: Matrix[T])(implicit arg0: Semiring[T], arg1: ClassManifest[T], arg2: DefaultArrayValue[T]): DenseMatrix[T]

    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.

    Definition Classes
    LinearAlgebra

  58. def useNativeLibraries: Boolean

    Returns true if we can use native libraries.

    Returns true if we can use native libraries. You can disable it by writing breeze.linalg.useNativeLibraries to false

  59. def useNativeLibraries_=(v: Boolean): Unit

    Disables or attempts to enable native libraries.

    Disables or attempts to enable native libraries. Will throw a RuntimeException if you try to set the value to true and we can't load the libraries.

    v

  60. val variance: URFunc[Double, Double]

    A breeze.generic.URFunc for computing the variance of objects.

    A breeze.generic.URFunc for computing the variance of objects. The method just calls meanAndVariance and returns the second result.

Inherited from LinearAlgebra

Inherited from AnyRef

Inherited from Any

Ungrouped