use System.arraycopy instead of loop for better performance.

Author: XenoAmess

src/main/java/org/apache/commons/math4/analysis/differentiation/DSCompiler.java

@@ -1497,11 +1497,11 @@ public void cosh(final double[] operand, final int operandOffset,
 
         // create the function value and derivatives
         double[] function = new double[1 + order];
-        function[0] = FastMath.cosh(operand[operandOffset]);
+        final double function0 = function[0] = FastMath.cosh(operand[operandOffset]);
         if (order > 0) {
-            function[1] = FastMath.sinh(operand[operandOffset]);
+            final double function1 = function[1] = FastMath.sinh(operand[operandOffset]);
             for (int i = 2; i <= order; ++i) {
-                function[i] = function[i - 2];
+                function[i] = (i & 1) == 0 ? function0 : function1;
             }
         }
 
@@ -1523,11 +1523,11 @@ public void sinh(final double[] operand, final int operandOffset,
 
         // create the function value and derivatives
         double[] function = new double[1 + order];
-        function[0] = FastMath.sinh(operand[operandOffset]);
+        final double function0 = function[0] = FastMath.sinh(operand[operandOffset]);
         if (order > 0) {
-            function[1] = FastMath.cosh(operand[operandOffset]);
+            final double function1 = function[1] = FastMath.cosh(operand[operandOffset]);
             for (int i = 2; i <= order; ++i) {
-                function[i] = function[i - 2];
+                function[i] = (i & 1) == 0 ? function0 : function1;
             }
         }
 

src/main/java/org/apache/commons/math4/analysis/function/Logit.java

@@ -170,22 +170,20 @@ public DerivativeStructure value(final DerivativeStructure t)
         double[] f = new double[t.getOrder() + 1];
 
         // function value
-        f[0] = FastMath.log((x - lo) / (hi - x));
-
-        if (Double.isInfinite(f[0])) {
-
-            if (f.length > 1) {
-                f[1] = Double.POSITIVE_INFINITY;
+        final double f0 = f[0] = FastMath.log((x - lo) / (hi - x));
+        final int fLen = f.length;
+        if (Double.isInfinite(f0)) {
+            if (fLen > 1) {
+                final double f1 = f[1] = Double.POSITIVE_INFINITY;
+                // fill the array with infinities
+                // (for x close to lo the signs will flip between -inf and +inf,
+                //  for x close to hi the signs will always be +inf)
+                // this is probably overkill, since the call to compose at the end
+                // of the method will transform most infinities into NaN ...
+                for (int i = 2; i < fLen; ++i) {
+                    f[i] = (i & 1) == 0 ? f0 : f1;
+                }
             }
-            // fill the array with infinities
-            // (for x close to lo the signs will flip between -inf and +inf,
-            //  for x close to hi the signs will always be +inf)
-            // this is probably overkill, since the call to compose at the end
-            // of the method will transform most infinities into NaN ...
-            for (int i = 2; i < f.length; ++i) {
-                f[i] = f[i - 2];
-            }
-
         } else {
 
             // function derivatives

src/main/java/org/apache/commons/math4/analysis/solvers/LaguerreSolver.java

@@ -275,9 +275,7 @@ public Complex[] solveAll(Complex coefficients[], Complex initial)
             }
             // Coefficients for deflated polynomial.
             final Complex c[] = new Complex[n + 1];
-            for (int i = 0; i <= n; i++) {
-                c[i] = coefficients[i];
-            }
+            System.arraycopy(coefficients, 0, c, 0, n + 1);
 
             // Solve individual roots successively.
             final Complex root[] = new Complex[n];

src/main/java/org/apache/commons/math4/dfp/Dfp.java

@@ -668,8 +668,8 @@ public Dfp getTwo() {
     /** Shift the mantissa left, and adjust the exponent to compensate.
      */
     protected void shiftLeft() {
-        for (int i = mant.length - 1; i > 0; i--) {
-            mant[i] = mant[i-1];
+        if (mant.length - 1 >= 0) {
+            System.arraycopy(mant, 0, mant, 1, mant.length - 1);
         }
         mant[0] = 0;
         exp--;
@@ -680,8 +680,8 @@ uses shiftRight() */
     /** Shift the mantissa right, and adjust the exponent to compensate.
      */
     protected void shiftRight() {
-        for (int i = 0; i < mant.length - 1; i++) {
-            mant[i] = mant[i+1];
+        if (mant.length - 1 >= 0) {
+            System.arraycopy(mant, 1, mant, 0, mant.length - 1);
         }
         mant[mant.length - 1] = 0;
         exp++;
@@ -1863,9 +1863,7 @@ public Dfp divide(Dfp divisor) {
 
             /* move the remainder into the dividend while left shifting */
             dividend[0] = 0;
-            for (int i = 0; i < mant.length; i++) {
-                dividend[i + 1] = remainder[i];
-            }
+            System.arraycopy(remainder, 0, dividend, 1, mant.length);
         }
 
         /* Find the most sig digit */

src/main/java/org/apache/commons/math4/fitting/leastsquares/LevenbergMarquardtOptimizer.java

@@ -348,9 +348,8 @@ public Optimum optimize(final LeastSquaresProblem problem) {
 
             //residuals already have weights applied
             double[] weightedResidual = currentResiduals;
-            for (int i = 0; i < nR; i++) {
-                qtf[i] = weightedResidual[i];
-            }
+            if (nR >= 0)
+                System.arraycopy(weightedResidual, 0, qtf, 0, nR);
 
             // compute Qt.res
             qTy(qtf, internalData);

src/main/java/org/apache/commons/math4/linear/HessenbergTransformer.java

@@ -150,9 +150,7 @@ public RealMatrix getH() {
                 }
 
                 // copy upper triangular part of the matrix
-                for (int j = i; j < m; ++j) {
-                    h[i][j] = householderVectors[i][j];
-                }
+                System.arraycopy(householderVectors[i], i, h[i], i, m - i);
             }
             cachedH = MatrixUtils.createRealMatrix(h);
         }

src/main/java/org/apache/commons/math4/ml/neuralnet/twod/NeuronSquareMesh2D.java

@@ -237,9 +237,8 @@ private NeuronSquareMesh2D(boolean wrapRowDim,
     public synchronized NeuronSquareMesh2D copy() {
         final long[][] idGrid = new long[numberOfRows][numberOfColumns];
         for (int r = 0; r < numberOfRows; r++) {
-            for (int c = 0; c < numberOfColumns; c++) {
-                idGrid[r][c] = identifiers[r][c];
-            }
+            if (numberOfColumns >= 0)
+                System.arraycopy(identifiers[r], 0, idGrid[r], 0, numberOfColumns);
         }
 
         return new NeuronSquareMesh2D(wrapRows,

src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsNordsieckFieldTransformer.java

@@ -170,9 +170,9 @@ private AdamsNordsieckFieldTransformer(final Field<T> field, final int n) {
         // Nordsieck to multistep, then shifting rows to represent step advance
         // then applying inverse transform
         T[][] shiftedP = bigP.getData();
-        for (int i = shiftedP.length - 1; i > 0; --i) {
-            // shift rows
-            shiftedP[i] = shiftedP[i - 1];
+        // shift rows
+        if (shiftedP.length - 1 >= 0) {
+            System.arraycopy(shiftedP, 0, shiftedP, 1, shiftedP.length - 1);
         }
         shiftedP[0] = MathArrays.buildArray(field, rows);
         Arrays.fill(shiftedP[0], field.getZero());

src/main/java/org/apache/commons/math4/optim/nonlinear/scalar/noderiv/CMAESOptimizer.java

@@ -811,8 +811,8 @@ private void updateBD(double negccov) {
      * @param val Current best fitness value.
      */
     private static void push(double[] vals, double val) {
-        for (int i = vals.length-1; i > 0; i--) {
-            vals[i] = vals[i-1];
+        if (vals.length - 1 >= 0) {
+            System.arraycopy(vals, 0, vals, 1, vals.length - 1);
         }
         vals[0] = val;
     }

src/test/java/org/apache/commons/math4/linear/RealVectorAbstractTest.java

@@ -406,9 +406,7 @@ public void testSetSubVectorSameType() {
         final int index = 2;
         actual.setSubVector(index, create(sub));
 
-        for (int i = 0; i < sub.length; i++){
-            expected[index + i] = sub[i];
-        }
+        System.arraycopy(sub, 0, expected, 2, sub.length);
         TestUtils.assertEquals("", expected, actual, 0d);
     }
 
@@ -421,9 +419,7 @@ public void testSetSubVectorMixedType() {
         final int index = 2;
         actual.setSubVector(index, createAlien(sub));
 
-        for (int i = 0; i < sub.length; i++){
-            expected[index + i] = sub[i];
-        }
+        System.arraycopy(sub, 0, expected, 2, sub.length);
         TestUtils.assertEquals("", expected, actual, 0d);
     }