Type: Java Math Library | Status: Continuous Research (Sawdust alert!)

A "slow-burning" Java experimental library for mathematical modelling. It is not designed for performance, but rather to represent abstract mathematical structures and use them to perform symbolic and numerical calculations, making it possible to handle symbolic polynomial arithmetic, solve differential equations or simulate quantum mechanics problems.

net.gommagomma.smfn/
|-- math/
|   |-- algebra/
|   |   |-- core/                           (AlgebraicElement, AlgebraicStructure, Commutative, NumericFactory, MathFunction, Mapping, FunctionElement)
|   |   |   |-- algorithms                  (AlgebraicAlgorithms)
|   |   |   |-- elements/                   (...)
|   |   |   |   |-- additive/               (...)
|   |   |   |   |-- multiplicative/         (...)
|   |   |   |   |-- tensors/                (TensorElement)
|   |   |   |   \-- capabilities/           (Absolutable,Exponentiable,Normable,Sqrtable,Orderable)
|   |   |   |-- structures/                 (AdditiveMonoid,MultiplicativeMonoid,ComutativeMultiplicativeMonoid,Semiring,Ring,CommutativeRing,Group, AbelianGroup,Field)
|   |   |-- numeric/                        (Natural, Signedint, ZnElement, Rational, Real, Complex)
|   |   |-- polynomial/
|   |   \-- structures/                     (NaturalSemiring, IntegerRing, ZnRing, RationalField, RealField, ComplexField, PolynomialRing)
|   |-- linearalgebra                       # Vettori, Matrici e Spazi
|   |   |-- core                   		  # Interfacce per Vettori, Matrici, Spazi
|   |   |   |-- elements/                   (...)
|   |   |   \-- structures/                 (...)
|   |   |-- complex                         # Implementazioni per C (ComplexVector, ComplexMatrix, relativi spaces)
|   |   |-- natural                         # Implementazioni per N (NaturalVector, NaturalMatrix, relativi spaces)
|   |   |-- rational                        # Implementazioni per Q (RationalVector, RationalMatrix, relativi spaces)
|   |   |-- real                            # Implementazioni per R (RealVector, RealMatrix, relativi spaces)
|   |   \-- signedint                       # Implementazioni per Z (SignedIntVector, SignedIntMatrix, relativi spaces)
|   |-- geometry/								  # (GeometryEntity, Point, Circle, Ellipse)
|   |-- analysis/                           # Calcolo (Funzioni, Derivate, Integrali, Risolutori Numerici)
|   |   |-- core								  # core interface per functionals, operators, problems, solvers
|   |   |-- functions/						  # LinearFunction ...
|   |   |-- fractals/                       # Contiene implementazioni specifiche di frattali (Mandelbrot, Julia, ...)
|   |   |-- numerical/                      # Contiene implementazioni di metodi numerici
|   |   |   |-- functionals/                # Contiene le implementazioni per il calcolo differenziale/integrale
|   |   |   |-- solvers.ode/                # Contiene le implementazioni per la risoluzione delle ODE
|   |   |   |-- solvers.root/               # Contiene le implementazioni per la ricerca delle roots
|   |   |   \-- ode/                        # Contiene le implementazioni per la risoluzione delle ODE
|   |   \-- integral/                       # (es. Metodi di quadratura numerica)
|   |-- utils                               # Utility e Costanti (MathConstants, MathUtils)
|-- graphics/                               # Logica specifica per la viewport e il rendering
|   |-- core/                               # Interfacce grafiche (Renderer, Viewport, ColorMapper, VieportController)
|   |-- swing/                              # impl (SwingRenderer1D, Swingrnderer2D)
|   \-- plotting/                           # (FunctionPlotter, CartesianAxisPlotter, ScatterPlotter)
|-- physics                                 # Package per le applicazioni fisiche (Elettromagnetismo, MQ, RG)
|   |-- core/                               (Interfacce fisiche base: particella, forza...)
|   |-- mechanics/                          (Dinamica, gravità , cinematica)
|   |-- em                                  # Classi per campi E e B
|   |-- mq                                  # Classi per funzioni d'onda, operatori (HamiltonianOperator, Observable, ...)
|   |   |-- core								 # Observable
|   |   |-- operators/                      # Implementazioni di Posizione, Momento, Momento Angolare
|   |   |-- states/                         # StateVector (normalizzato), QuantumSystem
|   |   |-- dynamics/                       # TimeEvolutionOperator, SchrodingerSolver
|   |   |-- problems/                       # Esempi: ParticleInABox, HarmonicOscillator
|   |   \-- utils/                          # PhysicalConstants, Units
|   |-- relativity                          # Classi per metriche tensoriali

• interface Commutative {}
• interface AlgebraicElement<E extends AlgebraicElement> { boolean isMathematicallyEqualTo(E other); E copy();}
• interface AlgebraicStructure<E extends AlgebraicElement> { String getName(); boolean contains(E e); }
• interface NumericFactory<E extends SemiringElement> {E zero(); E one(); E of(double value); E of(long value); E of(int value);}
• interface Mapping<I, O> { O apply(I input); default Mapping<V, O> compose(Mapping<? super V, ? extends I> before) { Objects.requireNonNull(before); return (V v) -> apply(before.apply(v)); } static Mapping<T, T> identity() { return (T t) -> t; } }
• interface Morphism<I, O> extends Mapping<I, O> { O evaluate(I input); }

• AlgebraicAlgorithms { public static <E extends EuclideanDomainElement<E, N>, N extends ComparableElement> E gcd(E a, E b){} public static <E extends EuclideanDomainElement<E, N>, N extends ComparableElement> E lcm(E a, E b) {} }

• interface AdditiveMonoidElement<E extends AdditiveMonoidElement> extends AlgebraicElement { E add(E other); E getZero(); default boolean isZero() { return isMathematicallyEqualTo(getZero()); }}
• interface CommutativeMonoidElement<E extends CommutativeMonoidElement> extends AdditiveMonoidElement, Commutative {}
• interface GroupElement<E extends GroupElement> extends AdditiveMonoidElement {E negate(); default E subtract(E other) {return add(other.negate());}}
• interface AbelianGroupElement<E extends AbelianGroupElement> extends GroupElement, CommutativeMonoidElement {}

• interface MultiplicativeMonoidElement<E extends MultiplicativeMonoidElement> extends AlgebraicElement { E multiply(E other); E getOne(); default boolean isOne() { return isMathematicallyEqualTo(getOne()); }}
• interface CommutativeMultiplicativeMonoidElement<T extends CommutativeMultiplicativeMonoidElement> extends MultiplicativeMonoidElement, Commutative {}
• interface SemiringElement<E extends SemiringElement> extends CommutativeMonoidElement, MultiplicativeMonoidElement {}
• interface RingElement<E extends RingElement> extends SemiringElement, AbelianGroupElement {}
• interface CommutativeRingElement<E extends CommutativeRingElement> extends RingElement, CommutativeMultiplicativeMonoidElement {}
• interface FieldElement<E extends FieldElement> extends CommutativeRingElement, Scalable<E, E> {E inverse();default E divide(E other) { return multiply(other.inverse());} @Override default E scale(E scalar) { return this.multiply(scalar); }}
• interface EuclideanDomainElement<E extends EuclideanDomainElement<E, N>, N extends Orderable> extends CommutativeRingElement {N normValue(); E remainder(E divisor); E quotient(E divisor); default E mod(E divisor) { return remainder(divisor); }}

• interface TensorElement<K extends SemiringElement> {int rank(); int[] getShape(); long size(); K get(int... indices);}

• interface Orderable<E extends Orderable> extends AlgebraicElement, Comparable{ default boolean isLessThan(E other) { return compareTo(other) < 0; }default boolean isGreaterThan(E other) {return compareTo(other) > 0;} }
• interface Sqrtable<E extends Sqrtable> extends AlgebraicElement { E sqrt(); }
• interface Exponentiable<E extends Exponentiable> extends AlgebraicElement { E power(int exponent);}
• interface Normable<N extends FieldElement, E extends Normable<N, E>> extends AlgebraicElement {N norm();}
• interface Differentiable<T extends AlgebraicElement> { T derivative(); }
• interface Absolutable<E extends Absolutable> extends Orderable, AbelianGroupElement { default E abs() { return this.isLessThan(getZero()) ? this.negate() : (E) this;} default int signum() { if (this.isZero()) return 0; return this.isGreaterThan(getZero()) ? 1 : -1; }}
• interface LinearCombinable<K, E extends LinearCombinable<K, E>> extends Scalable<K, E>, AbelianGroupElement{ default E linearCombine(K a, E other, K b) { return this.scale(a).add(other.scale(b)); }}
• interface Scalable<K, E> { E scale(K scalar);}

• interface AdditiveMonoid<E extends AdditiveMonoidElement> extends AlgebraicStructure{ E additiveIdentity(); }}
• interface MultiplicativeMonoid<E extends MultiplicativeMonoidElement> extends AlgebraicStructure { E multiplicativeIdentity();}
• interface CommutativeMultiplicativeMonoid<E extends CommutativeMultiplicativeMonoidElement> extends MultiplicativeMonoid {}
• interface Group<E extends GroupElement> extends AdditiveMonoid {}
• interface AbelianGroup<E extends AbelianGroupElement> extends Group {}
• interface Semiring<E extends SemiringElement> extends AdditiveMonoid, MultiplicativeMonoid, NumericFactory{ default E zero() { return additiveIdentity(); } default E one() { return multiplicativeIdentity(); } }
• interface Ring<E extends RingElement> extends Semiring, AbelianGroup {}
• interface CommutativeRing<E extends CommutativeRingElement> extends Ring, CommutativeMultiplicativeMonoid {}
• interface EuclideanDomain<E extends EuclideanDomainElement<E, N>, N extends Orderable> extends CommutativeRing { E quotient(E a, E b); E remainder(E a, E b);}
• interface Field<E extends FieldElement> extends CommutativeRing {}

• interface HasScalarStructure<K extends SemiringElement>{ Semiring getScalarStructure();}

• final class Natural implements SemiringElement, Exponentiable, Orderable {}
• final class SignedInt implements CommutativeRingElement, Exponentiable, Absolutable, EuclideanDomainElement<SignedInt, Natural> { /* ... */ }
• final class Rational implements FieldElement, Normable<Real, Rational>, Exponentiable, Absolutable {}
• final class Real implements FieldElement, Normable<Real, Real>, Exponentiable, Sqrtable, Absolutable {}
• final class Complex implements FieldElement, Normable<Real, Complex>, Exponentiable, Sqrtable {}
• final class ZnElement implements CommutativeRingElement {}

• final class NaturalSemiring implements Semiring {}
• final class IntegerRing implements EuclideanDomain<SignedInt, Natural> {}
• final class RationalField implements Field {}
• final class RealField implements Field {}
• final class ComplexField implements Field {}
• final class ZnRing implements CommutativeRing {}

• abstract class AbstractPolynomial<K extends SemiringElement, P extends AbstractPolynomial<K, P>> implements SemiringElement

  , Morphism<K, K> {}

• abstract class AbstractRingPolynomial<K extends RingElement, P extends AbstractRingPolynomial<K, P>> extends AbstractPolynomial<K, P> implements RingElement

  {}

• final class SemiringPolynomial<K extends SemiringElement> extends AbstractPolynomial<K, SemiringPolynomial> {}

• final class GeneralPolynomial<K extends RingElement> extends AbstractRingPolynomial<K, GeneralPolynomial> {}

• final class CommutativePolynomial<K extends CommutativeRingElement> extends AbstractRingPolynomial<K, CommutativePolynomial> implements CommutativeRingElement<CommutativePolynomial> {}

• final class EuclideanPolynomial<K extends FieldElement> extends AbstractRingPolynomial<K, EuclideanPolynomial> implements EuclideanDomainElement<EuclideanPolynomial, Natural> {}

• final class PolynomialQuotientRemainder<K extends SemiringElement, P extends AbstractPolynomial<K, P>> {}

• final class Polynomials {}

• abstract class AbstractPolynomialRing<K extends SemiringElement, P extends AbstractPolynomial<K, P>> implements HasScalarStructure {}

• public final class SemiringPolynomialRing<K extends SemiringElement> extends AbstractPolynomialRing<K, SemiringPolynomial> implements Semiring<SemiringPolynomial> {}

• final class GeneralPolynomialRing<K extends RingElement> extends AbstractPolynomialRing<K, GeneralPolynomial> implements Ring<GeneralPolynomial> {}

• final class CommutativePolynomialRing<K extends CommutativeRingElement> extends AbstractPolynomialRing<K, CommutativePolynomial> implements CommutativeRing<CommutativePolynomial> {}

• final class EuclideanPolynomialRing<K extends FieldElement> extends AbstractPolynomialRing<K, EuclideanPolynomial> implements EuclideanDomain<EuclideanPolynomial, Natural> {}

• interface SpaceElement<V extends SpaceElement> extends AlgebraicElement{}
• interface SemimoduleElement<K extends SemiringElement, V extends SemimoduleElement<K, V>> extends SpaceElement, CommutativeMonoidElement, Scalable<K, V>, TensorElement {int dimension(); K get(int index); int dimension();}
• interface ModuleElement<K extends RingElement, V extends ModuleElement<K, V>> extends SemimoduleElement<K, V>, LinearCombinable<K, V> {}
• interface VectorElement<K extends FieldElement, V extends VectorElement<K, V>> extends ModuleElement<K, V> {}
• interface NormedVectorElement<K extends FieldElement & NormableElement<Real, K>, V extends NormedVectorElement<K, V>> extends VectorElement<K, V>, NormableElement<Real, V>{ default Real distanceTo(V other) {}}
• interface InnerProductSpaceElement<K extends FieldElement & NormableElement<Real, K>, V extends InnerProductSpaceElement<K, V>> extends NormedVectorElement<K, V> {K dotProduct(V other);}
• public abstract class AbstractRank1Tensor<K extends SemiringElement, V extends SemimoduleElement<K, V>> implements SemimoduleElement<K, V> {}

• interface SemiringMatrixElement<K extends SemiringElement,V extends SemimoduleElement<K, V>, M extends SemiringMatrixElement<K, V, M>> extends SemiringElement, LinearMapping<K, V, M>, Scalable<K, M> { int getRows(); int getColumns(); K get(int row, int col); V getRowVector(int row); V getColumnVector(int col); M multiply(M other); V multiply(V vector);M transpose();}
• interface RingMatrixElement<K extends RingElement, V extends ModuleElement<K, V>, M extends RingMatrixElement<K, V, M>> extends SemiringMatrixElement<K, V, M>, RingElement {}
• interface FieldMatrixElement<K extends FieldElement, V extends VectorElement<K, V>, M extends FieldMatrixElement<K, V, M>> extends RingMatrixElement<K, V, M>, LinearOperator<K, V, M> { K determinant(); M inverse(); }
• abstract class AbstractSemiringMatrix<K extends SemiringElement, V extends SemimoduleElement<K, V>, M extends SemiringMatrixElement<K, V, M>, S extends SemiringMatrixSemimodule<K, V, M>> implements SemiringMatrixElement<K, V, M>, TensorElement { protected final K[][] data; protected final int rows; protected final int cols; protected final S structure;}
• abstract class AbstractRingMatrix<K extends RingElement, V extends ModuleElement<K, V>, M extends RingMatrixElement<K, V, M>, S extends RingMatrixModule<K, V, M>> extends AbstractSemiringMatrix<K, V, M, S> implements RingMatrixElement<K, V, M> {}
• abstract class AbstractFieldMatrix<K extends FieldElement, V extends VectorElement<K, V>, M extends FieldMatrixElement<K, V, M>, S extends FieldMatrixSpace<K, V, M>> extends AbstractRingMatrix<K, V, M, S> implements FieldMatrixElement<K, V, M> {}

• interface VectorElementFactory<K extends SemiringElement, V extends SemimoduleElement<K, V>>{ V createVector(K[] data); V createVector(double[] data); V createVector(long[] data); V createVector(int[] data); V createZeroVector(int dimension);}
• interface MatrixElementFactory<K extends SemiringElement, V extends SemimoduleElement<K, V>, M extends SemiringMatrixElement<K, V, M>>{ M createMatrix(K[][] data); M createMatrix(double[][] data);M createMatrix(long[][] data); M createMatrix(int[][] data); M createZeroMatrix(int rows, int cols);}

• interface LinearSpace<K extends SemiringElement, V extends AlgebraicElement> extends AlgebraicStructure { Semiring getScalarStructure(); }

• interface MetricSpace<T extends AlgebraicElement> extends LinearSpace {Real distance(T point1, T point2);}

• interface Semimodule<K extends SemiringElement, V extends SemimoduleElement<K, V>> extends LinearSpace, VectorElementFactory<K, V> {}

• interface Module<K extends RingElement, V extends ModuleElement<K, V>> extends Semimodule<K, V> {Ring getScalarStructure(); }

• interface VectorSpace<K extends FieldElement, V extends VectorElement<K, V>> extends Module<K, V> {Field getScalarStructure();}

• class RealMetricSpace implements MetricSpace<Real, Real> {}

• interface InnerProductSpace<K extends FieldElement & Normable<Real, K>, V extends InnerProductSpaceElement<K, V>> extends VectorSpace<K, V>, MetricSpace {default K innerProduct(V v1, V v2) {return v1.dotProduct(v2);} @Override default Real distance(V point1, V point2) { return point1.distanceTo(point2); }}

• interface HilbertSpace<K extends FieldElement & Normable<Real, K>, V extends InnerProductSpaceElement<K, V>> extends InnerProductSpace<K, V> {}

• interface SemiringMatrixSemimodule<K extends SemiringElement, V extends SemimoduleElement<K, V>, M extends SemiringMatrixElement<K, V, M>> extends LinearSpace, SemiringMatrixFactory<K, V, M>, DimensionalStructure<SemiringMatrixSemimodule<K, V, M>> {Semiring getScalarStructure(); Semimodule<K, V> getVectorStructure(); int getMatrixRows(); int getMatrixColumns();}

• interface RingMatrixModule<K extends RingElement, V extends ModuleElement<K, V>, M extends RingMatrixElement<K, V, M>> extends SemiringMatrixSemimodule<K, V, M> { @Override Ring getScalarStructure(); @Override Module<K, V> getVectorStructure();}

• interface FieldMatrixSpace<K extends FieldElement, V extends VectorElement<K, V>, M extends FieldMatrixElement<K, V, M>> extends RingMatrixModule<K, V, M> {@Override Field getScalarStructure(); @Override VectorSpace<K, V> getVectorStructure();}

• interface DimensionalStructure<S extends AlgebraicStructure<?>> {S getSpaceOfDimensions(int rows, int cols);}

• interface LinearMapping<K, V, M extends LinearMapping<K, V, M>> extends Scalable<K, M>, Morphism<V, V> { default V transform(V vector) { return apply(vector); }}
• interface LinearMorphism<K extends SemiringElement, V extends Scalable<K, V> & CommutativeMonoidElement> extends Morphism<V, V>, CommutativeMonoidElement<LinearMorphism<K, V>>, Scalable<K, LinearMorphism<K, V>> { }
• interface LinearOperator<K extends FieldElement, V extends LinearCombinable<K, V>, O extends LinearOperator<K, V, O>> extends LinearMapping<K, V, O>, LinearCombinable<K, O> {@Override default V evaluate(V vector) { return apply(vector); }}
• interface HermitianMapping<K extends FieldElement, V extends LinearCombinable<K, V>, H extends HermitianMapping<K, V, H>> extends LinearMapping<K, V, H> {Real expectationValue(V state);}
• interface HermitianOperator<K extends FieldElement, V extends LinearCombinable<K, V>, O extends HermitianOperator<K, V, O>> extends LinearOperator<K, V, O>, HermitianMapping<K, V, O> {}

• final class NaturalVector extends AbstractRank1Tensor<Natural, NaturalVector> { //... }
• final class NaturalSemimodule implements Semimodule<Natural, NaturalVector> {}
• final class NaturalMatrix extends AbstractSemiringMatrix<Natural, NaturalVector, NaturalMatrix, NaturalMatrixSemimodule> {}
• final class NaturalMatrixSemimodule implements SemiringMatrixSemimodule<Natural, NaturalVector, NaturalMatrix> {}

###net.gommagomma.smfn.math.linearalgebra.signedint:

• final class SignedIntVector extends AbstractRank1Tensor<SignedInt, SignedIntVector> implements ModuleElement<SignedInt, SignedIntVector> {//...}
• final class SignedIntModule implements Module<SignedInt, SignedIntVector> {}
• final class SignedIntMatrix extends AbstractRingMatrix<SignedInt, SignedIntVector, SignedIntMatrix, SignedIntMatrixModule> {}
• final class SignedIntMatrixModule implements RingMatrixModule<SignedInt, SignedIntVector, SignedIntMatrix> {}

• final class RealVector extends AbstractRank1Tensor<Real, RealVector> implements InnerProductSpaceElement<Real, RealVector> {//...}
• final class RealVectorSpace implements HilbertSpace<Real, RealVector> {//...}
• final class RealMatrix extends AbstractFieldMatrix<Real, RealVector, RealMatrix, RealMatrixSpace> {//...}
• final class RealMatrixSpace implements FieldMatrixSpace<Real, RealVector, RealMatrix> {//...}

• final class ComplexVector extends AbstractRank1Tensor<Complex, ComplexVector> implements InnerProductSpaceElement<Complex, ComplexVector> { //... }
• final class ComplexVectorSpace implements HilbertSpace<Complex, ComplexVector> {//...}
• final class ComplexMatrix extends AbstractFieldMatrix<Complex, ComplexVector, ComplexMatrix, ComplexMatrixSpace> {}
• final class ComplexMatrixSpace implements FieldMatrixSpace<Complex, ComplexVector, ComplexMatrix> {//...}

• final class RationalVector extends AbstractRank1Tensor<Rational, RationalVector> implements InnerProductSpaceElement<Rational, RationalVector> { /... }
• final class RationalVectorSpace implements VectorSpace<Rational, RationalVector> {//...}
• final class RationalMatrix implements AbstractFieldMatrix<Rational, RationalVector, RationalMatrix, RationalMatrixSpace> {//...}
• final class RationalMatrixSpace implements FieldMatrixSpace<Rational, RationalVector, RationalMatrix> {//...}

• interface GeometryEntity<D extends AlgebraicElement, C extends AlgebraicElement> extends Morphism<D, C> {int getAmbientDimension();}
• class Point implements AlgebraicElement {}
• class Circle implements GeometryEntity<RealVector, Real> {}
• class Ellipse implements GeometryEntity<RealVector, Real> {}

• interface Functional<K extends FieldElement, D extends AlgebraicElement, C> { K evaluate(Mapping<D, K> f, C context); }

• interface SymbolicOperator<F extends Mapping, R extends Mapping> extends Operator<F, R> {}
• interface DifferentialOperator<F extends Mapping, R extends Mapping> extends SymbolicOperator<F, R> {}
• interface IntegralOperator<F extends Mapping, R extends Mapping> extends SymbolicOperator<F, R> {}

• interface AnalysisProblem<P extends AlgebraicElement

  > {}

• interface DifferentialEquationProblem<K extends FieldElement, V extends VectorElement<K, V>> extends AnalysisProblem { V derivative(V currentState, Real currentTime); }
• interface InitialValueProblem<K extends FieldElement, V extends VectorElement<K, V>> extends DifferentialEquationProblem<K, V> { V getInitialState(); Real getStartTime(); }
• interface BoundaryValueProblem<K extends FieldElement, V extends VectorElement<K, V>> extends DifferentialEquationProblem<K, V> { K getEndTime(); V getBoundaryConditionAtStart(); V getBoundaryConditionAtEnd(); }
• interface FixedPointProblem<T extends AlgebraicElement> extends AnalysisProblem { T nextIteration(T current); }
• interface ScalarRootFindingProblem<T extends FieldElement> extends AnalysisProblem { Mapping<T, T> getFunction(); }
• interface RootFindingProblem<K extends FieldElement, V extends VectorElement<K, V>> extends AnalysisProblem { Mapping<V, V> getFunction(); }

• interface Solver<P, R> {}
• interface IterativeSolver<P, S extends AlgebraicElement, R extends AlgebraicElement> extends Solver<P, R> { R solve(P problem, S initialState, ConvergenceCriteria criteria, ConvergenceParameters params, MetricSpace space); }
• interface IntervalSolver<K extends FieldElement, R extends VectorElement<K, R>> extends Solver<InitialValueProblem<K, R>, R> { R integrate(InitialValueProblem<K, R> problem, Real endTime, IntegrationParameters params); }
• interface IntervalODEStepSolver<K extends FieldElement, T extends VectorElement<K, T>> extends IntervalSolver<K, T> { T step(DifferentialEquationProblem<K, T> system, T currentState, Real currentTime, Real deltaTime); }
• interface ConvergenceCriteria { boolean isConverged(Real distance, ConvergenceParameters params, int iteration); }
• final class ConvergenceParameters { public final Real tolerance; public final int maxIterations; }
• final class IntegrationParameters { public final Real fixedStepSize; public final Real tolerance; public final Real maxStepSize; public final Real minStepSize; }