CPD Results

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

Duplications

File Line
org/apache/commons/nabla/NablaMath.java 354
org/apache/commons/nabla/NablaStrictMath.java 354 
        return DifferentialPair.newConstant(StrictMath.signum(a.getValue()));
    }

    /** Sign copy function.
     * @param magnitude function input value
     * @param sign sign reference
     * @return either magnitude or -magnitude to match sign
     */
    public static DifferentialPair copySign(final DifferentialPair magnitude,
                                            final double sign) {
        final long mBits = Double.doubleToLongBits(magnitude.getValue());
        final long sBits = Double.doubleToLongBits(sign);
        return (((mBits ^ sBits) & 0x8000000000000000L) == 0) ?
                magnitude : DifferentialPair.negate(magnitude);
    }

    /** Sign copy function.
     * @param magnitude function input value
     * @param sign sign reference
     * @return either magnitude or -magnitude to match sign
     */
    public static DifferentialPair copySign(final double magnitude,
                                            final DifferentialPair sign) {
        final long mBits = Double.doubleToLongBits(magnitude);
        final long sBits = Double.doubleToLongBits(sign.getValue());
        return (((mBits ^ sBits) & 0x8000000000000000L) == 0) ?
               DifferentialPair.newConstant(magnitude) :
               DifferentialPair.newConstant(-magnitude);
    }

    /** Sign copy function.
     * @param magnitude function input value
     * @param sign sign reference
     * @return either magnitude or -magnitude to match sign
     */
    public static DifferentialPair copySign(final DifferentialPair magnitude,
                                            final DifferentialPair sign) {
        final long mBits = Double.doubleToLongBits(magnitude.getValue());
        final long sBits = Double.doubleToLongBits(sign.getValue());
        return (((mBits ^ sBits) & 0x8000000000000000L) == 0) ?
                magnitude : DifferentialPair.negate(magnitude);
    }


    ////////////////////////////
    // neighborhood functions //
    ////////////////////////////

    /** Floor function.
     * @param a function input value
     * @return largest integer value smaller than a or equal to a
     */
    public static DifferentialPair floor(final DifferentialPair a) {
        return DifferentialPair.newConstant(StrictMath.floor(a.getValue()));

File Line
org/apache/commons/nabla/NablaMath.java 545
org/apache/commons/nabla/NablaStrictMath.java 545 
        return new DifferentialPair(StrictMath.toRadians(a.getValue()), StrictMath.toRadians(a.getFirstDerivative()));
    }


    //////////////////////////
    // comparison functions //
    //////////////////////////

    /** Max function.
     * @param a first function input value
     * @param b second function input value
     * @return maximal value from the (a, b) pair
     */
    public static DifferentialPair max(final DifferentialPair a,
                                       final double b) {
        return (a.getValue() >= b) ? a : DifferentialPair.newConstant(b);
    }

    /** Max function.
     * @param a first function input value
     * @param b second function input value
     * @return maximal value from the (a, b) pair
     */
    public static DifferentialPair max(final double a,
                                       final DifferentialPair b) {
        return (b.getValue() >= a) ? b : DifferentialPair.newConstant(a);
    }

    /** Max function.
     * @param a first function input value
     * @param b second function input value
     * @return maximal value from the (a, b) pair
     */
    public static DifferentialPair max(final DifferentialPair a,
                                       final DifferentialPair b) {
        return (a.getValue() >= b.getValue()) ? a : b;
    }

    /** Min function.
     * @param a first function input value
     * @param b second function input value
     * @return minimal value from the (a, b) pair
     */
    public static DifferentialPair min(final DifferentialPair a,
                                       final double b) {
        return (a.getValue() <= b) ? a : DifferentialPair.newConstant(b);
    }

    /** Min function.
     * @param a first function input value
     * @param b second function input value
     * @return minimal value from the (a, b) pair
     */
    public static DifferentialPair min(final double a,
                                       final DifferentialPair b) {
        return (b.getValue() <= a) ? b : DifferentialPair.newConstant(a);
    }

    /** Min function.
     * @param a first function input value
     * @param b second function input value
     * @return minimal value from the (a, b) pair
     */
    public static DifferentialPair min(final DifferentialPair a,
                                       final DifferentialPair b) {
        return (a.getValue() <= b.getValue()) ? a : b;
    }

}

File Line
org/apache/commons/nabla/algorithmic/forward/arithmetic/DDivTransformer12.java 47
org/apache/commons/nabla/algorithmic/forward/arithmetic/DMulTransformer12.java 47 
    private DMulTransformer12() {
    }

    /** Get the singleton instance.
     * <p>We use here the Initialization on Demand Holder idiom.</p>
     * @return the singleton instance
     */
    public static InstructionsTransformer getInstance() {
        return LazyHolder.INSTANCE;
    }

    /** {@inheritDoc} */
    public InsnList getReplacement(final AbstractInsnNode insn,
                                   final MethodDifferentiator methodDifferentiator)
        throws DifferentiationException {

        final int tmp1 = methodDifferentiator.getTmp(1);
        final int tmp2 = methodDifferentiator.getTmp(2);
        final int tmp3 = methodDifferentiator.getTmp(3);
        final InsnList list = new InsnList();

        // operand stack initial state: a0, a1, b0, b1
        list.add(new VarInsnNode(Opcodes.DSTORE, tmp1)); // => a0, a1, b0
        list.add(new InsnNode(Opcodes.DUP2));            // => a0, a1, b0, b0
        list.add(new VarInsnNode(Opcodes.DSTORE, tmp2)); // => a0, a1, b0
        list.add(new InsnNode(Opcodes.DMUL));            // => a0, a1*b0
        list.add(new VarInsnNode(Opcodes.DSTORE, tmp3)); // => a0
        list.add(new InsnNode(Opcodes.DUP2));            // => a0, a0
        list.add(new VarInsnNode(Opcodes.DLOAD,  tmp1)); // => a0, a0, b1
        list.add(new InsnNode(Opcodes.DMUL));            // => a0, a0*b1
        list.add(new VarInsnNode(Opcodes.DLOAD,  tmp3)); // => a0, a0*b1, a1*b0

File Line
org/apache/commons/nabla/algorithmic/forward/functions/AcosTransformer.java 28
org/apache/commons/nabla/algorithmic/forward/functions/AsinTransformer.java 27 
public class AsinTransformer implements MathInvocationTransformer {

    /** {@inheritDoc} */
    public InsnList getReplacementList(final String owner, final MethodDifferentiator methodDifferentiator) {

        // generate differential code
        // ... u0, u1  --> ...  asin(u0), u1 / sqrt(1 - u0 * u0)
        final InsnList list = new InsnList();
        list.add(new InsnNode(Opcodes.DUP2_X2));
        list.add(new InsnNode(Opcodes.POP2));
        list.add(new InsnNode(Opcodes.DUP2_X2));
        list.add(new InsnNode(Opcodes.DUP2));
        list.add(new InsnNode(Opcodes.DMUL));
        list.add(new InsnNode(Opcodes.DCONST_1));
        list.add(new InsnNode(Opcodes.DSUB));
        list.add(new InsnNode(Opcodes.DNEG));
        list.add(new MethodInsnNode(Opcodes.INVOKESTATIC, owner, "sqrt", D_RETURN_D_DESCRIPTOR));
        list.add(new InsnNode(Opcodes.DDIV));
        list.add(new InsnNode(Opcodes.DUP2_X2));

File Line
org/apache/commons/nabla/algorithmic/forward/arithmetic/DRemTransformer12.java 60
org/apache/commons/nabla/algorithmic/forward/functions/HypotTransformer12.java 32 
    public InsnList getReplacementList(final String owner, final MethodDifferentiator methodDifferentiator)
        throws DifferentiationException {

        final int tmp1 = methodDifferentiator.getTmp(1);
        final int tmp2 = methodDifferentiator.getTmp(2);
        final int tmp3 = methodDifferentiator.getTmp(3);
        final int tmp4 = methodDifferentiator.getTmp(4);

        // generate differential code
        // ... x0, x1, y0, y1  --> ...  hypot(x0,y0), (x0*x1+y0*y1)/hypot(x0,y0)
        final InsnList list = new InsnList();
        list.add(new VarInsnNode(Opcodes.DSTORE, tmp1)); // => x0, x1, y0
        list.add(new VarInsnNode(Opcodes.DSTORE, tmp2)); // => x0, x1
        list.add(new VarInsnNode(Opcodes.DSTORE, tmp3)); // => x0
        list.add(new VarInsnNode(Opcodes.DSTORE, tmp4)); // =>
        list.add(new VarInsnNode(Opcodes.DLOAD,  tmp4)); // => x0
        list.add(new VarInsnNode(Opcodes.DLOAD,  tmp2)); // => x0, y0
        list.add(new MethodInsnNode(Opcodes.INVOKESTATIC, owner, "hypot", DD_RETURN_D_DESCRIPTOR)); // => hypot(x0,y0)

File Line
org/apache/commons/nabla/numerical/EightPointsScheme.java 40
org/apache/commons/nabla/numerical/SixPointsScheme.java 40 
        denominator = 60 * h;
    }

    /** {@inheritDoc} */
    public UnivariateDerivative differentiate(final UnivariateDifferentiable d) {
        return new UnivariateDerivative() {

            /** {@inheritDoc} */
            public UnivariateDifferentiable getPrimitive() {
                return d;
            }

            /** {@inheritDoc} */
            public DifferentialPair f(final DifferentialPair t) {
                final double h = getStepSize();
                final double u0 = t.getValue();
                final double ft = d.f(u0);
                final double d1 = d.f(u0 +     h) - d.f(u0 -     h);
                final double d2 = d.f(u0 + 2 * h) - d.f(u0 - 2 * h);
                final double d3 = d.f(u0 + 3 * h) - d.f(u0 - 3 * h);

File Line
org/apache/commons/nabla/algorithmic/forward/functions/AcosTransformer.java 28
org/apache/commons/nabla/algorithmic/forward/functions/AtanhTransformer.java 31 
public class AtanhTransformer implements MathInvocationTransformer {

    /** {@inheritDoc} */
    public InsnList getReplacementList(final String owner, final MethodDifferentiator methodDifferentiator) {

        // generate differential code
        // ... u0, u1  --> ...  atanh(u0), u1 / (1 - u0 * u0)
        final InsnList list = new InsnList();
        list.add(new InsnNode(Opcodes.DUP2_X2));
        list.add(new InsnNode(Opcodes.POP2));
        list.add(new InsnNode(Opcodes.DUP2_X2));
        list.add(new InsnNode(Opcodes.DUP2));
        list.add(new InsnNode(Opcodes.DMUL));
        list.add(new InsnNode(Opcodes.DCONST_1));
        list.add(new InsnNode(Opcodes.DSUB));
        list.add(new InsnNode(Opcodes.DNEG));
        list.add(new InsnNode(Opcodes.DDIV));

File Line
org/apache/commons/nabla/algorithmic/forward/arithmetic/DRemTransformer2.java 48
org/apache/commons/nabla/algorithmic/forward/instructions/Dup2X2Transformer12.java 44 
    private Dup2X2Transformer12() {
    }

    /** Get the singleton instance.
     * <p>We use here the Initialization on Demand Holder idiom.</p>
     * @return the singleton instance
     */
    public static InstructionsTransformer getInstance() {
        return LazyHolder.INSTANCE;
    }

    /** {@inheritDoc} */
    public InsnList getReplacement(final AbstractInsnNode insn,
                                   final MethodDifferentiator methodDifferentiator)
        throws DifferentiationException {

        final int tmp1 = methodDifferentiator.getTmp(1);
        final int tmp2 = methodDifferentiator.getTmp(2);
        final int tmp3 = methodDifferentiator.getTmp(3);

        final InsnList list = new InsnList();
        // operand stack initial state: a0, a1, b0, b1
        list.add(new VarInsnNode(Opcodes.DSTORE, tmp1)); // => a0, a1, b0
        list.add(new VarInsnNode(Opcodes.DSTORE, tmp2)); // => a0, a1
        list.add(new VarInsnNode(Opcodes.DSTORE, tmp3)); // => a0
        list.add(new VarInsnNode(Opcodes.DLOAD,  tmp2)); // => a0, b0

File Line
org/apache/commons/nabla/algorithmic/forward/functions/Atan2Transformer1.java 43
org/apache/commons/nabla/algorithmic/forward/functions/Atan2Transformer2.java 41 
        final InsnList list = new InsnList();
        list.add(new VarInsnNode(Opcodes.DSTORE, tmp3)); // => y, x0
        list.add(new VarInsnNode(Opcodes.DSTORE, tmp2)); // => y
        list.add(new VarInsnNode(Opcodes.DSTORE, tmp1)); // =>
        list.add(new VarInsnNode(Opcodes.DLOAD,  tmp1)); // => y
        list.add(new VarInsnNode(Opcodes.DLOAD,  tmp2)); // => y, x0
        list.add(new MethodInsnNode(Opcodes.INVOKESTATIC, owner, "atan2", DD_RETURN_D_DESCRIPTOR)); // => atan2(y,x0)
        list.add(new VarInsnNode(Opcodes.DLOAD,  tmp3)); // => atan2(y,x0), x1
        list.add(new VarInsnNode(Opcodes.DLOAD,  tmp1)); // => atan2(y,x0), x1, y

File Line
org/apache/commons/nabla/algorithmic/forward/functions/AsinhTransformer.java 31
org/apache/commons/nabla/algorithmic/forward/functions/AtanTransformer.java 27 
public class AtanTransformer implements MathInvocationTransformer {

    /** {@inheritDoc} */
    public InsnList getReplacementList(final String owner, final MethodDifferentiator methodDifferentiator) {

        // generate differential code
        // ... u0, u1  --> ...  atan(u0), u1 / (1 + u0 * u0)
        final InsnList list = new InsnList();
        list.add(new InsnNode(Opcodes.DUP2_X2));
        list.add(new InsnNode(Opcodes.POP2));
        list.add(new InsnNode(Opcodes.DUP2_X2));
        list.add(new InsnNode(Opcodes.DUP2));
        list.add(new InsnNode(Opcodes.DMUL));
        list.add(new InsnNode(Opcodes.DCONST_1));
        list.add(new InsnNode(Opcodes.DADD));
        list.add(new InsnNode(Opcodes.DDIV));

File Line
org/apache/commons/nabla/algorithmic/forward/functions/AcosTransformer.java 28
org/apache/commons/nabla/algorithmic/forward/functions/AcoshTransformer.java 31 
public class AcoshTransformer implements MathInvocationTransformer {

    /** {@inheritDoc} */
    public InsnList getReplacementList(final String owner, final MethodDifferentiator methodDifferentiator) {

        // generate differential code
        // ... u0, u1  --> ...  acosh(u0), u1 / sqrt(u0 * u0 - 1)
        final InsnList list = new InsnList();
        list.add(new InsnNode(Opcodes.DUP2_X2));
        list.add(new InsnNode(Opcodes.POP2));
        list.add(new InsnNode(Opcodes.DUP2_X2));
        list.add(new InsnNode(Opcodes.DUP2));
        list.add(new InsnNode(Opcodes.DMUL));
        list.add(new InsnNode(Opcodes.DCONST_1));
        list.add(new InsnNode(Opcodes.DSUB));
        list.add(new MethodInsnNode(Opcodes.INVOKESTATIC, owner, "sqrt", D_RETURN_D_DESCRIPTOR));

File Line
org/apache/commons/nabla/algorithmic/forward/arithmetic/DAddTransformer12.java 47
org/apache/commons/nabla/algorithmic/forward/arithmetic/DSubTransformer12.java 47 
    private DSubTransformer12() {
    }

    /** Get the singleton instance.
     * <p>We use here the Initialization on Demand Holder idiom.</p>
     * @return the singleton instance
     */
    public static InstructionsTransformer getInstance() {
        return LazyHolder.INSTANCE;
    }

    /** {@inheritDoc} */
    public InsnList getReplacement(final AbstractInsnNode insn,
                                   final MethodDifferentiator methodDifferentiator)
        throws DifferentiationException {

        final int tmp = methodDifferentiator.getTmp(1);
        final InsnList list = new InsnList();

        // operand stack initial state: a0, a1, b0, b1
        list.add(new VarInsnNode(Opcodes.DSTORE, tmp)); // => a0, a1, b0
        list.add(new InsnNode(Opcodes.DUP2_X2));        // => a0, b0, a1, b0
        list.add(new InsnNode(Opcodes.POP2));           // => a0, b0, a1
        list.add(new VarInsnNode(Opcodes.DLOAD,  tmp)); // => a0, b0, a1, b1
        list.add(new InsnNode(Opcodes.DSUB));           // => a0, b0, a1-b1

File Line
org/apache/commons/nabla/numerical/EightPointsScheme.java 40
org/apache/commons/nabla/numerical/FourPointsScheme.java 40 
        denominator = 12 * h;
    }

    /** {@inheritDoc} */
    public UnivariateDerivative differentiate(final UnivariateDifferentiable d) {
        return new UnivariateDerivative() {

            /** {@inheritDoc} */
            public UnivariateDifferentiable getPrimitive() {
                return d;
            }

            /** {@inheritDoc} */
            public DifferentialPair f(final DifferentialPair t) {
                final double h = getStepSize();
                final double u0 = t.getValue();
                final double ft = d.f(u0);
                final double d1 = d.f(u0 +     h) - d.f(u0 -     h);
                final double d2 = d.f(u0 + 2 * h) - d.f(u0 - 2 * h);

File Line
org/apache/commons/nabla/algorithmic/forward/arithmetic/DDivTransformer2.java 47
org/apache/commons/nabla/algorithmic/forward/instructions/Dup2X2Transformer2.java 44 
    private Dup2X2Transformer2() {
    }

    /** Get the singleton instance.
     * <p>We use here the Initialization on Demand Holder idiom.</p>
     * @return the singleton instance
     */
    public static InstructionsTransformer getInstance() {
        return LazyHolder.INSTANCE;
    }

    /** {@inheritDoc} */
    public InsnList getReplacement(final AbstractInsnNode insn,
                                   final MethodDifferentiator methodDifferentiator)
        throws DifferentiationException {

        final int tmp1 = methodDifferentiator.getTmp(1);
        final int tmp2 = methodDifferentiator.getTmp(2);

        final InsnList list = new InsnList();
        // operand stack initial state: w, a0, a1
        list.add(new VarInsnNode(Opcodes.DSTORE, tmp1)); // => w, a0
        list.add(new InsnNode(Opcodes.DUP2));            // => w, a0, a0
        list.add(new VarInsnNode(Opcodes.DSTORE, tmp2)); // => w, a0
        list.add(new InsnNode(Opcodes.DUP2_X2));         // => a0, w, a0

File Line
org/apache/commons/nabla/algorithmic/forward/functions/Atan2Transformer1.java 50
org/apache/commons/nabla/algorithmic/forward/functions/Atan2Transformer2.java 51 
        list.add(new InsnNode(Opcodes.DNEG));            // => atan2(y,x0), -x1*y
        list.add(new VarInsnNode(Opcodes.DLOAD,  tmp2)); // => atan2(y,x0), -x1*y, x0
        list.add(new InsnNode(Opcodes.DUP2));            // => atan2(y,x0), -x1*y, x0, x0
        list.add(new InsnNode(Opcodes.DMUL));            // => atan2(y,x0), -x1*y, x0^2
        list.add(new VarInsnNode(Opcodes.DLOAD,  tmp1)); // => atan2(y,x0), -x1*y, x0^2, y
        list.add(new InsnNode(Opcodes.DUP2));            // => atan2(y,x0), -x1*y, x0^2, y, y
        list.add(new InsnNode(Opcodes.DMUL));            // => atan2(y,x0), -x1*y, x0^2, y^2
        list.add(new InsnNode(Opcodes.DADD));            // => atan2(y,x0), -x1*y, x0^2+y^2
        list.add(new InsnNode(Opcodes.DDIV));            // => atan2(y,x0), -x1*y/(x0^2+y^2)
        return list;

    }

}

File Line
org/apache/commons/nabla/algorithmic/forward/functions/AcosTransformer.java 28
org/apache/commons/nabla/algorithmic/forward/functions/AtanTransformer.java 27 
public class AsinhTransformer implements MathInvocationTransformer {

    /** {@inheritDoc} */
    public InsnList getReplacementList(final String owner, final MethodDifferentiator methodDifferentiator) {

        // generate differential code
        // ... u0, u1  --> ...  asinh(u0), u1 / sqrt(u0 * u0 + 1)
        final InsnList list = new InsnList();
        list.add(new InsnNode(Opcodes.DUP2_X2));
        list.add(new InsnNode(Opcodes.POP2));
        list.add(new InsnNode(Opcodes.DUP2_X2));
        list.add(new InsnNode(Opcodes.DUP2));
        list.add(new InsnNode(Opcodes.DMUL));
        list.add(new InsnNode(Opcodes.DCONST_1));
        list.add(new InsnNode(Opcodes.DADD));