| Package | Description | 
|---|---|
| org.ojalgo | |
| org.ojalgo.access | |
| org.ojalgo.array | |
| org.ojalgo.function.multiary | |
| org.ojalgo.matrix | |
| org.ojalgo.matrix.decomposition | |
| org.ojalgo.matrix.store | |
| org.ojalgo.matrix.store.operation | 
 
 Contents in this package loosely corresponds to BLAS. 
 | 
| org.ojalgo.matrix.task | |
| org.ojalgo.matrix.task.iterative | |
| org.ojalgo.netio | 
 
 This package loosely corresponds to (extends) the packages: java.io.*, java.nio.*, java.net.* and sun.net.* 
 | 
| org.ojalgo.optimisation | |
| org.ojalgo.optimisation.convex | |
| org.ojalgo.random | |
| org.ojalgo.random.process | |
| org.ojalgo.scalar | 
| Modifier and Type | Method and Description | 
|---|---|
static void | 
ProgrammingError.throwIfMultiplicationNotPossible(Access2D<?> left,
                                Access2D<?> right)  | 
static void | 
ProgrammingError.throwIfMultiplicationNotPossible(Access2D<?> left,
                                Access2D<?> right)  | 
static void | 
ProgrammingError.throwIfNotEqualColumnDimensions(Access2D<?> mtrx1,
                               Access2D<?> mtrx2)  | 
static void | 
ProgrammingError.throwIfNotEqualColumnDimensions(Access2D<?> mtrx1,
                               Access2D<?> mtrx2)  | 
static void | 
ProgrammingError.throwIfNotEqualDimensions(Access2D<?> mtrx1,
                         Access2D<?> mtrx2)  | 
static void | 
ProgrammingError.throwIfNotEqualDimensions(Access2D<?> mtrx1,
                         Access2D<?> mtrx2)  | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
Stream2D<N extends Number,A extends Access2D<N>,R extends Mutate2D.Receiver<N>,P extends Stream2D<N,A,R,P>>  | 
| Modifier and Type | Method and Description | 
|---|---|
static Access2D<Double> | 
Access2D.asPrimitive2D(Access2D<?> access)  | 
static Access2D<Double> | 
Access2D.wrap(double[][] target)  | 
static <N extends Number> | 
Access2D.wrap(N[][] target)  | 
static Access2D<Double> | 
Access2D.wrapAccess2D(double[][] target)
Deprecated. 
 
v45 Use  
wrap(double[][]) instead | 
static <N extends Number> | 
Access2D.wrapAccess2D(N[][] target)
Deprecated. 
 
v45 Use  
#wrap(N[][]) instead | 
| Modifier and Type | Method and Description | 
|---|---|
default void | 
Mutate2D.Receiver.accept(Access2D<?> supplied)  | 
static Access2D<Double> | 
Access2D.asPrimitive2D(Access2D<?> access)  | 
I | 
Factory2D.copy(Access2D<?> source)  | 
static boolean | 
Access2D.equals(Access2D<?> accessA,
      Access2D<?> accessB,
      NumberContext context)  | 
static boolean | 
Access2D.equals(Access2D<?> accessA,
      Access2D<?> accessB,
      NumberContext context)  | 
static <S extends Number> | 
RowView.makeIterable(Access2D<S> access)  | 
static <S extends Number> | 
ColumnView.makeIterable(Access2D<S> access)  | 
static String | 
Access2D.toString(Access2D<?> matrix)  | 
| Constructor and Description | 
|---|
ColumnView(Access2D<N> access)  | 
RowView(Access2D<N> access)  | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
Array2D<N extends Number>
Array2D 
 | 
| Modifier and Type | Method and Description | 
|---|---|
Array2D<N> | 
Array2D.Factory.copy(Access2D<?> source)  | 
| Modifier and Type | Method and Description | 
|---|---|
static QuadraticFunction<BigDecimal> | 
QuadraticFunction.makeBig(Access2D<? extends Number> factors)  | 
static CompoundFunction<BigDecimal> | 
CompoundFunction.makeBig(Access2D<? extends Number> quadraticFactors,
       Access1D<? extends Number> linearFactors)  | 
static QuadraticFunction<ComplexNumber> | 
QuadraticFunction.makeComplex(Access2D<? extends Number> factors)  | 
static CompoundFunction<ComplexNumber> | 
CompoundFunction.makeComplex(Access2D<? extends Number> quadraticFactors,
           Access1D<? extends Number> linearFactors)  | 
static QuadraticFunction<Double> | 
QuadraticFunction.makePrimitive(Access2D<? extends Number> factors)  | 
static CompoundFunction<Double> | 
CompoundFunction.makePrimitive(Access2D<? extends Number> quadraticFactors,
             Access1D<? extends Number> linearFactors)  | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
BasicMatrix
 This interface declares a set of high level methods for linear algebra. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
BigMatrix
Deprecated. 
 
v45 Use  
RationalMatrix instead. | 
class  | 
ComplexMatrix
ComplexMatrix 
 | 
class  | 
PrimitiveMatrix
PrimitiveMatrix 
 | 
class  | 
QuaternionMatrix
QuaternionMatrix 
 | 
class  | 
RationalMatrix
RationalMatrix 
 | 
| Modifier and Type | Method and Description | 
|---|---|
static Access2D<BigDecimal> | 
MatrixUtils.wrapBigAccess2D(BasicMatrix matrix)  | 
static Access2D<ComplexNumber> | 
MatrixUtils.wrapComplexAccess2D(BasicMatrix matrix)  | 
static Access2D<Double> | 
MatrixUtils.wrapPrimitiveAccess2D(BasicMatrix matrix)  | 
| Modifier and Type | Method and Description | 
|---|---|
BasicMatrix | 
BasicMatrix.add(int row,
   int col,
   Access2D<?> addend)  | 
static void | 
MatrixUtils.copy(Access2D<?> source,
    int rows,
    int columns,
    double[][] destination)  | 
static void | 
MatrixUtils.copyComplexArgument(Access2D<ComplexNumber> source,
                   ElementsConsumer<?> destination)
Copies the argument of the ComplexNumber elements to the destination. 
 | 
static void | 
MatrixUtils.copyComplexImaginary(Access2D<ComplexNumber> source,
                    ElementsConsumer<?> destination)
Copies the imaginary part of the ComplexNumber elements to the destination. 
 | 
static void | 
MatrixUtils.copyComplexModulus(Access2D<ComplexNumber> source,
                  ElementsConsumer<?> destination)
Copies the modulus of the ComplexNumber elements to the destination. 
 | 
static void | 
MatrixUtils.copyComplexModulusAndArgument(Access2D<ComplexNumber> source,
                             ElementsConsumer<?> modDest,
                             ElementsConsumer<?> argDest)
Simultaneously copies the modulus and argument of the ComplexNumber elements to the destinations. 
 | 
static void | 
MatrixUtils.copyComplexReal(Access2D<ComplexNumber> source,
               ElementsConsumer<?> destination)
Copies the real part of the ComplexNumber elements to the destination. 
 | 
static void | 
MatrixUtils.copyComplexRealAndImaginary(Access2D<ComplexNumber> source,
                           ElementsConsumer<?> realDest,
                           ElementsConsumer<?> imagDest)
Simultaneously copies the real and imaginary parts of the ComplexNumber elements to the destinations. 
 | 
BasicMatrix | 
BasicMatrix.divideElements(Access2D<?> aMtrx)
Divides the elements of this with the elements of aMtrx. 
 | 
boolean | 
BasicMatrix.equals(Access2D<?> aMtrx,
      NumberContext aCntxt)  | 
static PrimitiveDenseStore | 
MatrixUtils.getComplexArgument(Access2D<ComplexNumber> arg)
Extracts the argument of the ComplexNumber elements to a new primitive double valued matrix. 
 | 
static PrimitiveDenseStore | 
MatrixUtils.getComplexImaginary(Access2D<ComplexNumber> arg)
Extracts the imaginary part of the ComplexNumber elements to a new primitive double valued matrix. 
 | 
static PrimitiveDenseStore | 
MatrixUtils.getComplexModulus(Access2D<ComplexNumber> arg)
Extracts the modulus of the ComplexNumber elements to a new primitive double valued matrix. 
 | 
static PrimitiveDenseStore | 
MatrixUtils.getComplexReal(Access2D<ComplexNumber> arg)
Extracts the real part of the ComplexNumber elements to a new primitive double valued matrix. 
 | 
static boolean | 
MatrixUtils.isHermitian(Access2D<?> matrix)  | 
BasicMatrix | 
BasicMatrix.mergeColumns(Access2D<?> belowRows)
[belowRows] is appended below [this]. 
 | 
BasicMatrix | 
BasicMatrix.mergeRows(Access2D<?> rightColumns)
[rightColumns] is appended to the right of [this]. 
 | 
BasicMatrix | 
BasicMatrix.multiplyElements(Access2D<?> aMtrx)
Multiplies the elements of this matrix with the elements of aMtrx. 
 | 
BasicMatrix | 
BasicMatrix.solve(Access2D<?> aRHS)
 This method solves a system of linear equations: [this][X]=[aRHS]. 
 | 
static String | 
MatrixUtils.toString(Access2D<?> matrix)
Deprecated. 
 
v45 Use  
toString(Access2D<?>) instead | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
DecompositionStore<N extends Number>
 Only classes that will act as a delegate to a MatrixDecomposition implementation from this
 package should implement this interface. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
MatrixStore<N> | 
HermitianEvD.invert(Access2D<?> original)  | 
MatrixStore<N> | 
HermitianEvD.invert(Access2D<?> original,
      PhysicalStore<N> preallocated)  | 
static <N extends Number> | 
SingularValue.make(Access2D<N> typical)  | 
static <N extends Number> | 
Schur.make(Access2D<N> typical)
Deprecated.  
  | 
static <N extends Number> | 
LU.make(Access2D<N> typical)  | 
static <N extends Number> | 
Hessenberg.make(Access2D<N> typical)  | 
static <N extends Number> | 
Cholesky.make(Access2D<N> typical)  | 
static <N extends Number> | 
QR.make(Access2D<N> typical)  | 
static <N extends Number> | 
Bidiagonal.make(Access2D<N> typical)  | 
static <N extends Number> | 
Eigenvalue.make(Access2D<N> typical)  | 
static <N extends Number> | 
LDL.make(Access2D<N> typical)  | 
static <N extends Number> | 
Tridiagonal.make(Access2D<N> typical)  | 
static <N extends Number> | 
Eigenvalue.make(Access2D<N> typical,
    boolean hermitian)  | 
MatrixStore<N> | 
HermitianEvD.solve(Access2D<?> body,
     Access2D<?> rhs)  | 
MatrixStore<N> | 
HermitianEvD.solve(Access2D<?> body,
     Access2D<?> rhs)  | 
MatrixStore<N> | 
HermitianEvD.solve(Access2D<?> body,
     Access2D<?> rhs,
     PhysicalStore<N> preallocated)  | 
MatrixStore<N> | 
HermitianEvD.solve(Access2D<?> body,
     Access2D<?> rhs,
     PhysicalStore<N> preallocated)  | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
MatrixStore<N extends Number>
 A MatrixStore is a two dimensional store of numbers/scalars. 
 | 
interface  | 
PhysicalStore<N extends Number>
 PhysicalStore:s, as opposed to MatrixStore:s, are mutable. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
BigDenseStore
Deprecated. 
 
v45 Use  
GenericDenseStore instead | 
class  | 
ColumnsSupplier<N extends Number>  | 
class  | 
ComplexDenseStore
Deprecated. 
 
v45 Use  
GenericDenseStore instead | 
class  | 
GenericDenseStore<N extends Number & Scalar<N>>
A N implementation of PhysicalStore. 
 | 
class  | 
PrimitiveDenseStore
A Double (actually double) implementation of PhysicalStore. 
 | 
class  | 
RawStore
Uses double[][] internally. 
 | 
class  | 
RowsSupplier<N extends Number>  | 
class  | 
SparseStore<N extends Number>  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
BigDenseStore.accept(Access2D<?> supplied)
Deprecated.  
  | 
void | 
RawStore.accept(Access2D<?> supplied)  | 
void | 
GenericDenseStore.accept(Access2D<?> supplied)  | 
void | 
PrimitiveDenseStore.accept(Access2D<?> supplied)  | 
void | 
ComplexDenseStore.accept(Access2D<?> supplied)
Deprecated.  
  | 
I | 
PhysicalStore.Factory.conjugate(Access2D<?> source)  | 
MatrixStore.LogicalBuilder<N> | 
MatrixStore.Factory.makeWrapper(Access2D<?> access)  | 
void | 
BigDenseStore.substituteBackwards(Access2D<BigDecimal> body,
                   boolean unitDiagonal,
                   boolean conjugated,
                   boolean hermitian)
Deprecated.  
  | 
void | 
ComplexDenseStore.substituteBackwards(Access2D<ComplexNumber> body,
                   boolean unitDiagonal,
                   boolean conjugated,
                   boolean hermitian)
Deprecated.  
  | 
void | 
RawStore.substituteBackwards(Access2D<Double> body,
                   boolean unitDiagonal,
                   boolean conjugated,
                   boolean hermitian)  | 
void | 
PrimitiveDenseStore.substituteBackwards(Access2D<Double> body,
                   boolean unitDiagonal,
                   boolean conjugated,
                   boolean hermitian)  | 
void | 
GenericDenseStore.substituteBackwards(Access2D<N> body,
                   boolean unitDiagonal,
                   boolean conjugated,
                   boolean hermitian)  | 
void | 
PhysicalStore.substituteBackwards(Access2D<N> body,
                   boolean unitDiagonal,
                   boolean conjugated,
                   boolean hermitian)
Will solve the equation system [A][X]=[B] where:
 
 [body][this]=[this] is [A][X]=[B] ("this" is the right hand side, and it will be overwritten with
 the solution).
 [A] is upper/right triangular
  
 | 
void | 
BigDenseStore.substituteForwards(Access2D<BigDecimal> body,
                  boolean unitDiagonal,
                  boolean conjugated,
                  boolean identity)
Deprecated.  
  | 
void | 
ComplexDenseStore.substituteForwards(Access2D<ComplexNumber> body,
                  boolean unitDiagonal,
                  boolean conjugated,
                  boolean identity)
Deprecated.  
  | 
void | 
RawStore.substituteForwards(Access2D<Double> body,
                  boolean unitDiagonal,
                  boolean conjugated,
                  boolean identity)  | 
void | 
PrimitiveDenseStore.substituteForwards(Access2D<Double> body,
                  boolean unitDiagonal,
                  boolean conjugated,
                  boolean identity)  | 
void | 
GenericDenseStore.substituteForwards(Access2D<N> body,
                  boolean unitDiagonal,
                  boolean conjugated,
                  boolean identity)  | 
void | 
PhysicalStore.substituteForwards(Access2D<N> body,
                  boolean unitDiagonal,
                  boolean conjugated,
                  boolean identity)
Will solve the equation system [A][X]=[B] where:
 
 [body][this]=[this] is [A][X]=[B] ("this" is the right hand side, and it will be overwritten with
 the solution).
 [A] is lower/left triangular
  
 | 
I | 
PhysicalStore.Factory.transpose(Access2D<?> source)  | 
| Constructor and Description | 
|---|
RawStore(Access2D<?> template)  | 
| Modifier and Type | Method and Description | 
|---|---|
static void | 
FillMatchingSingle.conjugate(BigDecimal[] data,
         int structure,
         int firstColumn,
         int limitColumn,
         Access2D<?> source)  | 
static void | 
FillMatchingSingle.conjugate(double[] data,
         int structure,
         int firstColumn,
         int limitColumn,
         Access2D<?> source)  | 
static <N extends Number & Scalar<N>> | 
FillMatchingSingle.conjugate(N[] data,
         int structure,
         int firstColumn,
         int limitColumn,
         Access2D<?> source,
         Scalar.Factory<N> scalar)  | 
static void | 
FillMatchingSingle.copy(BigDecimal[] data,
    int structure,
    int firstColumn,
    int limitColumn,
    Access2D<? extends Number> source)  | 
static void | 
FillMatchingSingle.copy(double[] data,
    int structure,
    int firstColumn,
    int limitColumn,
    Access2D<? extends Number> source)  | 
static <N extends Number & Scalar<N>> | 
FillMatchingSingle.copy(N[] data,
    int structure,
    int firstColumn,
    int limitColumn,
    Access2D<?> source,
    Scalar.Factory<N> scalar)  | 
static void | 
SubstituteBackwards.invoke(BigDecimal[] data,
      int structure,
      int first,
      int limit,
      Access2D<BigDecimal> body,
      boolean unitDiagonal,
      boolean conjugated,
      boolean hermitian)  | 
static void | 
SubstituteForwards.invoke(BigDecimal[] data,
      int structure,
      int first,
      int limit,
      Access2D<BigDecimal> body,
      boolean unitDiagonal,
      boolean conjugated,
      boolean identity)  | 
static void | 
SubstituteBackwards.invoke(double[] data,
      int structure,
      int first,
      int limit,
      Access2D<Double> body,
      boolean unitDiagonal,
      boolean conjugated,
      boolean hermitian)  | 
static void | 
SubstituteForwards.invoke(double[] data,
      int structure,
      int first,
      int limit,
      Access2D<Double> body,
      boolean unitDiagonal,
      boolean conjugated,
      boolean identity)  | 
static <N extends Number & Scalar<N>> | 
SubstituteBackwards.invoke(N[] data,
      int structure,
      int first,
      int limit,
      Access2D<N> body,
      boolean unitDiagonal,
      boolean conjugated,
      boolean hermitian,
      Scalar.Factory<N> scalar)  | 
static <N extends Number & Scalar<N>> | 
SubstituteForwards.invoke(N[] data,
      int structure,
      int first,
      int limit,
      Access2D<N> body,
      boolean unitDiagonal,
      boolean conjugated,
      boolean identity,
      Scalar.Factory<N> scalar)  | 
static void | 
FillMatchingSingle.transpose(BigDecimal[] data,
         int structure,
         int firstColumn,
         int limitColumn,
         Access2D<?> source)  | 
static void | 
FillMatchingSingle.transpose(double[] data,
         int structure,
         int firstColumn,
         int limitColumn,
         Access2D<?> source)  | 
static <N extends Number & Scalar<N>> | 
FillMatchingSingle.transpose(N[] data,
         int structure,
         int firstColumn,
         int limitColumn,
         Access2D<?> source,
         Scalar.Factory<N> scalar)  | 
| Modifier and Type | Method and Description | 
|---|---|
N | 
DeterminantTask.calculateDeterminant(Access2D<?> matrix)  | 
MatrixStore<Double> | 
AbstractInverter.invert(Access2D<?> original)  | 
default MatrixStore<N> | 
InverterTask.invert(Access2D<?> original)
The output must be a "right inverse" and a "generalised inverse". 
 | 
MatrixStore<N> | 
InverterTask.invert(Access2D<?> original,
      PhysicalStore<N> preallocated)
 Exactly how (if at all) a specific implementation makes use of  
preallocated is not
 specified by this interface. | 
default MatrixStore<N> | 
SolverTask.solve(Access2D<?> body,
     Access2D<?> rhs)
[A][X]=[B] or [body][return]=[rhs] 
 | 
default MatrixStore<N> | 
SolverTask.solve(Access2D<?> body,
     Access2D<?> rhs)
[A][X]=[B] or [body][return]=[rhs] 
 | 
MatrixStore<N> | 
SolverTask.solve(Access2D<?> body,
     Access2D<?> rhs,
     PhysicalStore<N> preallocated)
 Exactly how (if at all) a specific implementation makes use of  
preallocated is not
 specified by this interface. | 
MatrixStore<N> | 
SolverTask.solve(Access2D<?> body,
     Access2D<?> rhs,
     PhysicalStore<N> preallocated)
 Exactly how (if at all) a specific implementation makes use of  
preallocated is not
 specified by this interface. | 
| Modifier and Type | Method and Description | 
|---|---|
MatrixStore<Double> | 
JacobiSolver.solve(Access2D<?> body,
     Access2D<?> rhs,
     PhysicalStore<Double> current)  | 
MatrixStore<Double> | 
JacobiSolver.solve(Access2D<?> body,
     Access2D<?> rhs,
     PhysicalStore<Double> current)  | 
MatrixStore<Double> | 
GaussSeidelSolver.solve(Access2D<?> body,
     Access2D<?> rhs,
     PhysicalStore<Double> current)  | 
MatrixStore<Double> | 
GaussSeidelSolver.solve(Access2D<?> body,
     Access2D<?> rhs,
     PhysicalStore<Double> current)  | 
MatrixStore<Double> | 
MutableSolver.solve(Access2D<?> body,
     Access2D<?> rhs,
     PhysicalStore<Double> current)  | 
MatrixStore<Double> | 
MutableSolver.solve(Access2D<?> body,
     Access2D<?> rhs,
     PhysicalStore<Double> current)  | 
MatrixStore<Double> | 
ConjugateGradientSolver.solve(Access2D<?> body,
     Access2D<?> rhs,
     PhysicalStore<Double> preallocated)  | 
MatrixStore<Double> | 
ConjugateGradientSolver.solve(Access2D<?> body,
     Access2D<?> rhs,
     PhysicalStore<Double> preallocated)  | 
| Modifier and Type | Method and Description | 
|---|---|
static void | 
BasicLogger.debug(String message,
     Access2D<?> matrix)  | 
static void | 
BasicLogger.debug(String message,
     Access2D<?> matrix,
     NumberContext context)  | 
static void | 
BasicLogger.error(String message,
     Access2D<?> matrix)  | 
static void | 
BasicLogger.error(String message,
     Access2D<?> matrix,
     NumberContext context)  | 
default void | 
BasicLogger.Printer.printmtrx(String message,
         Access2D<?> matrix)  | 
void | 
BasicLogger.PrintStreamPrinter.printmtrx(String message,
         Access2D<?> matrix)  | 
void | 
BasicLogger.PrintWriterPrinter.printmtrx(String message,
         Access2D<?> matrix)  | 
default void | 
BasicLogger.Printer.printmtrx(String message,
         Access2D<?> matrix,
         NumberContext context)  | 
void | 
BasicLogger.PrintStreamPrinter.printmtrx(String message,
         Access2D<?> matrix,
         NumberContext context)  | 
void | 
BasicLogger.PrintWriterPrinter.printmtrx(String message,
         Access2D<?> matrix,
         NumberContext context)  | 
| Modifier and Type | Method and Description | 
|---|---|
protected void | 
GenericSolver.log(String descripttion,
   Access2D<?> matrix)  | 
void | 
Expression.setQuadraticFactors(List<Variable> variables,
                   Access2D<?> factors)  | 
| Modifier and Type | Method and Description | 
|---|---|
ConvexSolver.Builder | 
ConvexSolver.Builder.inequalities(Access2D<Double> mtrxAI,
            MatrixStore<Double> mtrxBI)  | 
| Constructor and Description | 
|---|
Normal1D(Access1D<?> locations,
        Access2D<?> covariances)  | 
Random1D(Access2D<?> correlations)  | 
| Constructor and Description | 
|---|
GeometricBrownian1D(Access2D<?> correlations,
                   List<? extends GeometricBrownianMotion> processes)  | 
Wiener1D(Access2D<?> correlations,
        List<? extends WienerProcess> processes)  | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
ComplexNumber
ComplexNumber is an immutable complex number class. 
 | 
static class  | 
ComplexNumber.Normalised  | 
class  | 
Quaternion  | 
static class  | 
Quaternion.Versor  | 
Copyright © 2018 Optimatika. All rights reserved.