The following document contains the results of PMD's CPD 6.8.0.

Duplications

File Line
org/hipparchus/ode/nonstiff/DormandPrince54FieldStateInterpolator.java 144
org/hipparchus/ode/nonstiff/DormandPrince54FieldStateInterpolator.java 197
            final T f2        = f1.multiply(eta);
            final T f3        = f2.multiply(theta);
            final T f4        = f3.multiply(eta);
            final T coeff0    = f1.multiply(a70).
                                subtract(f2.multiply(a70.subtract(1))).
                                add(f3.multiply(a70.multiply(2).subtract(1))).
                                add(f4.multiply(d0));
            final T coeff1    = time.getField().getZero();
            final T coeff2    = f1.multiply(a72).
                                subtract(f2.multiply(a72)).
                                add(f3.multiply(a72.multiply(2))).
                                add(f4.multiply(d2));
            final T coeff3    = f1.multiply(a73).
                                subtract(f2.multiply(a73)).
                                add(f3.multiply(a73.multiply(2))).
                                add(f4.multiply(d3));
            final T coeff4    = f1.multiply(a74).
                                subtract(f2.multiply(a74)).
                                add(f3.multiply(a74.multiply(2))).
                                add(f4.multiply(d4));
            final T coeff5    = f1.multiply(a75).
                                subtract(f2.multiply(a75)).
                                add(f3.multiply(a75.multiply(2))).
                                add(f4.multiply(d5));
            final T coeff6    = f4.multiply(d6).subtract(f3);
            final T coeffDot0 = a70.
                                subtract(dot2.multiply(a70.subtract(1))).
                                add(dot3.multiply(a70.multiply(2).subtract(1))).
                                add(dot4.multiply(d0));
            final T coeffDot1 = time.getField().getZero();
            final T coeffDot2 = a72.
                                subtract(dot2.multiply(a72)).
                                add(dot3.multiply(a72.multiply(2))).
                                add(dot4.multiply(d2));
            final T coeffDot3 = a73.
                                subtract(dot2.multiply(a73)).
                                add(dot3.multiply(a73.multiply(2))).
                                add(dot4.multiply(d3));
            final T coeffDot4 = a74.
                                subtract(dot2.multiply(a74)).
                                add(dot3.multiply(a74.multiply(2))).
                                add(dot4.multiply(d4));
            final T coeffDot5 = a75.
                                subtract(dot2.multiply(a75)).
                                add(dot3.multiply(a75.multiply(2))).
                                add(dot4.multiply(d5));
            final T coeffDot6 = dot4.multiply(d6).subtract(dot3);
            interpolatedState       = previousStateLinearCombination(coeff0, coeff1, coeff2, coeff3,
File Line
org/hipparchus/ode/nonstiff/AdamsBashforthFieldIntegrator.java 316
org/hipparchus/ode/nonstiff/AdamsMoultonFieldIntegrator.java 301
            nordsieck = predictedNordsieck;

            if (!isLastStep()) {

                if (resetOccurred()) {

                    // some events handler has triggered changes that
                    // invalidate the derivatives, we need to restart from scratch
                    start(equations, getStepStart(), finalTime);

                    final T  nextT      = getStepStart().getTime().add(getStepSize());
                    final boolean nextIsLast = forward ?
                                               nextT.subtract(finalTime).getReal() >= 0 :
                                               nextT.subtract(finalTime).getReal() <= 0;
                    final T hNew = nextIsLast ? finalTime.subtract(getStepStart().getTime()) : getStepSize();

                    rescale(hNew);
                    System.arraycopy(getStepStart().getCompleteState(), 0, y, 0, y.length);

                } else {

                    // stepsize control for next step
                    final T       factor     = computeStepGrowShrinkFactor(error);
                    final T       scaledH    = getStepSize().multiply(factor);
                    final T       nextT      = getStepStart().getTime().add(scaledH);
                    final boolean nextIsLast = forward ?
                                               nextT.subtract(finalTime).getReal() >= 0 :
                                               nextT.subtract(finalTime).getReal() <= 0;
                    T hNew = filterStep(scaledH, forward, nextIsLast);

                    final T       filteredNextT      = getStepStart().getTime().add(hNew);
                    final boolean filteredNextIsLast = forward ?
                                                       filteredNextT.subtract(finalTime).getReal() >= 0 :
                                                       filteredNextT.subtract(finalTime).getReal() <= 0;
                    if (filteredNextIsLast) {
                        hNew = finalTime.subtract(getStepStart().getTime());
                    }

                    rescale(hNew);
                    System.arraycopy(predictedY, 0, y, 0, y.length);

                }

                stepEnd = AdamsFieldStateInterpolator.taylor(equations.getMapper(), getStepStart(),
                                                             getStepStart().getTime().add(getStepSize()),
                                                             getStepSize(), scaled, nordsieck);

            }

        } while (!isLastStep());

        final FieldODEStateAndDerivative<T> finalState = getStepStart();
        setStepStart(null);
        setStepSize(null);
        return finalState;

    }
File Line
org/hipparchus/ode/nonstiff/DormandPrince853FieldStateInterpolator.java 242
org/hipparchus/ode/nonstiff/DormandPrince853FieldStateInterpolator.java 272
            final T f1 = f0.multiply(eta);
            final T f2 = f1.multiply(theta);
            final T f3 = f2.multiply(eta);
            final T f4 = f3.multiply(theta);
            final T f5 = f4.multiply(eta);
            final T f6 = f5.multiply(theta);
            final T[] p = MathArrays.buildArray(time.getField(), 16);
            final T[] q = MathArrays.buildArray(time.getField(), 16);
            for (int i = 0; i < p.length; ++i) {
                p[i] =     f0.multiply(d[0][i]).
                       add(f1.multiply(d[1][i])).
                       add(f2.multiply(d[2][i])).
                       add(f3.multiply(d[3][i])).
                       add(f4.multiply(d[4][i])).
                       add(f5.multiply(d[5][i])).
                       add(f6.multiply(d[6][i]));
                q[i] =                    d[0][i].
                        add(dot1.multiply(d[1][i])).
                        add(dot2.multiply(d[2][i])).
                        add(dot3.multiply(d[3][i])).
                        add(dot4.multiply(d[4][i])).
                        add(dot5.multiply(d[5][i])).
                        add(dot6.multiply(d[6][i]));
            }
            interpolatedState       = previousStateLinearCombination(p[0], p[1], p[ 2], p[ 3], p[ 4], p[ 5], p[ 6], p[ 7],
File Line
org/hipparchus/ode/nonstiff/AdamsBashforthIntegrator.java 311
org/hipparchus/ode/nonstiff/AdamsMoultonIntegrator.java 294
            nordsieck = predictedNordsieck;

            if (!isLastStep()) {

                if (resetOccurred()) {

                    // some events handler has triggered changes that
                    // invalidate the derivatives, we need to restart from scratch
                    start(equations, getStepStart(), finalTime);

                    final double  nextT      = getStepStart().getTime() + getStepSize();
                    final boolean nextIsLast = forward ?
                                               (nextT >= finalTime) :
                                               (nextT <= finalTime);
                    final double hNew = nextIsLast ? finalTime - getStepStart().getTime() : getStepSize();

                    rescale(hNew);
                    System.arraycopy(getStepStart().getCompleteState(), 0, y, 0, y.length);

                } else {

                    // stepsize control for next step
                    final double  factor     = computeStepGrowShrinkFactor(error);
                    final double  scaledH    = getStepSize() * factor;
                    final double  nextT      = getStepStart().getTime() + scaledH;
                    final boolean nextIsLast = forward ?
                                               (nextT >= finalTime) :
                                               (nextT <= finalTime);
                    double hNew = filterStep(scaledH, forward, nextIsLast);

                    final double  filteredNextT      = getStepStart().getTime() + hNew;
                    final boolean filteredNextIsLast = forward ? (filteredNextT >= finalTime) : (filteredNextT <= finalTime);
                    if (filteredNextIsLast) {
                        hNew = finalTime - getStepStart().getTime();
                    }

                    rescale(hNew);
                    System.arraycopy(predictedY, 0, y, 0, y.length);

                }

                stepEnd = AdamsStateInterpolator.taylor(equations.getMapper(), getStepStart(), getStepStart().getTime() + getStepSize(),
                                                        getStepSize(), scaled, nordsieck);

            }

        } while (!isLastStep());

        final ODEStateAndDerivative finalState = getStepStart();
        setStepStart(null);
        setStepSize(Double.NaN);
        return finalState;

    }
File Line
org/hipparchus/ode/nonstiff/DormandPrince54StateInterpolator.java 127
org/hipparchus/ode/nonstiff/DormandPrince54StateInterpolator.java 150
            final double f3        = f2 * theta;
            final double f4        = f3 * eta;
            final double coeff0    = f1 * A70 - f2   * (A70 - 1) + f3   * (2 * A70 - 1) + f4   * D0;
            final double coeff1    = 0;
            final double coeff2    = f1 * A72 - f2   * A72       + f3   * (2 * A72)     + f4   * D2;
            final double coeff3    = f1 * A73 - f2   * A73       + f3   * (2 * A73)     + f4   * D3;
            final double coeff4    = f1 * A74 - f2   * A74       + f3   * (2 * A74)     + f4   * D4;
            final double coeff5    = f1 * A75 - f2   * A75       + f3   * (2 * A75)     + f4   * D5;
            final double coeff6    = f4 * D6 - f3;
            final double coeffDot0 =      A70 - dot2 * (A70 - 1) + dot3 * (2 * A70 - 1) + dot4 * D0;
            final double coeffDot1 = 0;
            final double coeffDot2 =      A72 - dot2 * A72       + dot3 * (2 * A72)     + dot4 * D2;
            final double coeffDot3 =      A73 - dot2 * A73       + dot3 * (2 * A73)     + dot4 * D3;
            final double coeffDot4 =      A74 - dot2 * A74       + dot3 * (2 * A74)     + dot4 * D4;
            final double coeffDot5 =      A75 - dot2 * A75       + dot3 * (2 * A75)     + dot4 * D5;
            final double coeffDot6 = dot4 * D6 - dot3;
            interpolatedState       = previousStateLinearCombination(coeff0, coeff1, coeff2, coeff3,
File Line
org/hipparchus/ode/nonstiff/EmbeddedRungeKuttaFieldIntegrator.java 275
org/hipparchus/ode/nonstiff/RungeKuttaFieldIntegrator.java 154
                for (int k = 1; k < stages; ++k) {

                    for (int j = 0; j < y.length; ++j) {
                        T sum = yDotK[0][j].multiply(a[k-1][0]);
                        for (int l = 1; l < k; ++l) {
                            sum = sum.add(yDotK[l][j].multiply(a[k-1][l]));
                        }
                        yTmp[j] = y[j].add(getStepSize().multiply(sum));
                    }

                    yDotK[k] = computeDerivatives(getStepStart().getTime().add(getStepSize().multiply(c[k-1])), yTmp);

                }

                // estimate the state at the end of the step
                for (int j = 0; j < y.length; ++j) {
                    T sum    = yDotK[0][j].multiply(b[0]);
                    for (int l = 1; l < stages; ++l) {
                        sum = sum.add(yDotK[l][j].multiply(b[l]));
                    }
                    yTmp[j] = y[j].add(getStepSize().multiply(sum));
                }
File Line
org/hipparchus/ode/nonstiff/DormandPrince853StateInterpolator.java 219
org/hipparchus/ode/nonstiff/DormandPrince853StateInterpolator.java 239
            final double f2 = f1 * theta;
            final double f3 = f2 * eta;
            final double f4 = f3 * theta;
            final double f5 = f4 * eta;
            final double f6 = f5 * theta;
            final double[] p = new double[16];
            final double[] q = new double[16];
            for (int i = 0; i < p.length; ++i) {
                p[i] = f0 * D[0][i] +   f1 * D[1][i] +   f2 * D[2][i] +   f3 * D[3][i] +
                       f4 * D[4][i] +   f5 * D[5][i] +   f6 * D[6][i];
                q[i] = D[0][i] + dot1 * D[1][i] + dot2 * D[2][i] + dot3 * D[3][i] +
                                 dot4 * D[4][i] + dot5 * D[5][i] + dot6 * D[6][i];
            }
            interpolatedState       = previousStateLinearCombination(p[0], p[1], p[ 2], p[ 3], p[ 4], p[ 5], p[ 6], p[ 7],
File Line
org/hipparchus/ode/nonstiff/EmbeddedRungeKuttaIntegrator.java 247
org/hipparchus/ode/nonstiff/RungeKuttaIntegrator.java 136
                for (int k = 1; k < stages; ++k) {

                    for (int j = 0; j < y.length; ++j) {
                        double sum = a[k-1][0] * yDotK[0][j];
                        for (int l = 1; l < k; ++l) {
                            sum += a[k-1][l] * yDotK[l][j];
                        }
                        yTmp[j] = y[j] + getStepSize() * sum;
                    }

                    yDotK[k] = computeDerivatives(getStepStart().getTime() + c[k-1] * getStepSize(), yTmp);

                }

                // estimate the state at the end of the step
                for (int j = 0; j < y.length; ++j) {
                    double sum    = b[0] * yDotK[0][j];
                    for (int l = 1; l < stages; ++l) {
                        sum    += b[l] * yDotK[l][j];
                    }
                    yTmp[j] = y[j] + getStepSize() * sum;
File Line
org/hipparchus/ode/nonstiff/DormandPrince853FieldStateInterpolator.java 295
org/hipparchus/ode/nonstiff/DormandPrince853StateInterpolator.java 251
            }
            interpolatedState       = currentStateLinearCombination(p[0], p[1], p[ 2], p[ 3], p[ 4], p[ 5], p[ 6], p[ 7],
                                                                    p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
            interpolatedDerivatives = derivativeLinearCombination(q[0], q[1], q[ 2], q[ 3], q[ 4], q[ 5], q[ 6], q[ 7],
                                                                  q[8], q[9], q[10], q[11], q[12], q[13], q[14], q[15]);
        }

        return mapper.mapStateAndDerivative(time, interpolatedState, interpolatedDerivatives);

    }

}
File Line
org/hipparchus/ode/nonstiff/DormandPrince853FieldStateInterpolator.java 265
org/hipparchus/ode/nonstiff/DormandPrince853StateInterpolator.java 231
            }
            interpolatedState       = previousStateLinearCombination(p[0], p[1], p[ 2], p[ 3], p[ 4], p[ 5], p[ 6], p[ 7],
                                                                     p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
            interpolatedDerivatives = derivativeLinearCombination(q[0], q[1], q[ 2], q[ 3], q[ 4], q[ 5], q[ 6], q[ 7],
                                                                  q[8], q[9], q[10], q[11], q[12], q[13], q[14], q[15]);
        } else {
            final T f0 = oneMinusThetaH.negate();
File Line
org/hipparchus/ode/nonstiff/DormandPrince853FieldStateInterpolator.java 266
org/hipparchus/ode/nonstiff/DormandPrince853FieldStateInterpolator.java 296
org/hipparchus/ode/nonstiff/DormandPrince853StateInterpolator.java 232
org/hipparchus/ode/nonstiff/DormandPrince853StateInterpolator.java 252
            interpolatedState       = previousStateLinearCombination(p[0], p[1], p[ 2], p[ 3], p[ 4], p[ 5], p[ 6], p[ 7],
                                                                     p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
            interpolatedDerivatives = derivativeLinearCombination(q[0], q[1], q[ 2], q[ 3], q[ 4], q[ 5], q[ 6], q[ 7],
                                                                  q[8], q[9], q[10], q[11], q[12], q[13], q[14], q[15]);
        } else {
File Line
org/hipparchus/ode/nonstiff/AdamsBashforthFieldIntegrator.java 271
org/hipparchus/ode/nonstiff/AdamsMoultonFieldIntegrator.java 246
        final T[] y = getStepStart().getCompleteState();
        do {

            T[] predictedY = null;
            final T[] predictedScaled = MathArrays.buildArray(getField(), y.length);
            Array2DRowFieldMatrix<T> predictedNordsieck = null;
            T error = getField().getZero().add(10);
            while (error.subtract(1.0).getReal() >= 0.0) {

                // predict a first estimate of the state at step end
                predictedY = stepEnd.getCompleteState();

                // evaluate the derivative
                final T[] yDot = computeDerivatives(stepEnd.getTime(), predictedY);

                // predict Nordsieck vector at step end
                for (int j = 0; j < predictedScaled.length; ++j) {
                    predictedScaled[j] = getStepSize().multiply(yDot[j]);
                }
                predictedNordsieck = updateHighOrderDerivativesPhase1(nordsieck);
                updateHighOrderDerivativesPhase2(scaled, predictedScaled, predictedNordsieck);

                // evaluate error
                error = errorEstimation(y, predictedY, predictedScaled, predictedNordsieck);
File Line
org/hipparchus/ode/nonstiff/DormandPrince853FieldIntegrator.java 142
org/hipparchus/ode/nonstiff/DormandPrince853FieldIntegrator.java 178
              minStep, maxStep, scalAbsoluteTolerance, scalRelativeTolerance);
        e1_01 = fraction(        116092271.0,       8848465920.0);
        e1_06 = fraction(         -1871647.0,          1527680.0);
        e1_07 = fraction(        -69799717.0,        140793660.0);
        e1_08 = fraction(    1230164450203.0,     739113984000.0);
        e1_09 = fraction(-1980813971228885.0, 5654156025964544.0);
        e1_10 = fraction(        464500805.0,       1389975552.0);
        e1_11 = fraction(    1606764981773.0,   19613062656000.0);
        e1_12 = fraction(          -137909.0,          6168960.0);
        e2_01 = fraction(          -364463.0,          1920240.0);
        e2_06 = fraction(          3399327.0,           763840.0);
        e2_07 = fraction(         66578432.0,         35198415.0);
        e2_08 = fraction(      -1674902723.0,        288716400.0);
        e2_09 = fraction(  -74684743568175.0,  176692375811392.0);
        e2_10 = fraction(          -734375.0,          4826304.0);
        e2_11 = fraction(        171414593.0,        851261400.0);
        e2_12 = fraction(            69869.0,          3084480.0);
    }
File Line
org/hipparchus/ode/nonstiff/EmbeddedRungeKuttaFieldIntegrator.java 218
org/hipparchus/ode/nonstiff/RungeKuttaFieldIntegrator.java 116
    @Override
    public FieldODEStateAndDerivative<T> integrate(final FieldExpandableODE<T> equations,
                                                   final FieldODEState<T> initialState, final T finalTime)
        throws MathIllegalArgumentException, MathIllegalStateException {

        sanityChecks(initialState, finalTime);
        setStepStart(initIntegration(equations, initialState, finalTime));
        final boolean forward = finalTime.subtract(initialState.getTime()).getReal() > 0;

        // create some internal working arrays
        final int   stages = c.length + 1;
        final T[][] yDotK  = MathArrays.buildArray(getField(), stages, -1);
        final T[]   yTmp   = MathArrays.buildArray(getField(), equations.getMapper().getTotalDimension());
File Line
org/hipparchus/ode/EquationsMapper.java 49
org/hipparchus/ode/FieldEquationsMapper.java 58
    EquationsMapper(final EquationsMapper mapper, final int dimension) {
        final int index = (mapper == null) ? 0 : mapper.getNumberOfEquations();
        this.start = new int[index + 2];
        if (mapper == null) {
            start[0] = 0;
        } else {
            System.arraycopy(mapper.start, 0, start, 0, index + 1);
        }
        start[index + 1] = start[index] + dimension;
    }

    /** Get the number of equations mapped.
     * @return number of equations mapped
     */
    public int getNumberOfEquations() {
        return start.length - 1;
    }

    /** Return the dimension of the complete set of equations.
     * <p>
     * The complete set of equations correspond to the primary set plus all secondary sets.
     * </p>
     * @return dimension of the complete set of equations
     */
    public int getTotalDimension() {
        return start[start.length - 1];
    }
File Line
org/hipparchus/ode/events/FilterType.java 158
org/hipparchus/ode/events/FilterType.java 281
                        } else if (g < 0) {
                            // initialize as if previous root (i.e. forward one) was an ignored increasing event
                            return Transformer.MIN;
                        } else {
                            // we are exactly at a root, we don't know if it is an increasing
                            // or a decreasing event, we remain in uninitialized state
                            return Transformer.UNINITIALIZED;
                        }
                    case PLUS  :
                        if (g <= 0) {
                            // we have crossed the zero line on an ignored increasing event,
                            // we must change the transformer
                            return Transformer.MAX;
                        } else {
                            // we are still in the same status
                            return previous;
                        }
                    case MINUS :
                        if (g <= 0) {
                            // we have crossed the zero line on an ignored increasing event,
                            // we must change the transformer
                            return Transformer.MIN;
                        } else {
                            // we are still in the same status
                            return previous;
                        }
                    case MIN   :
                        if (g >= 0) {
                            // we have crossed the zero line on a triggered decreasing event,
                            // we must change the transformer
                            return Transformer.PLUS;
                        } else {
                            // we are still in the same status
                            return previous;
                        }
                    case MAX   :
                        if (g >= 0) {
                            // we have crossed the zero line on a triggered decreasing event,
                            // we must change the transformer
                            return Transformer.MINUS;
                        } else {
                            // we are still in the same status
                            return previous;
                        }
                    default    :
                        // this should never happen
                        throw MathRuntimeException.createInternalError();
                }
            }
File Line
org/hipparchus/ode/EquationsMapper.java 145
org/hipparchus/ode/FieldEquationsMapper.java 174
    public void insertEquationData(final int index, double[] equationData, double[] complete)
        throws MathIllegalArgumentException {
        checkIndex(index);
        final int begin     = start[index];
        final int end       = start[index + 1];
        final int dimension = end - begin;
        if (complete.length < end) {
            throw new MathIllegalArgumentException(LocalizedCoreFormats.DIMENSIONS_MISMATCH,
                                                   complete.length, end);
        }
        if (equationData.length != dimension) {
            throw new MathIllegalArgumentException(LocalizedCoreFormats.DIMENSIONS_MISMATCH,
                                                   equationData.length, dimension);
        }
        System.arraycopy(equationData, 0, complete, begin, dimension);
    }

    /** Check equation index.
     * @param index index of the equation, must be between 0 included and
     * {@link #getNumberOfEquations()} (excluded)
     * @exception MathIllegalArgumentException if index is out of range
     */
    private void checkIndex(final int index) throws MathIllegalArgumentException {
File Line
org/hipparchus/ode/nonstiff/AdamsBashforthIntegrator.java 262
org/hipparchus/ode/nonstiff/AdamsMoultonIntegrator.java 235
        final double[] y  = getStepStart().getCompleteState();
        do {

            double[] predictedY  = null;
            final double[] predictedScaled = new double[y.length];
            Array2DRowRealMatrix predictedNordsieck = null;
            double error = 10;
            while (error >= 1.0) {

                // predict a first estimate of the state at step end
                predictedY = stepEnd.getCompleteState();

                // evaluate the derivative
                final double[] yDot = computeDerivatives(stepEnd.getTime(), predictedY);

                // predict Nordsieck vector at step end
                for (int j = 0; j < predictedScaled.length; ++j) {
                    predictedScaled[j] = getStepSize() * yDot[j];
                }
                predictedNordsieck = updateHighOrderDerivativesPhase1(nordsieck);
                updateHighOrderDerivativesPhase2(scaled, predictedScaled, predictedNordsieck);

                // evaluate error
                error = errorEstimation(y, predictedY, predictedScaled, predictedNordsieck);
File Line
org/hipparchus/ode/nonstiff/DormandPrince54FieldIntegrator.java 226
org/hipparchus/ode/nonstiff/HighamHall54FieldIntegrator.java 199
            final T yScale = MathUtils.max(y0[j].abs(), y1[j].abs());
            final T tol    = (vecAbsoluteTolerance == null) ?
                             yScale.multiply(scalRelativeTolerance).add(scalAbsoluteTolerance) :
                             yScale.multiply(vecRelativeTolerance[j]).add(vecAbsoluteTolerance[j]);
            final T ratio  = h.multiply(errSum).divide(tol);
            error = error.add(ratio.multiply(ratio));

        }

        return error.divide(mainSetDimension).sqrt();

    }

}
File Line
org/hipparchus/ode/nonstiff/DormandPrince54FieldIntegrator.java 143
org/hipparchus/ode/nonstiff/HighamHall54FieldIntegrator.java 118
        c[3] = fraction(8,  9);
        c[4] = getField().getOne();
        c[5] = getField().getOne();
        return c;
    }

    /** {@inheritDoc} */
    @Override
    public T[][] getA() {
        final T[][] a = MathArrays.buildArray(getField(), 6, -1);
        for (int i = 0; i < a.length; ++i) {
            a[i] = MathArrays.buildArray(getField(), i + 1);
        }
        a[0][0] = fraction(     1,     5);

Back to top

Version: 1.4. Last Published: 2018-11-14.

Reflow Maven skin by Andrius Velykis.