All Classes Interface Summary Class Summary Enum Summary Exception Summary
| Class |
Description |
| AboveBelowStore<N extends java.lang.Comparable<N>> |
A merger of two MatrixStore instances by placing one store below the other. |
| AbstractContinuous |
|
| AbstractDecomposition<N extends java.lang.Comparable<N>> |
|
| AbstractDeterminator |
|
| AbstractDiscrete |
|
| AbstractDistribution1D |
|
| AbstractInverter |
|
| AbstractPolynomial<N extends java.lang.Comparable<N>,P extends AbstractPolynomial<N,P>> |
|
| AbstractProcess<D extends Distribution> |
|
| AbstractScedasticity |
|
| AbstractSolver |
|
| AbstractStore<N extends java.lang.Comparable<N>> |
|
| Access1D<N extends java.lang.Comparable<N>> |
1-dimensional accessor (get) methods.
|
| Access1D.Aggregatable<N extends java.lang.Comparable<N>> |
|
| Access1D.Collectable<N extends java.lang.Comparable<N>,R extends Mutate1D> |
|
| Access1D.ElementView<N extends java.lang.Comparable<N>> |
|
| Access1D.SelectionView<N extends java.lang.Comparable<N>> |
|
| Access1D.Sliceable<N extends java.lang.Comparable<N>> |
|
| Access1D.Visitable<N extends java.lang.Comparable<N>> |
|
| Access2D<N extends java.lang.Comparable<N>> |
2-dimensional accessor methods
|
| Access2D.Aggregatable<N extends java.lang.Comparable<N>> |
|
| Access2D.Collectable<N extends java.lang.Comparable<N>,R extends Mutate2D> |
|
| Access2D.ColumnView<N extends java.lang.Comparable<N>> |
|
| Access2D.ElementView<N extends java.lang.Comparable<N>> |
|
| Access2D.RowView<N extends java.lang.Comparable<N>> |
|
| Access2D.SelectionView<N extends java.lang.Comparable<N>> |
|
| Access2D.Sliceable<N extends java.lang.Comparable<N>> |
|
| Access2D.Visitable<N extends java.lang.Comparable<N>> |
|
| AccessAnyD<N extends java.lang.Comparable<N>> |
N-dimensional accessor methods
|
| AccessAnyD.Aggregatable<N extends java.lang.Comparable<N>> |
|
| AccessAnyD.Collectable<N extends java.lang.Comparable<N>,R extends MutateAnyD> |
|
| AccessAnyD.ElementView<N extends java.lang.Comparable<N>> |
|
| AccessAnyD.MatrixView<N extends java.lang.Comparable<N>> |
|
| AccessAnyD.SelectionView<N extends java.lang.Comparable<N>> |
|
| AccessAnyD.Sliceable<N extends java.lang.Comparable<N>> |
|
| AccessAnyD.VectorView<N extends java.lang.Comparable<N>> |
|
| AccessAnyD.Visitable<N extends java.lang.Comparable<N>> |
|
| AccessScalar<N> |
|
| AccessSeries |
|
| ActiveSetSolver |
|
| AffineFunction<N extends java.lang.Comparable<N>> |
[l]T[x] + c
|
| AffineFunction.Factory<N extends java.lang.Comparable<N>> |
|
| AggregateAll |
|
| Aggregator |
|
| AggregatorFunction<N extends java.lang.Comparable<N>> |
|
| AggregatorFunction.PredicateWrapper<N extends java.lang.Comparable<N>> |
|
| AggregatorSet<N extends java.lang.Comparable<N>> |
|
| AlphaVantageFetcher |
Deprecated. |
| AlphaVantageParser |
https://www.alphavantage.co/documentation/
|
| AlphaVantageParser.Data |
|
| Alternator<T> |
Alternator
|
| AMAX |
Given a vector x, the i?amax functions return the position of the vector element x[i] that has the largest
absolute value for real flavors, or the largest sum |Re(x[i])|+|Im(x[i])| for complex flavors.
|
| AMIN |
Given a vector x, the i?amin functions return the position of the vector element x[i] that has the smallest
absolute value for real flavors, or the smallest sum |Re(x[i])|+|Im(x[i])| for complex flavors.
|
| Amount |
(currency) amount as in "amount = price * quatity"
|
| AnyTensor<N extends java.lang.Comparable<N>> |
|
| AnyTensor.Factory<N extends java.lang.Comparable<N>> |
|
| ApplyCholesky |
|
| ApplyLDL |
|
| ApplyLU |
|
| ApproximateFunction<N extends java.lang.Comparable<N>> |
|
| ARCH |
|
| Array1D<N extends java.lang.Comparable<N>> |
Array1D
|
| Array1D.Factory<N extends java.lang.Comparable<N>> |
|
| Array1D.QuickAscendingSorter |
|
| Array1D.QuickDescendingSorter |
|
| Array2D<N extends java.lang.Comparable<N>> |
Array2D
|
| Array2D.Factory<N extends java.lang.Comparable<N>> |
|
| ArrayAnyD<N extends java.lang.Comparable<N>> |
ArrayAnyD
|
| ArrayAnyD.Factory<N extends java.lang.Comparable<N>> |
|
| ArrayBasedTensor<N extends java.lang.Comparable<N>,T extends ArrayBasedTensor<N,T>> |
|
| ArrayBasedTensor.Factory<N extends java.lang.Comparable<N>> |
|
| ArrayC128 |
|
| ArrayFactory<N extends java.lang.Comparable<N>,I extends BasicArray<N>> |
|
| ArrayH256 |
A one- and/or arbitrary-dimensional array of Quaternion. |
| ArrayOperation |
|
| ArrayQ128 |
|
| ArrayR032 |
A one- and/or arbitrary-dimensional array of double.
|
| ArrayR064 |
A one- and/or arbitrary-dimensional array of double.
|
| ArrayR128 |
A one- and/or arbitrary-dimensional array of Quadruple. |
| ArrayR256 |
A one- and/or arbitrary-dimensional array of BigDecimal.
|
| ArrayZ008 |
A one- and/or arbitrary-dimensional array of double.
|
| ArrayZ016 |
A one- and/or arbitrary-dimensional array of double.
|
| ArrayZ032 |
A one- and/or arbitrary-dimensional array of double.
|
| ArrayZ064 |
A one- and/or arbitrary-dimensional array of double.
|
| ArtificialNeuralNetwork |
|
| ArtificialNeuralNetwork.Activator |
https://en.wikipedia.org/wiki/Activation_function
|
| ArtificialNeuralNetwork.Error |
|
| ASCII |
ASCII codes
0
1
2
3
4
5
6
7
0
NUL
SOH
STX
ETX
EOT
ENQ
ACK
BEL
8
BS
HT
LF
VT
FF
CR
SO
SI
16
DLE
DC1
DC2
DC3
DC4
NAK
SYN
ETB
24
CAN
EM
SUB
ESC
FS
GS
RS
US
32
SP
!
"
#
$
%
&
'
40
(
)
*
+
,
-
.
/
48
0
1
2
3
4
5
6
7
56
8
9
:
;
<
=
>
?
64
@
A
B
C
D
E
F
G
72
H
I
J
K
L
M
N
O
80
P
Q
R
S
T
U
V
W
88
X
Y
Z
[
\
]
^
_
96
`
a
b
c
d
e
f
g
104
h
i
j
k
l
m
n
o
112
p
q
r
s
t
u
v
w
120
x
y
z
{
|
~
DEL
http://www.lammertbies.nl/comm/info/ascii-characters.html
|
| ASUM |
The ?asum routine computes the sum of the magnitudes of elements of a real vector, or the sum of magnitudes
of the real and imaginary parts of elements of a complex vector: res = |Re x1| + |Im x1| + |Re x2| + |Im
x2|+ ...
|
| AutoConsumer<T> |
Utilities for AutoCloseable Consumer:s
|
| AutoFunctional |
|
| AutoSupplier<T> |
Utilities for AutoCloseable Supplier:s
|
| AXPY |
The ?axpy routines perform a vector-vector operation defined as y := a*x + y where: a is a scalar x and y
are vectors each with a number of elements that equals n.
|
| BasePrimitiveSolver |
|
| BasicArray<N extends java.lang.Comparable<N>> |
A BasicArray is 1-dimensional, but designed to easily be extended or encapsulated, and then treated as
arbitrary-dimensional.
|
| BasicArray.Factory<N extends java.lang.Comparable<N>> |
|
| BasicFunction |
|
| BasicFunction.Differentiable<N extends java.lang.Comparable<N>,F extends BasicFunction> |
|
| BasicFunction.Integratable<N extends java.lang.Comparable<N>,F extends BasicFunction> |
|
| BasicFunction.PlainUnary<T,R> |
For when you want to emphasise that something is a (mathematical) function.
|
| BasicLogger |
BasicLogger is not meant to replace any other logging library.
|
| BasicLogger.BasicWriter |
|
| BasicLogger.Buffer |
Temporarily store data/text.
|
| BasicLogger.NotNull |
|
| BasicLogger.Printable |
|
| BasicLogger.PrivateDetails |
|
| BasicMachine |
How much memory, and how many threads share that memory.
|
| BasicMatrix<N extends java.lang.Comparable<N>,M extends BasicMatrix<N,M>> |
A base class for, easy to use, immutable (thread safe) matrices with a rich feature set.
|
| BasicParser<T> |
A (CSV) parser interface.
|
| BasicSeries<K extends java.lang.Comparable<? super K>,V extends java.lang.Comparable<V>> |
A BasicSeries is a SortedMap with:
Keys restricted to Comparable (the keys have a natural order)
Values restricted to Comparable (the values are "numeric" as in extending Number
or implementing NumberDefinition. |
| BasicSeries.NaturallySequenced<K extends java.lang.Comparable<? super K>,V extends java.lang.Comparable<V>> |
A series with naturally sequenced keys - given any key there is a natural "next" key, e.g.
|
| BasicSeries.TimeSeriesBuilder<K extends java.lang.Comparable<? super K>> |
|
| BatchManager |
When you're going to instantiate multiple BatchNode:s and you want them to share some properties,
this is a convenient alternative. |
| BatchNode<T> |
A batch processing data node for when there's no way to fit the data in memory.
|
| BatchNode.Builder<T> |
|
| BatchNode.TwoStepWrapper<T> |
|
| BetaFunction |
|
| BetaFunction.Incomplete |
|
| BetaFunction.Regularized |
|
| Bidiagonal<N extends java.lang.Comparable<N>> |
A general matrix [A] can be factorized by similarity transformations into the form [A]=[LQ][D][RQ]
-1 where:
[A] (m-by-n) is any, real or complex, matrix
[D] (r-by-r) or (m-by-n) is, upper or lower, bidiagonal
[LQ] (m-by-r) or (m-by-m) is orthogonal
[RQ] (n-by-r) or (n-by-n) is orthogonal
r = min(m,n)
|
| Bidiagonal.Factory<N extends java.lang.Comparable<N>> |
|
| BidiagonalDecomposition<N extends java.lang.Comparable<N>> |
|
| BidiagonalDecomposition.C128 |
|
| BidiagonalDecomposition.H256 |
|
| BidiagonalDecomposition.Q128 |
|
| BidiagonalDecomposition.R064 |
|
| BidiagonalDecomposition.R128 |
|
| BigAggregator |
|
| BigAggregator.BigAggregatorFunction |
|
| BigFunction |
Only the reference type parameter (BigDecimal) methods are actually implemented.
|
| BigFunction.Binary |
|
| BigFunction.Consumer |
|
| BigFunction.Nullary |
|
| BigFunction.Parameter |
|
| BigFunction.Predicate |
|
| BigFunction.Unary |
|
| BigMath |
|
| BigMath.Prefix |
|
| BigScalar |
A BigDecimal based implementation of the Scalar interface. |
| BinaryContext |
|
| BinaryFormat |
|
| BinaryFunction<N extends java.lang.Comparable<N>> |
|
| BinaryFunction.FixedFirst<N extends java.lang.Comparable<N>> |
|
| BinaryFunction.FixedSecond<N extends java.lang.Comparable<N>> |
|
| BinaryFunctionSeries |
|
| Binomial |
The frequency in count indepedent trials, each with probability probability, has a binomial distribution.
|
| BlackLittermanContext |
|
| BlackLittermanModel |
|
| BlackLittermanModel.View |
View/Forecast/Opinion
|
| BooleanContext |
|
| BooleanFormat |
BooleanFormat doesn't do anything useful, but it was needed for BooleanContext (that doesn't
do much either). |
| BufferArray |
The odd member among the array implementations.
|
| BufferArray.BufferConstructor |
|
| BufferArray.Factory |
|
| BufferArray.MappedFileFactory |
|
| BufferR032 |
|
| BufferR064 |
|
| BufferZ008 |
|
| BufferZ016 |
|
| BufferZ032 |
|
| BufferZ064 |
|
| BusinessObject |
Each/every business object interface should extends this BusinessObject interface (and
preferably nothing else). |
| ByteBufferBackedInputStream |
|
| ByteBufferBackedOutputStream |
|
| CABS1 |
The ?cabs1 is an auxiliary routine for a few BLAS Level 1 routines.
|
| CalculationLayer |
|
| CalendarDate |
Originally, long before Java 8 and its new Date and Time API, this class was designed to provide an
immutable complement to the existing Date and Calendar classes and to have
easy/direct access to the underlying epoch millisecond value.
|
| CalendarDate.Resolution |
Extends TemporalAdjuster but also loosely corresponds to a TemporalUnit and/or
TemporalAmount.
|
| CalendarDateDuration |
|
| CalendarDateSeries<N extends java.lang.Comparable<N>> |
|
| CalendarDateUnit |
|
| Cauchy |
https://en.wikipedia.org/wiki/Cauchy_distribution
|
| CharacteristicLine |
|
| CharacterRing |
A circular char buffer - an Appendable CharSequence that always hold exactly
65536 characters.
|
| CharacterRing.RingLogger |
|
| CharArraySegment |
|
| CharArraySegment.RootSegment |
|
| CharArraySegment.Subsegment |
|
| ChiSquareDistribution |
|
| ChiSquareDistribution.Degree2 |
|
| ChiSquareDistribution.NormalApproximation |
|
| Cholesky<N extends java.lang.Comparable<N>> |
Cholesky: [A] = [L][L]H (or [R]H[R])
|
| Cholesky.Factory<N extends java.lang.Comparable<N>> |
|
| CholeskyDecomposition<N extends java.lang.Comparable<N>> |
|
| CholeskyDecomposition.C128 |
|
| CholeskyDecomposition.H256 |
|
| CholeskyDecomposition.Q128 |
|
| CholeskyDecomposition.R064 |
|
| CholeskyDecomposition.R128 |
|
| CloseableList<T extends java.lang.AutoCloseable> |
|
| CloseableMap<K,V extends java.lang.AutoCloseable> |
|
| ColourData |
|
| ColumnsStore<N extends java.lang.Comparable<N>> |
A selection (re-ordering) of columns.
|
| ColumnsSupplier<N extends java.lang.Comparable<N>> |
Sparse columns – columns can be added and removed.
|
| ColumnsSupplier.SingleView<N extends java.lang.Comparable<N>> |
|
| CombinatorialFunctions |
https://reference.wolfram.com/language/tutorial/CombinatorialFunctions.html
|
| CommonMachine |
|
| ComparableNumber<N extends ComparableNumber<N>> |
|
| ComplexAggregator |
|
| ComplexAggregator.ComplexAggregatorFunction |
|
| ComplexFunction |
|
| ComplexFunction.Binary |
|
| ComplexFunction.Consumer |
|
| ComplexFunction.Nullary |
|
| ComplexFunction.Parameter |
|
| ComplexFunction.Predicate |
|
| ComplexFunction.Unary |
|
| ComplexMath |
|
| ComplexNumber |
ComplexNumber is an immutable complex number class.
|
| ComposingStore<N extends java.lang.Comparable<N>> |
|
| ConfiguredIntegration<S extends Optimisation.Solver> |
|
| ConjugatedStore<N extends java.lang.Comparable<N>> |
ConjugatedStore
|
| ConjugateGradientSolver |
For solving [A][x]=[b] when [A] is symmetric and positive-definite.
|
| ConstantFunction<N extends java.lang.Comparable<N>> |
Constant valued function - always returns the same value.
|
| ConstantFunction.Factory<N extends java.lang.Comparable<N>> |
|
| ConstrainedSolver |
|
| ConstraintsMetaData |
|
| ContinuousDistribution |
|
| ConvexData<N extends java.lang.Comparable<N>> |
|
| ConvexData.ConvexDataFactory<N extends java.lang.Comparable<N>> |
|
| ConvexObjectiveFunction<N extends java.lang.Comparable<N>> |
1/2 [x]T[Q][x] - [l]T[x]
|
| ConvexSolver |
ConvexSolver solves optimisation problems of the form:
|
| ConvexSolver.Builder |
|
| ConvexSolver.Configuration |
|
| ConvexSolver.ModelIntegration |
|
| CoordinatedSet<K extends java.lang.Comparable<? super K>> |
|
| CoordinatedSet.Builder<K extends java.lang.Comparable<? super K>> |
|
| CoordinationSet<N extends java.lang.Comparable<N>> |
|
| COPY |
The ?copy routines perform a vector-vector operation defined as y = x, where x and y are vectors.
|
| CorePrimitiveOperation |
|
| DaemonPoolExecutor |
|
| DataBatch |
A reusable data batch.
|
| DataFetcher |
|
| DataInterpreter<T> |
|
| DataProcessors |
Various data processors that could be useful when doing data science or similar.
|
| DataReader<T> |
|
| DataReader.Deserializer<T> |
|
| DataSeries |
|
| DataSource |
|
| DataSource.Coordinated |
|
| DataTransform<IN,OUT> |
DataTransform is a functional interface that can be used to transform data.
|
| DataWriter<T> |
|
| DataWriter.Serializer<T> |
|
| DateContext |
|
| DatePart |
|
| DatePrice |
|
| DatePrice.DefaultDP |
|
| DatePriceParser |
Will switch between any/all known parsers producing DatePrice subclasses. |
| DatePriceParser.DefaultParser |
|
| DateStyle |
|
| DecompositionStore<N extends java.lang.Comparable<N>> |
Only classes that will act as a delegate to a MatrixDecomposition implementation from this
package should implement this interface. |
| DeferredTridiagonal<N extends java.lang.Comparable<N>> |
|
| DeferredTridiagonal.C128 |
|
| DeferredTridiagonal.H256 |
|
| DeferredTridiagonal.Q128 |
|
| DeferredTridiagonal.R064 |
|
| DeferredTridiagonal.R128 |
|
| DenseArray<N extends java.lang.Comparable<N>> |
Each and every element occupies memory and holds a value.
|
| DenseArray.Factory<N extends java.lang.Comparable<N>> |
|
| DenseMutator2D<N extends java.lang.Comparable<N>,M extends BasicMatrix<N,M>> |
|
| DenseTableau |
|
| DetectingParser<T> |
Will detect which delegate parser to use.
|
| DeterminantTask<N extends java.lang.Comparable<N>> |
|
| DeterminantTask.Factory<N extends java.lang.Comparable<N>> |
|
| Deterministic |
|
| DiagonalStore<N extends java.lang.Comparable<N>,D extends Access1D<?>> |
|
| DiagonalStore.Builder<N extends java.lang.Comparable<N>,D extends Access1D<?>> |
|
| DifferencesSeries |
|
| DirectASS |
Solves optimisation problems of the form:
|
| DiscreteDistribution |
|
| DiscreteFourierTransform |
The discrete Fourier transform (DFT) converts a finite sequence of equally-spaced samples of a function
into a same-length sequence of equally-spaced samples of the discrete-time Fourier transform (DTFT), which
is a complex-valued function of frequency.
|
| DiscreteFourierTransform.Directive |
|
| DiscreteFourierTransform.FFT |
|
| DiscreteFourierTransform.FullMatrix |
|
| DiscreteFourierTransform.Single |
|
| Disposable |
|
| Distribution |
Distribution
|
| Distribution1D |
|
| DivideAndConquer |
|
| DivideAndConquer.Conquerer |
|
| DivideAndConquer.Divider |
|
| DOT |
The ?dot routines perform a vector-vector reduction operation defined as Equation where xi and yi are
elements of vectors x and y.
|
| DOTC |
The ?dotc routines perform a vector-vector operation defined as: Equation
|
| DOTU |
The ?dotu routines perform a vector-vector reduction operation defined as Equation where xi and yi are
elements of complex vectors x and y.
|
| DualSimplexSolver |
Requires all variables to have both lower and upper bounds.
|
| DynamicEvD<N extends java.lang.Comparable<N>> |
|
| DynamicEvD.R064 |
|
| EffectiveThrowable |
|
| EfficientFrontier |
Represents a portfolio on the efficient fronter.
|
| Eigenvalue<N extends java.lang.Comparable<N>> |
[A] = [V][D][V]-1 ([A][V] = [V][D])
[A] = any square matrix.
[V] = contains the eigenvectors as columns.
[D] = a diagonal matrix with the eigenvalues on the diagonal (possibly in blocks).
|
| Eigenvalue.Eigenpair |
|
| Eigenvalue.Factory<N extends java.lang.Comparable<N>> |
|
| Eigenvalue.Generalisation |
|
| Eigenvalue.Generalised<N extends java.lang.Comparable<N>> |
|
| EigenvalueDecomposition<N extends java.lang.Comparable<N>> |
|
| ElementsSupplier<N extends java.lang.Comparable<N>> |
An ElementsSupplier is not necessarily (or not yet) a matrix, but something from which the elements
of a matrix can be derived. |
| ElementView1D<N extends java.lang.Comparable<N>,V extends ElementView1D<N,V>> |
|
| ElementView2D<N extends java.lang.Comparable<N>,V extends ElementView2D<N,V>> |
|
| ElementViewAnyD<N extends java.lang.Comparable<N>,V extends ElementViewAnyD<N,V>> |
|
| EntryList<K,V> |
|
| EntryPair<K,V> |
Singleton (immutable) Map:s with primitive valued specialisations.
|
| EntryPair.KeyedPrimitive<K> |
|
| EntryPair.ObjectByte<K> |
|
| EntryPair.ObjectDouble<K> |
|
| EntryPair.ObjectFloat<K> |
|
| EntryPair.ObjectInt<K> |
|
| EntryPair.ObjectLong<K> |
|
| EntryPair.ObjectObject<K,V> |
|
| EntryPair.ObjectShort<K> |
|
| EntrySet<K,V> |
Allows you to wrap and treat two arrays as a Collection of key-value pairs.
|
| EntrySet.EntryView<K,V> |
|
| EntrySet.KeyedPrimitives<K> |
|
| EntrySet.ObjectByte<K> |
|
| EntrySet.ObjectDouble<K> |
|
| EntrySet.ObjectFloat<K> |
|
| EntrySet.ObjectInt<K> |
|
| EntrySet.ObjectLong<K> |
|
| EntrySet.ObjectObject<K,V> |
|
| EntrySet.ObjectShort<K> |
|
| EntrySet.ViewingIterator<K,V> |
|
| EnumeratedColumnsParser |
|
| EnumeratedColumnsParser.Builder |
|
| EnumeratedColumnsParser.FastViewStrategy |
|
| EnumeratedColumnsParser.LineView |
|
| EnumeratedColumnsParser.ParseStrategy |
|
| EnumeratedColumnsParser.QuotedViewStrategy |
|
| EnumeratedColumnsParser.RFC4180 |
|
| EnumPartition<E extends java.lang.Enum<E>> |
Keeps track of n (ordered) Enum values – any Enum and any number of values.
|
| Equation |
|
| EquilibriumModel |
|
| Erlang |
Distribution of the sum of aCount random variables with an exponential distribution with parameter aLambda.
|
| ErrorFunction |
|
| EvD1D |
|
| EvD2D |
|
| ExactDecimal<S extends ExactDecimal<S>> |
To help implement exact decimal numbers with a fixed number of decimal places (fixed scale).
|
| ExactDecimal.Descriptor |
|
| ExactDecimal.Factory<S extends ExactDecimal<S>> |
|
| Exchange |
|
| ExchangeColumns |
|
| ExplicitTimeSeries |
|
| Exponential |
Distribution of length of life when no aging.
|
| Expression |
Think of an Expression as one constraint or a component to the objective function.
|
| ExpressionsBasedModel |
Lets you construct optimisation problems by combining (mathematical) expressions in terms of variables.
|
| ExpressionsBasedModel.DefaultIntermediate |
|
| ExpressionsBasedModel.Description |
Counts of different kinds of model entities.
|
| ExpressionsBasedModel.EntityMap |
Connects solver constraints and variables back to model entities.
|
| ExpressionsBasedModel.FileFormat |
|
| ExpressionsBasedModel.Integration<S extends Optimisation.Solver> |
|
| ExpressionsBasedModel.Presolver |
|
| ExpressionsBasedModel.Simplifier<ME extends ModelEntity<?>,S extends ExpressionsBasedModel.Simplifier<?,?>> |
|
| ExpressionsBasedModel.Validator |
|
| ExpressionsBasedModel.VariableAnalyser |
|
| ExpressionsBasedModel.VariablesCategorisation |
|
| Factory1D<I extends Structure1D> |
|
| Factory1D.Builder<I extends Structure1D> |
|
| Factory1D.MayBeSparse<I extends Structure1D,DENSE extends Factory1D.Builder<I>,SPARSE extends Factory1D.Builder<I>> |
For when the structures can be either dense or sparse.
|
| Factory1D.TwoStep<I extends Structure1D,B extends Factory1D.Builder<I>> |
|
| Factory2D<I extends Structure2D> |
|
| Factory2D.Builder<I extends Structure2D> |
|
| Factory2D.MayBeSparse<I extends Structure2D,DENSE extends Factory2D.Builder<I>,SPARSE extends Factory2D.Builder<I>> |
For when the structures can be either dense or sparse.
|
| Factory2D.TwoStep<I extends Structure2D,B extends Factory2D.Builder<I>> |
|
| FactoryAnyD<I extends StructureAnyD> |
|
| FactoryAnyD.Builder<I extends StructureAnyD> |
|
| FactoryAnyD.MayBeSparse<I extends StructureAnyD,DENSE extends FactoryAnyD.Builder<I>,SPARSE extends FactoryAnyD.Builder<I>> |
For when the structures can be either dense or sparse.
|
| FactoryAnyD.TwoStep<I extends StructureAnyD,B extends FactoryAnyD.Builder<I>> |
|
| FactoryStore<N extends java.lang.Comparable<N>> |
|
| FactorySupplement |
|
| Field<T> |
A field is a commutative ring (even the multiplication operation) with notions of addition, subtraction,
multiplication, and division.
|
| FileFormat |
|
| FileFormat.Version1 |
Directly mapping the original internal construction
|
| FileFormat.Version2 |
Same as v1 but for float rather than double
|
| FileFormatEBM |
|
| FileFormatMPS |
Mathematical Programming System (MPS) parser
|
| FileFormatMPS.BoundType |
BoundType used with the BOUNDS section.
|
| FileFormatMPS.ColumnMarker |
|
| FileFormatMPS.FieldPredicate |
|
| FileFormatMPS.FileSection |
|
| FileFormatMPS.RowType |
RowType used with the ROWS and RANGES sections.
|
| FillAll |
|
| FillCompatible |
https://se.mathworks.com/help/matlab/matlab_prog/compatible-array-sizes-for-basic-operations.html
|
| FillMatchingDual |
|
| FillMatchingSingle |
|
| FinanceData<DP extends DatePrice> |
A source of (historical) financial time series data.
|
| FinanceDataReader<DP extends DatePrice> |
|
| FinancePortfolio |
A FinancePortfolio is primarily a set of portfolio asset weights.
|
| FinancePortfolio.Context |
|
| FinanceUtils |
|
| FirstOrderApproximation<N extends java.lang.Comparable<N>> |
|
| FixedReturnsPortfolio |
|
| FixedWeightsPortfolio |
|
| FloatingPointReceptacle |
An array (double[] or float[]) builder/converter.
|
| FormatContext<T> |
Abstract base class for TypeContext implementations backed by Format. |
| FourierSeries |
This is the real coefficient trigonometric form of the Fourier series.
|
| FrequencyMap<T> |
Count the occurrence of different keys
|
| FrequencyMap.FrequencyPredicate<T> |
|
| FromFileReader<T> |
|
| FromFileReader.Builder |
|
| FunctionSet<N extends java.lang.Comparable<N>> |
A predefined/standard set of functions.
|
| Gamma |
Distribution of the sum of aCount random variables with an exponential distribution with parameter aLambda.
|
| GammaFunction |
|
| GammaFunction.Incomplete |
|
| GammaFunction.LanczosApproximation |
Lanczos approximation.
|
| GammaFunction.Logarithmic |
|
| GammaFunction.Regularized |
|
| GARCH |
|
| GaussianField<K extends java.lang.Comparable<? super K>> |
This GaussianField class is a generalization, as well as the underlying implementation, of
GaussianProcess. |
| GaussianField.Covariance<K extends java.lang.Comparable<? super K>> |
|
| GaussianField.Mean<K extends java.lang.Comparable<? super K>> |
|
| GaussianProcess |
A Gaussian process is a RandomProcess where each variable has a normal distribution. |
| GaussSeidelSolver |
For solving [A][x]=[b] where [A] has non-zero elements on the diagonal.
|
| GeneralEvD<N extends java.lang.Comparable<N>> |
|
| GeneralEvD.R064 |
Eigenvalues and eigenvectors of a real matrix.
|
| GeneralisedEvD<N extends java.lang.Comparable<N>> |
|
| GenerateApplyAndCopyHouseholderColumn |
|
| GenerateApplyAndCopyHouseholderRow |
|
| GenericContext<T> |
|
| GenericDecomposition<N extends java.lang.Comparable<N>> |
AbstractDecomposition
|
| GenericSolver |
|
| GenericSolver.Builder<B extends GenericSolver.Builder<B,S>,S extends GenericSolver> |
|
| GenericStore<N extends Scalar<N>> |
|
| GenericStore.Factory<N extends Scalar<N>> |
|
| Geometric |
The number of required trials until an event with probability aProbability occurs has a geometric
distribution.
|
| GeometricBrownianMotion |
Diffusion process defined by a stochastic differential equation:
|
| GomorySolver |
An alternative MIP solver using Gomory Mixed Integer (GMI) cuts – purely iterative with no branching.
|
| GomorySolver.ModelIntegration |
|
| Group |
A group is a set of elements paired with a binary operation.
|
| Group.Additive<T> |
|
| Group.Multiplicative<T> |
|
| GrowthStrategy |
To be used by non fixed size data structures that delegate the actual storage to a DenseArray.
|
| GrowthStrategy.Builder |
|
| Hardware |
The first element in the array should correspond to total system resources; the total amount of RAM and
the total number of threads (Typically the same as what is returned by
Runtime.availableProcessors()).
|
| HermitianEvD<N extends java.lang.Comparable<N>> |
Eigenvalues and eigenvectors of a real matrix.
|
| HermitianEvD.C128 |
|
| HermitianEvD.H256 |
|
| HermitianEvD.Q128 |
|
| HermitianEvD.R064 |
|
| HermitianEvD.R128 |
|
| HermitianRank2Update |
[A] -= ([a][b]c+[b][a]c)
[A] is assumed to be hermitian (square symmetric) [A] = [A]C.
|
| Hessenberg<N extends java.lang.Comparable<N>> |
Hessenberg: [A] = [Q][H][Q]T A general square matrix [A] can be decomposed by orthogonal
similarity transformations into the form [A]=[Q][H][Q]T where
[H] is upper (or lower) hessenberg matrix
[Q] is orthogonal/unitary
|
| Hessenberg.Factory<N extends java.lang.Comparable<N>> |
|
| HessenbergDecomposition<N extends java.lang.Comparable<N>> |
|
| HessenbergDecomposition.C128 |
|
| HessenbergDecomposition.H256 |
|
| HessenbergDecomposition.Q128 |
|
| HessenbergDecomposition.R064 |
|
| HessenbergDecomposition.R128 |
|
| Homoscedastic |
|
| Householder<N extends java.lang.Comparable<N>> |
|
| Householder.Generic<N extends Scalar<N>> |
|
| Householder.Primitive32 |
|
| Householder.Primitive64 |
|
| HouseholderColumn<N extends java.lang.Comparable<N>> |
|
| HouseholderHermitian |
Performs Householder transformation from both sides simultaneously assuming that [A] is hermitian (square
symmetric) [A] = [A]H.
|
| HouseholderLeft |
|
| HouseholderReference<N extends java.lang.Comparable<N>> |
|
| HouseholderRight |
|
| HouseholderRow<N extends java.lang.Comparable<N>> |
|
| HypergeometricFunction |
|
| IdentityStore<N extends java.lang.Comparable<N>> |
IdentityStore
|
| IDX |
|
| IEXTradingFetcher |
Deprecated.
|
| IEXTradingParser |
https://iextrading.com/developer/docs/#chart
|
| IEXTradingParser.Data |
|
| ImageData |
Treats an image as a matrix.
|
| ImageData.FrequencyDomainUpdater |
|
| ImageData.SingleChannel |
|
| ImplicitTimeSeries |
|
| IndexedMap<K,V> |
Wrap two arrays (of keys and values) and treat the result as a Map.
|
| IndexedMap.MappedPrimitives<K> |
|
| IndexOf |
|
| IndexSelector |
An array of int:s (indices) that are partitioned to be either "included" or "excluded".
|
| InMemoryFile |
An in-memory "file" that can be used with some ToFileWriter and/or FromFileReaderr
implementations instead of a File. |
| InPlaceDecomposition<N extends java.lang.Comparable<N>> |
|
| IntegerSolver |
|
| IntegerSolver.ModelIntegration |
|
| IntegerSolver.NodeStatistics |
When a node is determined to be a leaf - no further branching - what was the reason?
|
| IntegerStrategy |
|
| IntegerStrategy.ConfigurableStrategy |
|
| IntegerStrategy.GMICutConfiguration |
Gomory Mixed Integer Cut Configuration
|
| IntermediateSolver |
|
| InverterTask<N extends java.lang.Comparable<N>> |
|
| InverterTask.Factory<N extends java.lang.Comparable<N>> |
|
| InvertibleFactor<N extends java.lang.Comparable<N>> |
A chainable and reversible in-place (equation system) solver.
|
| InvertibleFactor.IdentityFactor<N extends java.lang.Comparable<N>> |
|
| IterativeASS |
Solves optimisation problems of the form:
|
| IterativeASS.SparseArrayPool |
|
| IterativeRefinementSolver |
Algorithm from: Solving quadratic programs to high precision using scaled iterative refinement
Mathematical Programming Computation (2019) 11:421–455 https://doi.org/10.1007/s12532-019-00154-6
|
| IterativeSolverTask |
For solving very large sparse equation systems – [A][x]=[b].
|
| IterativeSolverTask.Configurator |
|
| IterativeSolverTask.SparseDelegate |
|
| Iterator1D<N extends java.lang.Comparable<N>> |
|
| JacobiSolver |
For solving [A][x]=[b] where [A] has non-zero elements on the diagonal.
|
| JavaType |
B byte signed byte
C char Unicode character code point in the Basic Multilingual Plane,
encoded with UTF-16
D double double-precision floating-point value
F float single-precision floating-point value
I int integer
J long long integer
L ClassName ; reference an instance of class ClassName
S short signed short
Z boolean true or false
[ reference one array dimension
|
| Keyed1D<K,N extends java.lang.Comparable<N>> |
|
| Keyed2D<R,C,N extends java.lang.Comparable<N>> |
|
| KeyValue<K,V> |
A pair, like Map.Entry without Map.Entry.setValue(Object).
|
| KeyValue.Dual<T> |
A pair of the same type.
|
| KrylovSubspaceSolver |
|
| LayerTemplate |
|
| LDL<N extends java.lang.Comparable<N>> |
LDL: [A] = [L][D][L]H (or [R]H[D][R])
|
| LDL.Factory<N extends java.lang.Comparable<N>> |
|
| LDL.ModifiedFactory<N extends java.lang.Comparable<N>> |
|
| LDLDecomposition<N extends java.lang.Comparable<N>> |
|
| LDLDecomposition.C128 |
|
| LDLDecomposition.H256 |
|
| LDLDecomposition.Q128 |
|
| LDLDecomposition.R064 |
|
| LDLDecomposition.R128 |
|
| LDU<N extends java.lang.Comparable<N>> |
LDU: [A] = [L][D][U] ( [PL][L][D][U][PU] )
|
| LeftRightStore<N extends java.lang.Comparable<N>> |
A merger of two MatrixStore instances by placing one store to the right of the other. |
| LimitStore<N extends java.lang.Comparable<N>> |
|
| LinearFunction<N extends java.lang.Comparable<N>> |
[l]T[x]
|
| LinearFunction.Factory<N extends java.lang.Comparable<N>> |
|
| LinearSolver |
|
| LinearSolver.Builder |
Compared to LinearSolver.StandardBuilder this builder:
1) Accepts inequality constraints
2) Has relaxed the requiremnt on the RHS to be non-negative (both equalities and inequalities)
|
| LinearSolver.Configuration |
|
| LinearSolver.ModelIntegration |
|
| LinearSolver.NewIntegration |
An integration to a new/alternative/experimental LP-solver.
|
| LinearSolver.OldIntegration |
|
| LinearStructure |
LP (simplex tableau) meta data.
|
| LineSplittingParser |
|
| LineTerminator |
|
| LogicalStore<N extends java.lang.Comparable<N>> |
Logical stores are (intended to be) immutable.
|
| LogNormal |
A continuous distribution in which the logarithm of a variable has a normal distribution.
|
| LongToNumberMap<N extends java.lang.Comparable<N>> |
A SortedMap with primitive valued long keys and Comparable values (incl.
|
| LongToNumberMap.MapFactory<N extends java.lang.Comparable<N>> |
|
| LowerHessenbergStore<N extends java.lang.Comparable<N>> |
A Hessenberg matrix is one that is "almost" triangular.
|
| LowerSymmetricStore<N extends java.lang.Comparable<N>> |
|
| LowerTriangularStore<N extends java.lang.Comparable<N>> |
|
| LowerUpper |
|
| LU<N extends java.lang.Comparable<N>> |
LU: [A] = [L][U]
|
| LU.Factory<N extends java.lang.Comparable<N>> |
|
| LUDecomposition<N extends java.lang.Comparable<N>> |
|
| LUDecomposition.C128 |
|
| LUDecomposition.H256 |
|
| LUDecomposition.Q128 |
|
| LUDecomposition.R064 |
|
| LUDecomposition.R128 |
|
| ManagedConsumer<T> |
|
| ManagedSupplier<T> |
|
| MappedConsumer<IN,OUT> |
|
| MappedIndexSeries<K extends java.lang.Comparable<? super K>,N extends java.lang.Comparable<N>> |
|
| MappedSupplier<IN,OUT> |
|
| MarketEquilibrium |
MarketEquilibrium translates between the market portfolio weights and the equilibrium excess returns.
|
| MarkowitzModel |
The Markowitz model, in this class, is defined as:
|
| MathType |
The number sets supported by ojAlgo, paired with a declaration of how they are implemented/approximated.
|
| Matrix2D<N extends java.lang.Comparable<N>,M extends Matrix2D<N,M>> |
|
| MatrixC128 |
A matrix (linear algebra) with Complex NumberSet.C elements, implemented using dual 64-bit double
values. |
| MatrixC128.DenseReceiver |
|
| MatrixC128.Factory |
|
| MatrixC128.SparseReceiver |
|
| MatrixDecomposition<N extends java.lang.Comparable<N>> |
Notation used to describe the various matrix decompositions:
[A] could be any matrix.
|
| MatrixDecomposition.Determinant<N extends java.lang.Comparable<N>> |
|
| MatrixDecomposition.EconomySize<N extends java.lang.Comparable<N>> |
Several matrix decompositions can be expressed "economy sized" - some rows or columns of the decomposed
matrix parts are not needed for the most releveant use cases, and can therefore be left out.
|
| MatrixDecomposition.Factory<D extends MatrixDecomposition<?>> |
|
| MatrixDecomposition.Hermitian<N extends java.lang.Comparable<N>> |
Some matrix decompositions are only available with hermitian (symmetric) matrices or different
decomposition algorithms could be used depending on if the matrix is hemitian or not.
|
| MatrixDecomposition.Ordered<N extends java.lang.Comparable<N>> |
|
| MatrixDecomposition.Pivoting<N extends java.lang.Comparable<N>> |
The pivot or pivot element is the element of a matrix, or an array, which is selected first by an
algorithm (e.g.
|
| MatrixDecomposition.RankRevealing<N extends java.lang.Comparable<N>> |
A rank-revealing matrix decomposition of a matrix [A] is a decomposition that is, or can be transformed
to be, on the form [A]=[X][D][Y]T where:
[X] and [Y] are square and well conditioned.
[D] is diagonal with nonnegative and non-increasing values on the diagonal.
|
| MatrixDecomposition.Solver<N extends java.lang.Comparable<N>> |
|
| MatrixDecomposition.Values<N extends java.lang.Comparable<N>> |
Eigenvalue and Singular Value decompositions can calculate the "values" only.
|
| MatrixFactory<N extends java.lang.Comparable<N>,M extends BasicMatrix<N,M>,DR extends Mutate2D.ModifiableReceiver<N> & Factory2D.Builder<M>,SR extends Factory2D.Builder<M>> |
MatrixFactory creates instances of classes that implement the BasicMatrix
interface and have a constructor that takes a MatrixStore as input. |
| MatrixH256 |
A matrix (linear algebra) with Quaternion NumberSet.H elements, implemented using four 64-bit
double values. |
| MatrixH256.DenseReceiver |
|
| MatrixH256.Factory |
|
| MatrixH256.SparseReceiver |
|
| MatrixOperation |
Contents in this package loosely corresponds to BLAS.
|
| MatrixPipeline<N extends java.lang.Comparable<N>> |
Intermediate step in a matrix pipeline – a chain of operations to be executed when the elements are
extracted.
|
| MatrixPipeline.BinaryOperatorLeft<N extends java.lang.Comparable<N>> |
|
| MatrixPipeline.BinaryOperatorRight<N extends java.lang.Comparable<N>> |
|
| MatrixPipeline.ColumnsModifier<N extends java.lang.Comparable<N>> |
|
| MatrixPipeline.ColumnsReducer<N extends java.lang.Comparable<N>> |
|
| MatrixPipeline.Multiplication<N extends java.lang.Comparable<N>> |
|
| MatrixPipeline.RowsModifier<N extends java.lang.Comparable<N>> |
|
| MatrixPipeline.RowsReducer<N extends java.lang.Comparable<N>> |
|
| MatrixPipeline.Transformer<N extends java.lang.Comparable<N>> |
|
| MatrixPipeline.Transpose<N extends java.lang.Comparable<N>> |
|
| MatrixPipeline.UnaryOperator<N extends java.lang.Comparable<N>> |
|
| MatrixQ128 |
A matrix (linear algebra) with Rational NumberSet.Q elements, implemented using dual 64-bit long
values. |
| MatrixQ128.DenseReceiver |
|
| MatrixQ128.Factory |
|
| MatrixQ128.SparseReceiver |
|
| MatrixR032 |
A matrix (linear algebra) with Real NumberSet.R elements, approximated by 32-bit float. |
| MatrixR032.DenseReceiver |
|
| MatrixR032.Factory |
|
| MatrixR032.SparseReceiver |
|
| MatrixR064 |
A matrix (linear algebra) with Real NumberSet.R elements, approximated by 64-bit double. |
| MatrixR064.DenseReceiver |
|
| MatrixR064.Factory |
|
| MatrixR064.SparseReceiver |
|
| MatrixR128 |
A matrix (linear algebra) with Real NumberSet.R elements, approximated by 128-bit floating-point
values (implemented using dual 64-bit double). |
| MatrixR128.DenseReceiver |
|
| MatrixR128.Factory |
|
| MatrixR128.SparseReceiver |
|
| MatrixStore<N extends java.lang.Comparable<N>> |
A MatrixStore is a two dimensional store of numbers/scalars. |
| MatrixTask<N extends java.lang.Comparable<N>> |
|
| MatrixTensor<N extends java.lang.Comparable<N>> |
|
| MatrixTensor.Factory<N extends java.lang.Comparable<N>> |
|
| MBeanUtils |
|
| MemoryEstimator |
MemoryEstimator
|
| MissingMath |
Math utilities missing from Math.
|
| ModelEntity<ME extends ModelEntity<ME>> |
Model entities are identified and compared by their names only.
|
| ModelStrategy |
This base class contains some model/problem specific data required by the IntegerSolver. |
| ModelStrategy.AbstractStrategy |
When implementing your own ModelStrategy extending this abstract class is a good starting
point. |
| ModelStrategy.DefaultStrategy |
|
| ModifyAll |
|
| Money |
An example ExactDecimal implementation corresponding to the SQL data type MONEY or DECIMAL(19,4). |
| MultiaryFunction<N extends java.lang.Comparable<N>> |
|
| MultiaryFunction.Affine<N extends java.lang.Comparable<N>> |
|
| MultiaryFunction.Constant<N extends java.lang.Comparable<N>> |
|
| MultiaryFunction.Convex<N extends java.lang.Comparable<N>> |
|
| MultiaryFunction.Linear<N extends java.lang.Comparable<N>> |
|
| MultiaryFunction.PureQuadratic<N extends java.lang.Comparable<N>> |
|
| MultiaryFunction.Quadratic<N extends java.lang.Comparable<N>> |
|
| MultiaryFunction.TwiceDifferentiable<N extends java.lang.Comparable<N>> |
Twice (Continuously) Differentiable Multiary Function
|
| MultipleValuesBasedProcess<D extends Distribution> |
|
| MultiplyBoth |
|
| MultiplyBoth.Generic<N extends Scalar<N>> |
|
| MultiplyBoth.Primitive |
|
| MultiplyHermitianAndVector |
Multiplies an hermitian (square symmetric) matrix with a vector.
|
| MultiplyLeft |
|
| MultiplyLeft.Generic<N extends Scalar<N>> |
|
| MultiplyLeft.Primitive32 |
|
| MultiplyLeft.Primitive64 |
|
| MultiplyNeither |
|
| MultiplyNeither.Generic<N extends Scalar<N>> |
|
| MultiplyNeither.Primitive32 |
|
| MultiplyNeither.Primitive64 |
|
| MultiplyRight |
|
| MultiplyRight.Generic<N extends Scalar<N>> |
|
| MultiplyRight.Primitive32 |
|
| MultiplyRight.Primitive64 |
|
| MultiviewSet<T> |
Multiple prioritised Queue:s backed by a common Set.
|
| MutableSolver<D extends IterativeSolverTask & IterativeSolverTask.SparseDelegate> |
|
| Mutate1D |
1-dimensional mutator methods
|
| Mutate1D.Fillable<N extends java.lang.Comparable<N>> |
Fills the target
|
| Mutate1D.Mixable<N extends java.lang.Comparable<N>> |
Mix/combine the previously existing value, at index, with the supplied addend.
|
| Mutate1D.Modifiable<N extends java.lang.Comparable<N>> |
|
| Mutate1D.ModifiableReceiver<N extends java.lang.Comparable<N>> |
|
| Mutate1D.Receiver<N extends java.lang.Comparable<N>> |
Anything/everything that does not require interaction with already existing elements.
|
| Mutate1D.Sortable |
|
| Mutate2D |
2-dimensional mutator methods
|
| Mutate2D.Exchangeable |
A few operations with no 1D or AnyD counterpart.
|
| Mutate2D.Fillable<N extends java.lang.Comparable<N>> |
|
| Mutate2D.Mixable<N extends java.lang.Comparable<N>> |
|
| Mutate2D.Modifiable<N extends java.lang.Comparable<N>> |
|
| Mutate2D.ModifiableReceiver<N extends java.lang.Comparable<N>> |
|
| Mutate2D.Receiver<N extends java.lang.Comparable<N>> |
|
| MutateAnyD |
N-dimensional mutator methods
|
| MutateAnyD.Fillable<N extends java.lang.Comparable<N>> |
|
| MutateAnyD.Mixable<N extends java.lang.Comparable<N>> |
|
| MutateAnyD.Modifiable<N extends java.lang.Comparable<N>> |
|
| MutateAnyD.ModifiableReceiver<N extends java.lang.Comparable<N>> |
|
| MutateAnyD.Receiver<N extends java.lang.Comparable<N>> |
|
| NativeMemory |
|
| NegateColumn |
|
| NetworkBuilder |
An Artificial Neural Network (ANN) builder.
|
| NetworkInvoker |
|
| NetworkTrainer |
An Artificial Neural Network (ANN) builder/trainer.
|
| NodeDropper |
|
| NodeKey |
|
| NodeKey.IntArrayPool |
|
| NodeSolver |
|
| Normal |
Under general conditions, the sum of a large number of random variables is approximately normally
distributed (the central limit theorem).
|
| Normal1D |
|
| NormalisedPortfolio |
Normalised weights Portfolio
|
| NormedVectorSpace<T,N extends java.lang.Comparable<N>> |
|
| NRM2 |
The ?nrm2 routines perform a vector reduction operation defined as res = ||x||, where: x is a vector, res
is a value containing the Euclidean norm of the elements of x.
|
| NRMINF |
Infinity norm - largest absolute value
|
| NullaryFunction<N extends java.lang.Comparable<N>> |
|
| NumberContext |
Think of this as a MathContext that specifies both precision and scale.
|
| NumberContext.Enforceable<T> |
|
| NumberContext.FormatPattern |
|
| NumberDefinition |
An interface defining a "Number".
|
| NumberList<N extends java.lang.Comparable<N>> |
Think of this as an ArrayList that can only contain numbers, but with a few extra features.
|
| NumberList.ListFactory<N extends java.lang.Comparable<N>> |
|
| NumberSeries<N extends java.lang.Comparable<N>> |
|
| NumberSet |
Some special sets of numbers commonly used in mathematics
|
| NumberStyle |
|
| NumberStyle.IntegerToUniformString |
|
| ObjectPool<T> |
|
| OffHeapArray |
Off heap memory array.
|
| OffHeapArray.Factory |
|
| OffHeapR032 |
|
| OffHeapR064 |
|
| OffHeapZ008 |
|
| OffHeapZ016 |
|
| OffHeapZ032 |
|
| OffHeapZ064 |
|
| OffsetStore<N extends java.lang.Comparable<N>> |
|
| OjAlgoUtils |
|
| Operate1D<N extends java.lang.Comparable<N>,P extends Operate1D<N,P>> |
|
| Operate2D<N extends java.lang.Comparable<N>,P extends Operate2D<N,P>> |
To be implemented by classes that are not directly mutable themselves, but that can operate on the elements
of some internal/future 2D data structure – similar to streams in some sense.
|
| OperateAnyD<N extends java.lang.Comparable<N>,P extends OperateAnyD<N,P>> |
|
| Operation |
|
| Operation |
|
| Operation.Addition<T> |
|
| Operation.Division<T> |
|
| Operation.Multiplication<T> |
|
| Operation.Subtraction<T> |
|
| OperationBinary |
|
| OperationParameter |
|
| OperationUnary |
|
| OperationVoid |
|
| OperatorWithException<T> |
|
| Optimisation |
|
| Optimisation.Constraint |
Constraint
|
| Optimisation.ConstraintType |
|
| Optimisation.Integration<M extends Optimisation.Model,S extends Optimisation.Solver> |
|
| Optimisation.Model |
|
| Optimisation.Objective |
Objective
|
| Optimisation.Options |
|
| Optimisation.ProblemStructure |
Basic description of the size/structure of an optimisation problem.
|
| Optimisation.Result |
|
| Optimisation.Sense |
|
| Optimisation.Solver |
|
| Optimisation.State |
|
| OptimisationService |
|
| OptimisationService.Integration |
|
| OptimisationService.Solver |
|
| OptimisedPortfolio |
|
| OptimisedPortfolio.Template |
|
| Paired<K,V> |
|
| ParallelGaussSeidelSolver |
|
| Parallelism |
A set of standard levels of parallelsim derived from the number of available cores and optionally capped by
reserving a specified amount of memory per thread.
|
| ParallelismSupplier |
|
| ParameterFunction<N extends java.lang.Comparable<N>> |
|
| ParameterFunction.FixedParameter<N extends java.lang.Comparable<N>> |
|
| Password |
Password
|
| PeriodicFunction |
A periodic function is a function that repeats its values in regular intervals or periods.
|
| PhasedSimplexSolver |
First runs the dual algorithm (with a possibly modified objective function) to establish feasibility, and
then the primal to reach optimality.
|
| PhysicalStore<N extends java.lang.Comparable<N>> |
PhysicalStore:s, as opposed to MatrixStore:s, are mutable.
|
| PhysicalStore.Factory<N extends java.lang.Comparable<N>,I extends PhysicalStore<N> & Factory2D.Builder<I>> |
|
| Pivot |
|
| PlainArray<N extends java.lang.Comparable<N>> |
Array class limited by integer (int, not long) indices.
|
| PochhammerSymbol |
http://mathworld.wolfram.com/PochhammerSymbol.html
https://en.wikipedia.org/wiki/Falling_and_rising_factorials
|
| Poisson |
The Poisson distribution is a discrete probability distribution that expresses the probability of a given
number of events occurring in a fixed interval of time and/or space if these events occur with a known
average rate and independently of the time since the last event.
|
| PoissonProcess |
A Poisson process is a stochastic process which counts the number of events in a given time interval.
|
| PolynomialC128 |
|
| PolynomialFunction<N extends java.lang.Comparable<N>> |
|
| PolynomialQ128 |
|
| PolynomialR032 |
|
| PolynomialR064 |
|
| PolynomialR128 |
|
| PolynomialR256 |
BigPolynomial
|
| PortfolioContext |
|
| PortfolioMixer |
|
| PortfolioSimulator |
|
| PowerOf2 |
|
| PowerOf2.IntPower |
|
| PowerOf2.LongPower |
|
| PredicateFunction<N extends java.lang.Comparable<N>> |
|
| Presolvers |
|
| Price |
price or exchange rate as in "amount = price * quatity" or "amount = rate * amount"
|
| PrimalSimplexSolver |
Requires the initial basis to be feasible (doesn't do a phase-1).
|
| Primitive1D |
|
| Primitive1D.Simple |
|
| Primitive1D.Wrapper |
|
| Primitive2D |
|
| Primitive2D.Simple |
|
| Primitive2D.Wrapper |
|
| PrimitiveAggregator |
|
| PrimitiveAggregator.PrimitiveAggregatorFunction |
|
| PrimitiveAnyD |
|
| PrimitiveAnyD.Simple |
|
| PrimitiveAnyD.Wrapper |
|
| PrimitiveArray |
|
| PrimitiveFactory<I extends PhysicalStore<java.lang.Double> & Factory2D.Builder<I>> |
|
| PrimitiveFunction |
Only the primitive parameter (double) methods are actually implemented.
|
| PrimitiveFunction.Binary |
|
| PrimitiveFunction.Consumer |
|
| PrimitiveFunction.Nullary |
|
| PrimitiveFunction.Parameter |
|
| PrimitiveFunction.Predicate |
|
| PrimitiveFunction.SampleDomain |
|
| PrimitiveFunction.Unary |
|
| PrimitiveMath |
|
| PrimitiveMath.Prefix |
|
| PrimitiveNumber |
Intended as a "boxed" version of any/all primitive numeric types.
|
| PrimitiveNumber.BoxedByte |
|
| PrimitiveNumber.BoxedDouble |
|
| PrimitiveNumber.BoxedFloat |
|
| PrimitiveNumber.BoxedInt |
|
| PrimitiveNumber.BoxedLong |
|
| PrimitiveNumber.BoxedShort |
|
| PrimitiveScalar |
|
| PrimitiveSeries |
|
| PrimitiveSubtype |
|
| PrimitiveTimeSeries |
|
| Process1D<P extends Process1D.ComponentProcess<?>> |
Drive a set of processes simultaneously – correlated or uncorrelated.
|
| Process1D.ComponentProcess<D extends Distribution> |
|
| ProcessingService |
A simple wrapper around an ExecutorService that makes it easier to process collections of items in
parallel.
|
| ProcessingService.CallableConsumer<W> |
|
| ProcessingService.CallableMapper<W,R> |
|
| ProductFormInverse |
|
| ProductFormInverse.ArrayPool |
|
| ProductFormInverse.ElementaryFactor |
|
| ProgrammingError |
Incorrect use of the API.
|
| Provider2D |
|
| Provider2D.Condition |
|
| Provider2D.Determinant<N extends java.lang.Comparable<N>> |
|
| Provider2D.Eigenpairs |
|
| Provider2D.Hermitian |
|
| Provider2D.Inverse<M> |
|
| Provider2D.Rank |
|
| Provider2D.Solution<M> |
|
| Provider2D.Symmetric |
|
| Provider2D.Trace<N extends java.lang.Comparable<N>> |
|
| PrunedSeries |
|
| PureQuadraticFunction<N extends java.lang.Comparable<N>> |
[x]T[Q][x] + c
|
| PureQuadraticFunction.Factory<N extends java.lang.Comparable<N>> |
|
| QPESolver |
Solves optimisation problems of the form:
|
| QR<N extends java.lang.Comparable<N>> |
QR: [A] = [Q][R] Decomposes [this] into [Q] and [R] where:
[Q] is an orthogonal matrix (orthonormal columns).
|
| QR.Factory<N extends java.lang.Comparable<N>> |
|
| QRDecomposition<N extends java.lang.Comparable<N>> |
|
| QRDecomposition.C128 |
|
| QRDecomposition.H256 |
|
| QRDecomposition.Q128 |
|
| QRDecomposition.R064 |
|
| QRDecomposition.R128 |
|
| QuadraticFunction<N extends java.lang.Comparable<N>> |
[x]T[Q][x] + [l]T[x] + c
|
| QuadraticFunction.Factory<N extends java.lang.Comparable<N>> |
|
| Quadruple |
https://stackoverflow.com/questions/66962567/how-to-emulate-double-precision-using-two-floats-in-opengl-es
|
| QuadrupleAggregator |
|
| QuadrupleAggregator.QuadrupleAggregatorFunction |
|
| QuadrupleFunction |
RationalFunction
|
| QuadrupleFunction.Binary |
|
| QuadrupleFunction.Consumer |
|
| QuadrupleFunction.Nullary |
|
| QuadrupleFunction.Parameter |
|
| QuadrupleFunction.Predicate |
|
| QuadrupleFunction.Unary |
|
| QuadrupleMath |
|
| QuadrupleMath.Prefix |
|
| Quantity |
quantity as in "amount = price * quatity"
|
| Quaternion |
|
| Quaternion.RotationAxis |
|
| QuaternionAggregator |
|
| QuaternionAggregator.QuaternionAggregatorFunction |
|
| QuaternionFunction |
|
| QuaternionFunction.Binary |
|
| QuaternionFunction.Consumer |
|
| QuaternionFunction.Nullary |
|
| QuaternionFunction.Parameter |
|
| QuaternionFunction.Predicate |
|
| QuaternionFunction.Unary |
|
| QuaternionMath |
|
| QueuedConsumer<T> |
|
| QueuedConsumer.Worker<T> |
|
| QueuedSupplier<T> |
|
| QueuedSupplier.Worker<T> |
|
| QuotientsSeries |
|
| R032Store |
|
| R064Store |
|
| Random1D |
|
| RandomField<T> |
A random field is a generalization of a stochastic process such that the underlying parameter need no
longer be a simple real or integer valued "time", but can instead take values that are multidimensional
vectors, or points on some manifold.
|
| RandomNumber |
RandomNumber
|
| RandomProcess<D extends Distribution> |
A random/stochastic process (a series of random variables indexed by time or space) representing the
evolution of some random value.
|
| RandomProcess.SimulationResults |
|
| RationalAggregator |
|
| RationalAggregator.RationalAggregatorFunction |
|
| RationalFunction |
RationalFunction
|
| RationalFunction.Binary |
|
| RationalFunction.Consumer |
|
| RationalFunction.Nullary |
|
| RationalFunction.Parameter |
|
| RationalFunction.Predicate |
|
| RationalFunction.Unary |
|
| RationalMath |
|
| RationalMath.Prefix |
|
| RationalNumber |
|
| RawCholesky |
|
| RawDecomposition |
In many ways similar to InPlaceDecomposition but this class is hardwired to work with double[][] data.
|
| RawEigenvalue |
Eigenvalues and eigenvectors of a real matrix.
|
| RawEigenvalue.Dynamic |
|
| RawEigenvalue.General |
|
| RawEigenvalue.Symmetric |
|
| RawLU |
|
| RawQR |
For an m-by-n matrix A with m >= n, the QR decomposition is an m-by-n orthogonal matrix Q and an n-by-n
upper triangular matrix R so that A = Q*R.
|
| RawSingularValue |
Singular Value Decomposition.
|
| RawStore |
Uses double[][] internally.
|
| ReaderWriterBuilder<B extends ReaderWriterBuilder<B>> |
|
| RecoverableCondition |
Something that potentially could go wrong, actually did go wrong.
|
| ReferenceTypeArray<N extends java.lang.Comparable<N>> |
A one- and/or arbitrary-dimensional array of Comparable.
|
| RepeatedColumnsStore<N extends java.lang.Comparable<N>> |
|
| RepeatedRowsStore<N extends java.lang.Comparable<N>> |
|
| ResourceLocator |
Locate/fetch resources such as csv, json or text/html.
|
| ResourceLocator.KeyedValues |
|
| ResourceLocator.Method |
|
| ResourceLocator.Request |
|
| ResourceLocator.Response |
|
| ResourceLocator.Session |
|
| ResourceSpecification |
ResourceSpecification - it's a URI/URL builder.
|
| RevisedStore |
|
| Ring<T> |
A ring is a commutative group (addition operation) with a second binary operation (multiplication) that is
distributive over the commutative group operation and is associative.
|
| ROT |
Given two complex vectors x and y, each vector element of these vectors is replaced as follows: xi = c*xi +
s*yi yi = c*yi - s*xi
|
| RotateLeft |
|
| RotateRight |
|
| RotateRight |
|
| Rotation<N extends java.lang.Comparable<N>> |
|
| Rotation.Generic<N extends Scalar<N>> |
|
| Rotation.Primitive |
|
| ROTG |
Given the Cartesian coordinates (a, b) of a point, these routines return the parameters c, s, r, and z
associated with the Givens rotation.
|
| ROTM |
Given two vectors x and y, each vector element of these vectors is replaced as follows: for i=1 to n, where
H is a modified Givens transformation matrix whose values are stored in the param[1] through param[4]
array.
|
| ROTMG |
Given Cartesian coordinates (x1, y1) of an input vector, these routines compute the components of a
modified Givens transformation matrix H that zeros the y-component of the resulting vector:
|
| RowsStore<N extends java.lang.Comparable<N>> |
A selection (re-ordering) of rows.
|
| RowsSupplier<N extends java.lang.Comparable<N>> |
Sparse rows – rows can be added and removed.
|
| RowsSupplier.SingleView<N extends java.lang.Comparable<N>> |
|
| SampleSet |
|
| SCAL |
The ?scal routines perform a vector operation defined as x = a*x where: a is a scalar, x is an n-element
vector.
|
| Scalar<N extends java.lang.Comparable<N>> |
|
| Scalar.Factory<N extends java.lang.Comparable<N>> |
|
| ScalarArray<N extends Scalar<N>> |
A one- and/or arbitrary-dimensional array of Scalar. |
| ScalarOperation |
|
| ScalarOperation.Addition<T,N extends java.lang.Comparable<N>> |
|
| ScalarOperation.Division<T,N extends java.lang.Comparable<N>> |
|
| ScalarOperation.Multiplication<T,N extends java.lang.Comparable<N>> |
|
| ScalarOperation.Subtraction<T,N extends java.lang.Comparable<N>> |
|
| ScalarPolynomial<N extends Scalar<N>,P extends ScalarPolynomial<N,P>> |
|
| ScedasticityModel |
|
| ScheduleBuilder |
|
| ScoredDualConsumer<T> |
|
| SDOT |
The ?sdot routines compute the inner product of two vectors with double precision.
|
| SecondOrderApproximation<N extends java.lang.Comparable<N>> |
|
| SegmentedArray<N extends java.lang.Comparable<N>> |
An array implemented as a sequence of segments that together make up the data structure.
|
| SegmentedFile |
Divides a large file in segments and then reads those (in parallel) using memory mapped files (memory
mapped file segments).
|
| SegmentedFile.Builder |
|
| SegmentedFile.Segment |
|
| SelectingStore<N extends java.lang.Comparable<N>> |
Selects (rearranges) existing rows and/or columns.
|
| SelfDeclaringScalar<S extends SelfDeclaringScalar<S>> |
|
| SequencedSupplier<S,T> |
|
| SeriesExtrapolator<K extends java.lang.Comparable<? super K>> |
An extrapolator produces new data points to existing series.
|
| SeriesForecaster |
A forecaster is restricted to CalendarDate keys and is intended to predict something related
to future keys/dates. |
| SeriesFunction<K extends java.lang.Comparable<? super K>> |
A function that maps from a (collection of) series and one or more keys to a series of numbers.
|
| SeriesInterpolator<K extends java.lang.Comparable<? super K>> |
An interpolator produces new data points to existing series, inbetween existing keys.
|
| SeriesInterpolator |
|
| SeriesSet |
|
| ServiceClient |
Make http/https calls.
|
| ServiceClient.Request |
|
| ServiceClient.Response<T> |
This is actually a wrapper of a future response.
|
| ServiceClient.Session |
When you need to make a sequence of calls maintaining some state inbetween calls.
|
| ShadingStore<N extends java.lang.Comparable<N>> |
Does not change the matrix size/shape, but applies some structure to the elements.
|
| ShardedConsumer<T> |
|
| ShardedConsumer.GeneralShardedConsumer<T> |
|
| ShardedConsumer.PowerOf2ShardedConsumer<T> |
|
| ShardedFile |
|
| SimpleAsset |
SimpleAsset is used to describe 1 asset (portfolio member).
|
| SimplePortfolio |
|
| SimpleSeries<K extends java.lang.Comparable<? super K>,V extends java.lang.Comparable<V>> |
|
| SimplexSolver |
|
| SimplexSolver.Direction |
|
| SimplexSolver.EnterInfo |
|
| SimplexSolver.ExitInfo |
|
| SimplexSolver.IterDescr |
|
| SimplexStore |
|
| SimplexStore.ColumnState |
|
| SimplexTableau |
|
| SimplexTableauSolver |
Classic simplex tableau solver:
Primal algorithm
2-phase
All variables assumed >=0, and RHS required to be >=0
Variable bounds other than >=0 handled like constraints
|
| SimplexTableauSolver.IterationPoint |
|
| SimultaneousTridiagonal |
Computes Q while decomposing.
|
| SingleStore<N extends java.lang.Comparable<N>> |
|
| SingleValueBasedProcess<D extends Distribution> |
|
| SingularValue<N extends java.lang.Comparable<N>> |
Singular Value: [A] = [U][D][V]T Decomposes [this] into [U], [D] and [V] where:
[U] is an orthogonal matrix.
|
| SingularValue.Factory<N extends java.lang.Comparable<N>> |
|
| SingularValueDecomposition<N extends java.lang.Comparable<N>> |
|
| SingularValueDecomposition.C128 |
|
| SingularValueDecomposition.H256 |
|
| SingularValueDecomposition.Q128 |
|
| SingularValueDecomposition.R064 |
|
| SingularValueDecomposition.R128 |
|
| SolverTask<N extends java.lang.Comparable<N>> |
|
| SolverTask.Factory<N extends java.lang.Comparable<N>> |
|
| SortAll |
|
| SourceCache |
|
| SourceCache.Value |
|
| SparseArray<N extends java.lang.Comparable<N>> |
Only stores nonzero elements and/or elements specifically set by the user.
|
| SparseArray.NonzeroPrimitiveCallback |
|
| SparseArray.NonzeroReferenceTypeCallback<N extends java.lang.Comparable<N>> |
|
| SparseArray.NonzeroView<N extends java.lang.Comparable<N>> |
|
| SparseArray.SparseFactory<N extends java.lang.Comparable<N>> |
|
| SparseMutator2D<N extends java.lang.Comparable<N>,M extends BasicMatrix<N,M>> |
|
| SparseStore<N extends java.lang.Comparable<N>> |
A sparse matrix (this implementation) is not thread safe.
|
| SparseStore.Builder<N extends java.lang.Comparable<N>> |
May be a preferable way to build a sparse matrix if:
You don't know the number of nonzero elements in advance.
|
| SparseStore.Factory<N extends java.lang.Comparable<N>> |
|
| SparseTableau |
|
| SpecialOrderedSet |
|
| StandardType |
|
| StationaryIterativeSolver |
|
| StationaryNormalProcess |
Process with fixed mean and (possibly) fluctuating variance given by a ScedasticityModel. |
| Stopwatch |
This stopwatch is always running.
|
| Stopwatch.TimedResult<T> |
|
| StrategyBuildingFactory<N extends java.lang.Comparable<N>,I extends Access1D<N>,SB extends StrategyBuildingFactory<N,I,SB>> |
|
| StringContext |
StringContext
|
| StringFormat |
|
| Structure1D |
A (fixed size) 1-dimensional data structure.
|
| Structure1D.BasicMapper<T> |
|
| Structure1D.IndexMapper<T> |
|
| Structure1D.IntIndex |
|
| Structure1D.Logical<S extends Structure1D,B extends Structure1D.Logical<S,B>> |
|
| Structure1D.LongIndex |
|
| Structure1D.LoopCallback |
|
| Structure2D |
A (fixed size) 2-dimensional data structure.
|
| Structure2D.IntRowColumn |
|
| Structure2D.Logical<S extends Structure2D,B extends Structure2D.Logical<S,B>> |
|
| Structure2D.LongRowColumn |
|
| Structure2D.ReducibleTo1D<R extends Structure1D> |
|
| Structure2D.Reshapable |
|
| Structure2D.RowColumnKey<R,C> |
|
| Structure2D.RowColumnMapper<R,C> |
|
| StructureAnyD |
A (fixed size) any-dimensional data structure.
|
| StructureAnyD.IntReference |
|
| StructureAnyD.Logical<S extends StructureAnyD,B extends StructureAnyD.Logical<S,B>> |
|
| StructureAnyD.LongReference |
|
| StructureAnyD.ReducibleTo1D<R extends Structure1D> |
|
| StructureAnyD.ReducibleTo2D<R extends Structure2D> |
|
| StructureAnyD.ReferenceCallback |
|
| StructureAnyD.ReferenceMapper |
|
| StructureAnyD.Reshapable |
|
| Subregion2D<N extends java.lang.Comparable<N>> |
|
| Subregion2D.ColumnsRegion<N extends java.lang.Comparable<N>> |
|
| Subregion2D.LimitRegion<N extends java.lang.Comparable<N>> |
|
| Subregion2D.OffsetRegion<N extends java.lang.Comparable<N>> |
|
| Subregion2D.RowsRegion<N extends java.lang.Comparable<N>> |
|
| Subregion2D.SynchronizedRegion<N extends java.lang.Comparable<N>> |
|
| Subregion2D.TransposedRegion<N extends java.lang.Comparable<N>> |
|
| Subregion2D.WrapperRegion<N extends java.lang.Comparable<N>> |
|
| SubstituteBackwards |
|
| SubstituteForwards |
|
| SuperimposedStore<N extends java.lang.Comparable<N>> |
SuperimposedStore
|
| SupplierIterator<T> |
|
| SWAP |
Given two vectors x and y, the ?swap routines return vectors y and x swapped, each replacing the other.
|
| TableauCutGenerator |
|
| TDistribution |
|
| TDistribution.Degree1 |
|
| TDistribution.Degree2 |
|
| TDistribution.Degree3 |
|
| TDistribution.Degree4 |
|
| TDistribution.Degree5 |
|
| TDistribution.DegreeInfinity |
|
| TemporalContext<T extends java.time.temporal.Temporal> |
An implementation of TypeContext that is implemented in terms of DateTimeFormatter and
TemporalAdjuster. |
| Tensor<N extends java.lang.Comparable<N>,T extends Tensor<N,T>> |
An n:th-rank tensor in m-dimensional space is a mathematical object that has n indices and m^n components
and obeys certain transformation rules.
|
| TensorFactory1D<N extends java.lang.Comparable<N>,T extends Mutate1D> |
|
| TensorFactory2D<N extends java.lang.Comparable<N>,T extends Mutate2D> |
|
| TensorFactoryAnyD<N extends java.lang.Comparable<N>,T extends MutateAnyD> |
|
| TextLineInterpreter<T> |
|
| TextLineReader |
|
| TextLineReader.Parser<T> |
|
| TextLineWriter |
|
| TextLineWriter.CSVLineBuilder |
A reusable delimited "text line" builder.
|
| TextLineWriter.Formatter<T> |
|
| Throughput |
|
| ThroughputMBean |
|
| TimeIndex<T extends java.lang.Comparable<? super T>> |
|
| ToFileWriter<T> |
|
| ToFileWriter.Builder |
|
| TrainingConfiguration |
|
| TransformableRegion<N extends java.lang.Comparable<N>> |
A transformable 2D (sub)region.
|
| TransformableRegion.FillByMultiplying<N extends java.lang.Comparable<N>> |
|
| Transformation1D<N extends java.lang.Comparable<N>> |
Represents an in-place transformation of a 1D data structure – the transformable is mutated.
|
| Transformation2D<N extends java.lang.Comparable<N>> |
Represents an in-place transformation of a 2D data structure – the transformable is mutated.
|
| TransformationAnyD<N extends java.lang.Comparable<N>> |
Represents an in-place transformation of a AnyD data structure – the transformable is mutated.
|
| TransformationFormat<N extends java.lang.Number & java.lang.Comparable<N>> |
|
| TransjugatedStore<N extends java.lang.Comparable<N>> |
|
| TransposedStore<N extends java.lang.Comparable<N>> |
|
| TreeSeries<K extends java.lang.Comparable<? super K>,V extends java.lang.Comparable<V>,I extends TreeSeries<K,V,I>> |
|
| Tridiagonal<N extends java.lang.Comparable<N>> |
Tridiagonal: [A] = [Q][D][Q]H Any square symmetric (hermitian) matrix [A] can be factorized by
similarity transformations into the form, [A]=[Q][D][Q]-1 where [Q] is an orthogonal (unitary)
matrix and [D] is a real symmetric tridiagonal matrix.
|
| Tridiagonal.Factory<N extends java.lang.Comparable<N>> |
|
| TridiagonalDecomposition<N extends java.lang.Comparable<N>> |
|
| TwoStepMapper<T,R> |
|
| TwoStepMapper.Combineable<T,R,A extends TwoStepMapper.Combineable<T,R,A>> |
Enables combining the state of multiple instances.
|
| TwoStepMapper.KeyCounter<T,G> |
A frequency counter that optionally filters some elements when merging subresults.
|
| TwoStepMapper.Mergeable<T,R> |
Enables merging the results from multiple instances.
|
| TwoStepMapper.SimpleCache<K,V> |
Will calculate the function value for each input item, and cache the result.
|
| TypeCache<T> |
|
| TypeContext<T> |
A type context provides two basic services:
It enforces some sort of rule/limit regarding size, accuracy or similar.
|
| TypeParser |
|
| TypeUtils |
|
| UnaryFunction<N extends java.lang.Comparable<N>> |
|
| UnaryFunctionSeries |
|
| UnaryOperatoStore<N extends java.lang.Comparable<N>> |
|
| UnconstrainedSolver |
Solves optimisation problems of the form:
|
| Uniform |
Certain waiting times.
|
| UpdatableSolver |
|
| UpperHessenbergStore<N extends java.lang.Comparable<N>> |
A Hessenberg matrix is one that is "almost" triangular.
|
| UpperSymmetricStore<N extends java.lang.Comparable<N>> |
|
| UpperTriangularStore<N extends java.lang.Comparable<N>> |
|
| Variable |
Variable
|
| VectorSpace<T,N extends java.lang.Comparable<N>> |
A vector space is a set of objects called vectors, where a vector is a tuple of fields/scalars/numbers.
|
| VectorTensor<N extends java.lang.Comparable<N>> |
|
| VectorTensor.Factory<N extends java.lang.Comparable<N>> |
|
| VirtualMachine |
|
| VisitAll |
|
| VoidFunction<N extends java.lang.Comparable<N>> |
|
| Weibull |
Useful as length of life distribution in reliability theory.
|
| WienerProcess |
|
| WrappedANN |
|
| WrapperStore<N extends java.lang.Comparable<N>> |
|
| YahooParser |
|
| YahooParser.Data |
|
| YahooSession |
Deprecated. |
| YahooSession.Fetcher |
|
| YahooSessionOld |
Deprecated. |
| YahooSessionOld.Fetcher |
Deprecated. |
| ZeroStore<N extends java.lang.Comparable<N>> |
ZeroStore
|
| ZTransform |
This class implements the Z-transform for a given complex number z.
|
| ZTransform.ZOperator |
|