Packages

  • package root
    Definition Classes
    root
  • package scalation

    The scalation package specifies system-wide constants for directory paths.

    The scalation package specifies system-wide constants for directory paths. Sub-packages may wish to define 'BASE-DIR = DATA_DIR + ⁄ + <package>' in their own 'package.scala' files. For maintainability, directory paths should only be specified in 'package.scala' files.

    Definition Classes
    root
  • package linalgebra

    The linalgebra package contains classes, traits and objects for linear algebra, including vectors and matrices for real and complex numbers.

    The linalgebra package contains classes, traits and objects for linear algebra, including vectors and matrices for real and complex numbers.

    Definition Classes
    scalation
  • package bld

    The bld package contains traits and objects for generating source code for vector classes, matrix traits and matrix classes.

    The bld package contains traits and objects for generating source code for vector classes, matrix traits and matrix classes.

    Definition Classes
    linalgebra
  • package gen

    The gen package contains generic classes, traits and objects for linear algebra, including vectors and matrices for types implementing Numeric.

    The gen package contains generic classes, traits and objects for linear algebra, including vectors and matrices for types implementing Numeric. Tend to run more slowly than the specialized versions in linalgebra.

    Definition Classes
    linalgebra
  • package mem_mapped

    The mem_mapped package contains classes, traits and objects for out-of-core linear algebra, including vectors and matrices for real and complex numbers.

    The mem_mapped package contains classes, traits and objects for out-of-core linear algebra, including vectors and matrices for real and complex numbers.

    Definition Classes
    linalgebra
  • package bld

    The bld package contains traits and objects for generating source code for out-of-core vector classes, matrix traits and matrix classes.

  • Converter
  • ConverterTest
  • MatriC
  • MatriD
  • MatriI
  • MatriL
  • MatriQ
  • MatriR
  • MatriS
  • MatrixC
  • MatrixCTest
  • MatrixD
  • MatrixDTest
  • MatrixI
  • MatrixITest
  • MatrixL
  • MatrixLTest
  • MatrixQ
  • MatrixQTest
  • MatrixR
  • MatrixRTest
  • StatVec
  • StatVecTest
  • Vec
  • VectorC
  • VectorCTest
  • VectorD
  • VectorDTest
  • VectorI
  • VectorITest
  • VectorL
  • VectorLTest
  • VectorQ
  • VectorQTest
  • VectorR
  • VectorRTest
  • VectorS
  • VectorSTest
  • package par

    The par package contains classes, traits and objects for parallel linear algebra, including vectors and matrices for real and complex numbers.

    The par package contains classes, traits and objects for parallel linear algebra, including vectors and matrices for real and complex numbers.

    Definition Classes
    linalgebra

package mem_mapped

The mem_mapped package contains classes, traits and objects for out-of-core linear algebra, including vectors and matrices for real and complex numbers.

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. mem_mapped
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. trait MatriC extends Error

    The MatriC trait specifies the operations to be defined by the concrete classes implementing Complex matrices, i.e., MatrixC - dense matrix BidMatrixC - bidiagonal matrix - useful for computing Singular Values SparseMatrixC - sparse matrix - majority of elements should be zero SymTriMatrixC - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixC - parallel dense matrix par.SparseMatrixC - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with "npp".

    The MatriC trait specifies the operations to be defined by the concrete classes implementing Complex matrices, i.e., MatrixC - dense matrix BidMatrixC - bidiagonal matrix - useful for computing Singular Values SparseMatrixC - sparse matrix - majority of elements should be zero SymTriMatrixC - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixC - parallel dense matrix par.SparseMatrixC - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with "npp". ------------------------------------------------------------------------------ row-wise column-wise Append: matrix +: vector matrix +: vector Concatenate: matrix ++ matrix matrix ++ matrix

  2. trait MatriD extends Error

    The MatriD trait specifies the operations to be defined by the concrete classes implementing Double matrices, i.e., MatrixD - dense matrix BidMatrixD - bidiagonal matrix - useful for computing Singular Values SparseMatrixD - sparse matrix - majority of elements should be zero SymTriMatrixD - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixD - parallel dense matrix par.SparseMatrixD - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with "npp".

    The MatriD trait specifies the operations to be defined by the concrete classes implementing Double matrices, i.e., MatrixD - dense matrix BidMatrixD - bidiagonal matrix - useful for computing Singular Values SparseMatrixD - sparse matrix - majority of elements should be zero SymTriMatrixD - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixD - parallel dense matrix par.SparseMatrixD - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with "npp". ------------------------------------------------------------------------------ row-wise column-wise Append: matrix +: vector matrix +: vector Concatenate: matrix ++ matrix matrix ++ matrix

  3. trait MatriI extends Error

    The MatriI trait specifies the operations to be defined by the concrete classes implementing Int matrices, i.e., MatrixI - dense matrix BidMatrixI - bidiagonal matrix - useful for computing Singular Values SparseMatrixI - sparse matrix - majority of elements should be zero SymTriMatrixI - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixI - parallel dense matrix par.SparseMatrixI - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with "npp".

    The MatriI trait specifies the operations to be defined by the concrete classes implementing Int matrices, i.e., MatrixI - dense matrix BidMatrixI - bidiagonal matrix - useful for computing Singular Values SparseMatrixI - sparse matrix - majority of elements should be zero SymTriMatrixI - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixI - parallel dense matrix par.SparseMatrixI - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with "npp". ------------------------------------------------------------------------------ row-wise column-wise Append: matrix +: vector matrix +: vector Concatenate: matrix ++ matrix matrix ++ matrix

  4. trait MatriL extends Error

    The MatriL trait specifies the operations to be defined by the concrete classes implementing Long matrices, i.e., MatrixL - dense matrix BidMatrixL - bidiagonal matrix - useful for computing Singular Values SparseMatrixL - sparse matrix - majority of elements should be zero SymTriMatrixL - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixL - parallel dense matrix par.SparseMatrixL - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with "npp".

    The MatriL trait specifies the operations to be defined by the concrete classes implementing Long matrices, i.e., MatrixL - dense matrix BidMatrixL - bidiagonal matrix - useful for computing Singular Values SparseMatrixL - sparse matrix - majority of elements should be zero SymTriMatrixL - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixL - parallel dense matrix par.SparseMatrixL - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with "npp". ------------------------------------------------------------------------------ row-wise column-wise Append: matrix +: vector matrix +: vector Concatenate: matrix ++ matrix matrix ++ matrix

  5. trait MatriQ extends Error

    The MatriQ trait specifies the operations to be defined by the concrete classes implementing Rational matrices, i.e., MatrixQ - dense matrix BidMatrixQ - bidiagonal matrix - useful for computing Singular Values SparseMatrixQ - sparse matrix - majority of elements should be zero SymTriMatrixQ - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixQ - parallel dense matrix par.SparseMatrixQ - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with "npp".

    The MatriQ trait specifies the operations to be defined by the concrete classes implementing Rational matrices, i.e., MatrixQ - dense matrix BidMatrixQ - bidiagonal matrix - useful for computing Singular Values SparseMatrixQ - sparse matrix - majority of elements should be zero SymTriMatrixQ - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixQ - parallel dense matrix par.SparseMatrixQ - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with "npp". ------------------------------------------------------------------------------ row-wise column-wise Append: matrix +: vector matrix +: vector Concatenate: matrix ++ matrix matrix ++ matrix

  6. trait MatriR extends Error

    The MatriR trait specifies the operations to be defined by the concrete classes implementing Real matrices, i.e., MatrixR - dense matrix BidMatrixR - bidiagonal matrix - useful for computing Singular Values SparseMatrixR - sparse matrix - majority of elements should be zero SymTriMatrixR - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixR - parallel dense matrix par.SparseMatrixR - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with "npp".

    The MatriR trait specifies the operations to be defined by the concrete classes implementing Real matrices, i.e., MatrixR - dense matrix BidMatrixR - bidiagonal matrix - useful for computing Singular Values SparseMatrixR - sparse matrix - majority of elements should be zero SymTriMatrixR - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixR - parallel dense matrix par.SparseMatrixR - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with "npp". ------------------------------------------------------------------------------ row-wise column-wise Append: matrix +: vector matrix +: vector Concatenate: matrix ++ matrix matrix ++ matrix

  7. trait MatriS extends Error

    The MatriS trait specifies the operations to be defined by the concrete classes implementing StrNum matrices, i.e., MatrixS - dense matrix BidMatrixS - bidiagonal matrix - useful for computing Singular Values SparseMatrixS - sparse matrix - majority of elements should be zero SymTriMatrixS - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixS - parallel dense matrix par.SparseMatrixS - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with "npp".

    The MatriS trait specifies the operations to be defined by the concrete classes implementing StrNum matrices, i.e., MatrixS - dense matrix BidMatrixS - bidiagonal matrix - useful for computing Singular Values SparseMatrixS - sparse matrix - majority of elements should be zero SymTriMatrixS - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixS - parallel dense matrix par.SparseMatrixS - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with "npp". ------------------------------------------------------------------------------ row-wise column-wise Append: matrix +: vector matrix +: vector Concatenate: matrix ++ matrix matrix ++ matrix

  8. class MatrixC extends MatriC with Error with Serializable

    The MatrixC class stores and operates on Numeric Matrices of type Complex.

    The MatrixC class stores and operates on Numeric Matrices of type Complex. This class follows the gen.MatrixN framework and is provided for efficiency.

  9. class MatrixD extends MatriD with Error with Serializable

    The MatrixD class stores and operates on Numeric Matrices of type Double.

    The MatrixD class stores and operates on Numeric Matrices of type Double. This class follows the gen.MatrixN framework and is provided for efficiency.

  10. class MatrixI extends MatriI with Error with Serializable

    The MatrixI class stores and operates on Numeric Matrices of type Int.

    The MatrixI class stores and operates on Numeric Matrices of type Int. This class follows the gen.MatrixN framework and is provided for efficiency.

  11. class MatrixL extends MatriL with Error with Serializable

    The MatrixL class stores and operates on Numeric Matrices of type Long.

    The MatrixL class stores and operates on Numeric Matrices of type Long. This class follows the gen.MatrixN framework and is provided for efficiency.

  12. class MatrixQ extends MatriQ with Error with Serializable

    The MatrixQ class stores and operates on Numeric Matrices of type Rational.

    The MatrixQ class stores and operates on Numeric Matrices of type Rational. This class follows the gen.MatrixN framework and is provided for efficiency.

  13. class MatrixR extends MatriR with Error with Serializable

    The MatrixR class stores and operates on Numeric Matrices of type Real.

    The MatrixR class stores and operates on Numeric Matrices of type Real. This class follows the gen.MatrixN framework and is provided for efficiency.

  14. final class StatVec extends AnyVal

    The StatVec value class provides methods for computing statistics on data vectors.

    The StatVec value class provides methods for computing statistics on data vectors. Both maximum likelihood and unbiased estimators are supported. Unbiased should only be used on sample (not population) data. Ex: It can be used to support the Method of Independent Replications (MIR). For efficiency, StatVec is a value class that enriches the VectorD. The corresponding implicit conversion in the package object.

    See also

    stat.StatVector for more complete statistical functions

    stackoverflow.com/questions/14861862/how-do-you-enrich-value-classes-without-overhead -----------------------------------------------------------------------------

  15. trait Vec extends AnyRef

    The Vec trait establishes a common base type for all vectors (e.g., VectorD).

  16. class VectorC extends Traversable[Complex] with PartiallyOrdered[VectorC] with Vec with Error with Serializable

    The VectorC class stores and operates on Numeric Vectors of base type Complex.

    The VectorC class stores and operates on Numeric Vectors of base type Complex. It follows the framework of gen.VectorN [T] and is provided for performance.

  17. class VectorD extends Traversable[Double] with PartiallyOrdered[VectorD] with Vec with Error with Serializable

    The VectorD class stores and operates on Numeric Vectors of base type Double.

    The VectorD class stores and operates on Numeric Vectors of base type Double. It follows the framework of gen.VectorN [T] and is provided for performance.

  18. class VectorI extends Traversable[Int] with PartiallyOrdered[VectorI] with Vec with Error with Serializable

    The VectorI class stores and operates on Numeric Vectors of base type Int.

    The VectorI class stores and operates on Numeric Vectors of base type Int. It follows the framework of gen.VectorN [T] and is provided for performance.

  19. class VectorL extends Traversable[Long] with PartiallyOrdered[VectorL] with Vec with Error with Serializable

    The VectorL class stores and operates on Numeric Vectors of base type Long.

    The VectorL class stores and operates on Numeric Vectors of base type Long. It follows the framework of gen.VectorN [T] and is provided for performance.

  20. class VectorQ extends Traversable[Rational] with PartiallyOrdered[VectorQ] with Vec with Error with Serializable

    The VectorQ class stores and operates on Numeric Vectors of base type Rational.

    The VectorQ class stores and operates on Numeric Vectors of base type Rational. It follows the framework of gen.VectorN [T] and is provided for performance.

  21. class VectorR extends Traversable[Real] with PartiallyOrdered[VectorR] with Vec with Error with Serializable

    The VectorR class stores and operates on Numeric Vectors of base type Real.

    The VectorR class stores and operates on Numeric Vectors of base type Real. It follows the framework of gen.VectorN [T] and is provided for performance.

  22. class VectorS extends Traversable[StrNum] with PartiallyOrdered[VectorS] with Vec with Error with Serializable

    The VectorS class stores and operates on Numeric Vectors of base type StrNum.

    The VectorS class stores and operates on Numeric Vectors of base type StrNum. It follows the framework of gen.VectorN [T] and is provided for performance.

Value Members

  1. implicit def vectorC2StatVec(x: VectorC): StatVec

    Implicit conversion from VectorD to StatVec, which supports more advanced statistical operations on vectors (e.g., covariance).

    Implicit conversion from VectorD to StatVec, which supports more advanced statistical operations on vectors (e.g., covariance). Other vector types require to conversion to VectorD via 'toDouble'. Caveat: won't work for vectors of string numbers (VectorS) since there not a meaningful conversion for general strings.

    x

    the vector to be enriched

  2. implicit def vectorD2StatVec(x: VectorD): StatVec
  3. implicit def vectorI2StatVec(x: VectorI): StatVec
  4. implicit def vectorL2StatVec(x: VectorL): StatVec
  5. implicit def vectorQ2StatVec(x: VectorQ): StatVec
  6. implicit def vectorR2StatVec(x: VectorR): StatVec
  7. object Converter

    The Converter object converts string number vectors to integer vectors.

  8. object ConverterTest extends App

    The ConverterTest object is used to test the Converter class.

    The ConverterTest object is used to test the Converter class. > runMain scalation.linalgebra.mem_mapped.ConverterTest

  9. object MatrixC extends Error with Serializable

    The MatrixC companion object provides operations for MatrixC that don't require 'this' (like static methods in Java).

    The MatrixC companion object provides operations for MatrixC that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from files or vectors.

  10. object MatrixCTest extends App with PackageInfo

    The MatrixCTest object tests the operations provided by MatrixC class.

    The MatrixCTest object tests the operations provided by MatrixC class. > runMain scalation.linalgebra.MatrixCTest

  11. object MatrixD extends Error with Serializable

    The MatrixD companion object provides operations for MatrixD that don't require 'this' (like static methods in Java).

    The MatrixD companion object provides operations for MatrixD that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from files or vectors.

  12. object MatrixDTest extends App with PackageInfo

    The MatrixDTest object tests the operations provided by MatrixD class.

    The MatrixDTest object tests the operations provided by MatrixD class. > runMain scalation.linalgebra.MatrixDTest

  13. object MatrixI extends Error with Serializable

    The MatrixI companion object provides operations for MatrixI that don't require 'this' (like static methods in Java).

    The MatrixI companion object provides operations for MatrixI that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from files or vectors.

  14. object MatrixITest extends App with PackageInfo

    The MatrixITest object tests the operations provided by MatrixI class.

    The MatrixITest object tests the operations provided by MatrixI class. > runMain scalation.linalgebra.MatrixITest

  15. object MatrixL extends Error with Serializable

    The MatrixL companion object provides operations for MatrixL that don't require 'this' (like static methods in Java).

    The MatrixL companion object provides operations for MatrixL that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from files or vectors.

  16. object MatrixLTest extends App with PackageInfo

    The MatrixLTest object tests the operations provided by MatrixL class.

    The MatrixLTest object tests the operations provided by MatrixL class. > runMain scalation.linalgebra.MatrixLTest

  17. object MatrixQ extends Error with Serializable

    The MatrixQ companion object provides operations for MatrixQ that don't require 'this' (like static methods in Java).

    The MatrixQ companion object provides operations for MatrixQ that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from files or vectors.

  18. object MatrixQTest extends App with PackageInfo

    The MatrixQTest object tests the operations provided by MatrixQ class.

    The MatrixQTest object tests the operations provided by MatrixQ class. > runMain scalation.linalgebra.MatrixQTest

  19. object MatrixR extends Error with Serializable

    The MatrixR companion object provides operations for MatrixR that don't require 'this' (like static methods in Java).

    The MatrixR companion object provides operations for MatrixR that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from files or vectors.

  20. object MatrixRTest extends App with PackageInfo

    The MatrixRTest object tests the operations provided by MatrixR class.

    The MatrixRTest object tests the operations provided by MatrixR class. > runMain scalation.linalgebra.MatrixRTest

  21. object StatVecTest extends App

    The StatVecTest object is used to test the StatVec class.

    The StatVecTest object is used to test the StatVec class. > runMain scalation.linalgebra.StatVecTest

  22. object Vec

    The Vec object provides a minimal set of functions that apply across all types of vectors.

    The Vec object provides a minimal set of functions that apply across all types of vectors.

    See also

    scalation.columnar_db.Relation

  23. object VectorC extends Serializable

    The VectorC object is the companion object for the VectorC class.

  24. object VectorCTest extends App

    The VectorCTest object tests the operations provided by VectorC.

    The VectorCTest object tests the operations provided by VectorC. > runMain scalation.linalgebra.mem_mapped.VectorCTest

  25. object VectorD extends Serializable

    The VectorD object is the companion object for the VectorD class.

  26. object VectorDTest extends App

    The VectorDTest object tests the operations provided by VectorD.

    The VectorDTest object tests the operations provided by VectorD. > runMain scalation.linalgebra.mem_mapped.VectorDTest

  27. object VectorI extends Serializable

    The VectorI object is the companion object for the VectorI class.

  28. object VectorITest extends App

    The VectorITest object tests the operations provided by VectorI.

    The VectorITest object tests the operations provided by VectorI. > runMain scalation.linalgebra.mem_mapped.VectorITest

  29. object VectorL extends Serializable

    The VectorL object is the companion object for the VectorL class.

  30. object VectorLTest extends App

    The VectorLTest object tests the operations provided by VectorL.

    The VectorLTest object tests the operations provided by VectorL. > runMain scalation.linalgebra.mem_mapped.VectorLTest

  31. object VectorQ extends Serializable

    The VectorQ object is the companion object for the VectorQ class.

  32. object VectorQTest extends App

    The VectorQTest object tests the operations provided by VectorQ.

    The VectorQTest object tests the operations provided by VectorQ. > runMain scalation.linalgebra.mem_mapped.VectorQTest

  33. object VectorR extends Serializable

    The VectorR object is the companion object for the VectorR class.

  34. object VectorRTest extends App

    The VectorRTest object tests the operations provided by VectorR.

    The VectorRTest object tests the operations provided by VectorR. > runMain scalation.linalgebra.mem_mapped.VectorRTest

  35. object VectorS extends Serializable

    The VectorS object is the companion object for the VectorS class.

  36. object VectorSTest extends App

    The VectorSTest object tests the operations provided by VectorS.

    The VectorSTest object tests the operations provided by VectorS. > runMain scalation.linalgebra.mem_mapped.VectorSTest

Inherited from AnyRef

Inherited from Any

Ungrouped