Examples of org.apache.commons.math3.ode.sampling.StepNormalizer

Package org.apache.commons.math3.ode.sampling

Examples of org.apache.commons.math3.ode.sampling.StepNormalizer

org.apache.commons.math3.exception.MathIllegalArgumentException

This class wraps an object implementing {@link FixedStepHandler}into a {@link StepHandler}.

This wrapper allows to use fixed step handlers with general integrators which cannot guaranty their integration steps will remain constant and therefore only accept general step handlers.

The stepsize used is selected at construction time. The {@link FixedStepHandler#handleStep handleStep} method of the underlying{@link FixedStepHandler} object is called at normalized times. Thenormalized times can be influenced by the {@link StepNormalizerMode} and{@link StepNormalizerBounds}.

There is no constraint on the integrator, it can use any time step it needs (time steps longer or shorter than the fixed time step and non-integer ratios are all allowed).

Examples (step size = 0.5)
Start time	End time	Direction	{@link StepNormalizerMode Mode}	{@link StepNormalizerBounds Bounds}	Output
0.3	3.1	forward	{@link StepNormalizerMode#INCREMENT INCREMENT}	{@link StepNormalizerBounds#NEITHER NEITHER}	0.8, 1.3, 1.8, 2.3, 2.8
0.3	3.1	forward	{@link StepNormalizerMode#INCREMENT INCREMENT}	{@link StepNormalizerBounds#FIRST FIRST}	0.3, 0.8, 1.3, 1.8, 2.3, 2.8
0.3	3.1	forward	{@link StepNormalizerMode#INCREMENT INCREMENT}	{@link StepNormalizerBounds#LAST LAST}	0.8, 1.3, 1.8, 2.3, 2.8, 3.1
0.3	3.1	forward	{@link StepNormalizerMode#INCREMENT INCREMENT}	{@link StepNormalizerBounds#BOTH BOTH}	0.3, 0.8, 1.3, 1.8, 2.3, 2.8, 3.1
0.3	3.1	forward	{@link StepNormalizerMode#MULTIPLES MULTIPLES}	{@link StepNormalizerBounds#NEITHER NEITHER}	0.5, 1.0, 1.5, 2.0, 2.5, 3.0
0.3	3.1	forward	{@link StepNormalizerMode#MULTIPLES MULTIPLES}	{@link StepNormalizerBounds#FIRST FIRST}	0.3, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0
0.3	3.1	forward	{@link StepNormalizerMode#MULTIPLES MULTIPLES}	{@link StepNormalizerBounds#LAST LAST}	0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.1
0.3	3.1	forward	{@link StepNormalizerMode#MULTIPLES MULTIPLES}	{@link StepNormalizerBounds#BOTH BOTH}	0.3, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.1
0.0	3.0	forward	{@link StepNormalizerMode#INCREMENT INCREMENT}	{@link StepNormalizerBounds#NEITHER NEITHER}	0.5, 1.0, 1.5, 2.0, 2.5, 3.0
0.0	3.0	forward	{@link StepNormalizerMode#INCREMENT INCREMENT}	{@link StepNormalizerBounds#FIRST FIRST}	0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0
0.0	3.0	forward	{@link StepNormalizerMode#INCREMENT INCREMENT}	{@link StepNormalizerBounds#LAST LAST}	0.5, 1.0, 1.5, 2.0, 2.5, 3.0
0.0	3.0	forward	{@link StepNormalizerMode#INCREMENT INCREMENT}	{@link StepNormalizerBounds#BOTH BOTH}	0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0
0.0	3.0	forward	{@link StepNormalizerMode#MULTIPLES MULTIPLES}	{@link StepNormalizerBounds#NEITHER NEITHER}	0.5, 1.0, 1.5, 2.0, 2.5, 3.0
0.0	3.0	forward	{@link StepNormalizerMode#MULTIPLES MULTIPLES}	{@link StepNormalizerBounds#FIRST FIRST}	0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0
0.0	3.0	forward	{@link StepNormalizerMode#MULTIPLES MULTIPLES}	{@link StepNormalizerBounds#LAST LAST}	0.5, 1.0, 1.5, 2.0, 2.5, 3.0
0.0	3.0	forward	{@link StepNormalizerMode#MULTIPLES MULTIPLES}	{@link StepNormalizerBounds#BOTH BOTH}	0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0
3.1	0.3	backward	{@link StepNormalizerMode#INCREMENT INCREMENT}	{@link StepNormalizerBounds#NEITHER NEITHER}	2.6, 2.1, 1.6, 1.1, 0.6
3.1	0.3	backward	{@link StepNormalizerMode#INCREMENT INCREMENT}	{@link StepNormalizerBounds#FIRST FIRST}	3.1, 2.6, 2.1, 1.6, 1.1, 0.6
3.1	0.3	backward	{@link StepNormalizerMode#INCREMENT INCREMENT}	{@link StepNormalizerBounds#LAST LAST}	2.6, 2.1, 1.6, 1.1, 0.6, 0.3
3.1	0.3	backward	{@link StepNormalizerMode#INCREMENT INCREMENT}	{@link StepNormalizerBounds#BOTH BOTH}	3.1, 2.6, 2.1, 1.6, 1.1, 0.6, 0.3
3.1	0.3	backward	{@link StepNormalizerMode#MULTIPLES MULTIPLES}	{@link StepNormalizerBounds#NEITHER NEITHER}	3.0, 2.5, 2.0, 1.5, 1.0, 0.5
3.1	0.3	backward	{@link StepNormalizerMode#MULTIPLES MULTIPLES}	{@link StepNormalizerBounds#FIRST FIRST}	3.1, 3.0, 2.5, 2.0, 1.5, 1.0, 0.5
3.1	0.3	backward	{@link StepNormalizerMode#MULTIPLES MULTIPLES}	{@link StepNormalizerBounds#LAST LAST}	3.0, 2.5, 2.0, 1.5, 1.0, 0.5, 0.3
3.1	0.3	backward	{@link StepNormalizerMode#MULTIPLES MULTIPLES}	{@link StepNormalizerBounds#BOTH BOTH}	3.1, 3.0, 2.5, 2.0, 1.5, 1.0, 0.5, 0.3
3.0	0.0	backward	{@link StepNormalizerMode#INCREMENT INCREMENT}	{@link StepNormalizerBounds#NEITHER NEITHER}	2.5, 2.0, 1.5, 1.0, 0.5, 0.0
3.0	0.0	backward	{@link StepNormalizerMode#INCREMENT INCREMENT}	{@link StepNormalizerBounds#FIRST FIRST}	3.0, 2.5, 2.0, 1.5, 1.0, 0.5, 0.0
3.0	0.0	backward	{@link StepNormalizerMode#INCREMENT INCREMENT}	{@link StepNormalizerBounds#LAST LAST}	2.5, 2.0, 1.5, 1.0, 0.5, 0.0
3.0	0.0	backward	{@link StepNormalizerMode#INCREMENT INCREMENT}	{@link StepNormalizerBounds#BOTH BOTH}	3.0, 2.5, 2.0, 1.5, 1.0, 0.5, 0.0
3.0	0.0	backward	{@link StepNormalizerMode#MULTIPLES MULTIPLES}	{@link StepNormalizerBounds#NEITHER NEITHER}	2.5, 2.0, 1.5, 1.0, 0.5, 0.0
3.0	0.0	backward	{@link StepNormalizerMode#MULTIPLES MULTIPLES}	{@link StepNormalizerBounds#FIRST FIRST}	3.0, 2.5, 2.0, 1.5, 1.0, 0.5, 0.0
3.0	0.0	backward	{@link StepNormalizerMode#MULTIPLES MULTIPLES}	{@link StepNormalizerBounds#LAST LAST}	2.5, 2.0, 1.5, 1.0, 0.5, 0.0
3.0	0.0	backward	{@link StepNormalizerMode#MULTIPLES MULTIPLES}	{@link StepNormalizerBounds#BOTH BOTH}	3.0, 2.5, 2.0, 1.5, 1.0, 0.5, 0.0

@see StepHandler @see FixedStepHandler @see StepNormalizerMode @see StepNormalizerBounds @since 1.2

     */
    public double correlation(final double[] xArray, final double[] yArray)
            throws DimensionMismatchException {


        if (xArray.length != yArray.length) {
            throw new DimensionMismatchException(xArray.length, yArray.length);
        }


        final int n = xArray.length;
        final long numPairs = sum(n - 1);

View Full Code Here

     * @throws DimensionMismatchException if {@link #target} and
     * {@link #weightMatrix} have inconsistent dimensions.
     */
    private void checkParameters() {
        if (target.length != weightMatrix.getColumnDimension()) {
            throw new DimensionMismatchException(target.length,
                                                 weightMatrix.getColumnDimension());
        }
    }

View Full Code Here

    public void increment(final double[] data)
        throws DimensionMismatchException {


        int length = data.length;
        if (length != dimension) {
            throw new DimensionMismatchException(length, dimension);
        }


        // only update the upper triangular part of the covariance matrix
        // as only these parts are actually stored
        for (int i = 0; i < length; i++){

View Full Code Here

     * @throws DimensionMismatchException if the dimension of sc does not match this
     * @since 3.3
     */
    public void append(StorelessCovariance sc) throws DimensionMismatchException {
        if (sc.dimension != dimension) {
            throw new DimensionMismatchException(sc.dimension, dimension);
        }


        // only update the upper triangular part of the covariance matrix
        // as only these parts are actually stored
        for (int i = 0; i < dimension; i++) {

View Full Code Here

            if (m.getColumnDimension() != m.getRowDimension()) {
                throw new NonSquareOperatorException(m.getColumnDimension(),
                                                     m.getRowDimension());
            }
            if (m.getRowDimension() != a.getRowDimension()) {
                throw new DimensionMismatchException(m.getRowDimension(),
                                                     a.getRowDimension());
            }
        }
    }

View Full Code Here

     * length.
     */
    protected double[] computeResiduals(double[] objectiveValue) {
        final double[] target = getTarget();
        if (objectiveValue.length != target.length) {
            throw new DimensionMismatchException(target.length,
                                                 objectiveValue.length);
        }


        final double[] residuals = new double[target.length];
        for (int i = 0; i < target.length; i++) {

View Full Code Here

   */
  public Rotation(Vector3D u, Vector3D v) throws MathArithmeticException {


    double normProduct = u.getNorm() * v.getNorm();
    if (normProduct == 0) {
        throw new MathArithmeticException(LocalizedFormats.ZERO_NORM_FOR_ROTATION_DEFINING_VECTOR);
    }


    double dot = u.dotProduct(v);


    if (dot < ((2.0e-15 - 1.0) * normProduct)) {

View Full Code Here

     * @return the smallest prime greater than or equal to n.
     * @throws MathIllegalArgumentException if n &lt; 0.
     */
    public static int nextPrime(int n) {
        if (n < 0) {
            throw new MathIllegalArgumentException(LocalizedFormats.NUMBER_TOO_SMALL, n, 0);
        }
        if (n == 2) {
            return 2;
        }
        n |= 1;//make sure n is odd

View Full Code Here

     * @throws MathIllegalArgumentException if n &lt; 2.
     */
    public static List<Integer> primeFactors(int n) {


        if (n < 2) {
            throw new MathIllegalArgumentException(LocalizedFormats.NUMBER_TOO_SMALL, n, 2);
        }
        // slower than trial div unless we do an awful lot of computation
        // (then it finally gets JIT-compiled efficiently
        // List<Integer> out = PollardRho.primeFactors(n);
        return SmallPrimes.trialDivision(n);

View Full Code Here

   */
  public Rotation(Vector3D axis, double angle) throws MathIllegalArgumentException {


    double norm = axis.getNorm();
    if (norm == 0) {
      throw new MathIllegalArgumentException(LocalizedFormats.ZERO_NORM_FOR_ROTATION_AXIS);
    }


    double halfAngle = -0.5 * angle;
    double coeff = FastMath.sin(halfAngle) / norm;

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.apache.commons.math3.ode.sampling.StepNormalizer

org.apache.commons.math3.analysis.differentiation.DerivativeStructure

org.apache.commons.math3.analysis.differentiation.MultivariateDifferentiableVectorFunction

org.apache.commons.math3.analysis.function.HarmonicOscillator

org.apache.commons.math3.analysis.function.Sin

org.apache.commons.math3.analysis.function.Sinc

org.apache.commons.math3.analysis.MultivariateFunction

org.apache.commons.math3.analysis.QuinticFunction

org.apache.commons.math3.analysis.solvers.BrentSolver

org.apache.commons.math3.analysis.UnivariateFunction

org.apache.commons.math3.complex.Complex

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.