commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From er...@apache.org
Subject [1/2] [math] MATH-1416: Depend on "Commons Numbers" (module "commons-numbers-arrays").
Date Thu, 25 May 2017 00:04:34 GMT
Repository: commons-math
Updated Branches:
  refs/heads/master 97dc91d15 -> 4a3727381


MATH-1416: Depend on "Commons Numbers" (module "commons-numbers-arrays").


Project: http://git-wip-us.apache.org/repos/asf/commons-math/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-math/commit/3200db16
Tree: http://git-wip-us.apache.org/repos/asf/commons-math/tree/3200db16
Diff: http://git-wip-us.apache.org/repos/asf/commons-math/diff/3200db16

Branch: refs/heads/master
Commit: 3200db1671d4b360abc43165cfb31e534966da92
Parents: 97dc91d
Author: Gilles <erans@apache.org>
Authored: Thu May 25 01:45:29 2017 +0200
Committer: Gilles <erans@apache.org>
Committed: Thu May 25 01:47:49 2017 +0200

----------------------------------------------------------------------
 pom.xml                                         |  6 +++
 .../commons/math4/analysis/FunctionUtils.java   |  4 +-
 .../analysis/differentiation/DSCompiler.java    |  8 ++--
 .../differentiation/DerivativeStructure.java    | 17 +++----
 .../differentiation/SparseGradient.java         | 20 ++++----
 .../BicubicInterpolatingFunction.java           |  3 +-
 .../interpolation/InterpolatingMicrosphere.java |  6 ++-
 .../geometry/euclidean/threed/Cartesian3D.java  | 30 ++++++------
 .../geometry/euclidean/threed/Rotation.java     | 20 ++++----
 .../geometry/euclidean/twod/Cartesian2D.java    |  8 ++--
 .../math4/geometry/euclidean/twod/Line.java     | 48 ++++++++++----------
 .../euclidean/twod/hull/ConvexHull2D.java       |  6 +--
 .../apache/commons/math4/util/Decimal64.java    | 17 +++----
 13 files changed, 102 insertions(+), 91 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/commons-math/blob/3200db16/pom.xml
----------------------------------------------------------------------
diff --git a/pom.xml b/pom.xml
index 817807b..b864093 100644
--- a/pom.xml
+++ b/pom.xml
@@ -380,6 +380,12 @@
 
     <dependency>
       <groupId>org.apache.commons</groupId>
+      <artifactId>commons-numbers-arrays</artifactId>
+      <version>1.0-SNAPSHOT</version>
+    </dependency>
+
+    <dependency>
+      <groupId>org.apache.commons</groupId>
       <artifactId>commons-rng-client-api</artifactId>
       <version>1.0</version>
     </dependency>

http://git-wip-us.apache.org/repos/asf/commons-math/blob/3200db16/src/main/java/org/apache/commons/math4/analysis/FunctionUtils.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/analysis/FunctionUtils.java b/src/main/java/org/apache/commons/math4/analysis/FunctionUtils.java
index fff715a..6c54879 100644
--- a/src/main/java/org/apache/commons/math4/analysis/FunctionUtils.java
+++ b/src/main/java/org/apache/commons/math4/analysis/FunctionUtils.java
@@ -17,6 +17,7 @@
 
 package org.apache.commons.math4.analysis;
 
+import org.apache.commons.numbers.arrays.LinearCombination;
 import org.apache.commons.math4.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.analysis.differentiation.MultivariateDifferentiableFunction;
 import org.apache.commons.math4.analysis.differentiation.UnivariateDifferentiableFunction;
@@ -25,7 +26,6 @@ import org.apache.commons.math4.exception.DimensionMismatchException;
 import org.apache.commons.math4.exception.NotStrictlyPositiveException;
 import org.apache.commons.math4.exception.NumberIsTooLargeException;
 import org.apache.commons.math4.exception.util.LocalizedFormats;
-import org.apache.commons.math4.util.MathArrays;
 
 /**
  * Utilities for manipulating function objects.
@@ -464,7 +464,7 @@ public class FunctionUtils {
                     orders[i] = 0;
 
                     // compose partial derivatives
-                    packed[i + 1] = MathArrays.linearCombination(dv, partials);
+                    packed[i + 1] = LinearCombination.value(dv, partials);
 
                 }
 

http://git-wip-us.apache.org/repos/asf/commons-math/blob/3200db16/src/main/java/org/apache/commons/math4/analysis/differentiation/DSCompiler.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/analysis/differentiation/DSCompiler.java
b/src/main/java/org/apache/commons/math4/analysis/differentiation/DSCompiler.java
index dd857de..03898ac 100644
--- a/src/main/java/org/apache/commons/math4/analysis/differentiation/DSCompiler.java
+++ b/src/main/java/org/apache/commons/math4/analysis/differentiation/DSCompiler.java
@@ -21,6 +21,7 @@ import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
 
+import org.apache.commons.numbers.arrays.LinearCombination;
 import org.apache.commons.math4.exception.DimensionMismatchException;
 import org.apache.commons.math4.exception.MathArithmeticException;
 import org.apache.commons.math4.exception.MathInternalError;
@@ -28,7 +29,6 @@ import org.apache.commons.math4.exception.NotPositiveException;
 import org.apache.commons.math4.exception.NumberIsTooLargeException;
 import org.apache.commons.numbers.combinatorics.FactorialDouble;
 import org.apache.commons.math4.util.FastMath;
-import org.apache.commons.math4.util.MathArrays;
 
 /** Class holding "compiled" computation rules for derivative structures.
  * <p>This class implements the computation rules described in Dan Kalman's paper <a
@@ -668,7 +668,7 @@ public class DSCompiler {
                                   final double[] result, final int resultOffset) {
         for (int i = 0; i < getSize(); ++i) {
             result[resultOffset + i] =
-                    MathArrays.linearCombination(a1, c1[offset1 + i], a2, c2[offset2 + i]);
+                    LinearCombination.value(a1, c1[offset1 + i], a2, c2[offset2 + i]);
         }
     }
 
@@ -693,7 +693,7 @@ public class DSCompiler {
                                   final double[] result, final int resultOffset) {
         for (int i = 0; i < getSize(); ++i) {
             result[resultOffset + i] =
-                    MathArrays.linearCombination(a1, c1[offset1 + i],
+                    LinearCombination.value(a1, c1[offset1 + i],
                                                  a2, c2[offset2 + i],
                                                  a3, c3[offset3 + i]);
         }
@@ -724,7 +724,7 @@ public class DSCompiler {
                                   final double[] result, final int resultOffset) {
         for (int i = 0; i < getSize(); ++i) {
             result[resultOffset + i] =
-                    MathArrays.linearCombination(a1, c1[offset1 + i],
+                    LinearCombination.value(a1, c1[offset1 + i],
                                                  a2, c2[offset2 + i],
                                                  a3, c3[offset3 + i],
                                                  a4, c4[offset4 + i]);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/3200db16/src/main/java/org/apache/commons/math4/analysis/differentiation/DerivativeStructure.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/analysis/differentiation/DerivativeStructure.java
b/src/main/java/org/apache/commons/math4/analysis/differentiation/DerivativeStructure.java
index 887d890..6a6b390 100644
--- a/src/main/java/org/apache/commons/math4/analysis/differentiation/DerivativeStructure.java
+++ b/src/main/java/org/apache/commons/math4/analysis/differentiation/DerivativeStructure.java
@@ -18,6 +18,7 @@ package org.apache.commons.math4.analysis.differentiation;
 
 import java.io.Serializable;
 
+import org.apache.commons.numbers.arrays.LinearCombination;
 import org.apache.commons.math4.Field;
 import org.apache.commons.math4.FieldElement;
 import org.apache.commons.math4.RealFieldElement;
@@ -965,7 +966,7 @@ public class DerivativeStructure implements RealFieldElement<DerivativeStructure
         for (int i = 0; i < b.length; ++i) {
             bDouble[i] = b[i].getValue();
         }
-        final double accurateValue = MathArrays.linearCombination(aDouble, bDouble);
+        final double accurateValue = LinearCombination.value(aDouble, bDouble);
 
         // compute a simple value, with all partial derivatives
         DerivativeStructure simpleValue = a[0].getField().getZero();
@@ -994,7 +995,7 @@ public class DerivativeStructure implements RealFieldElement<DerivativeStructure
         for (int i = 0; i < b.length; ++i) {
             bDouble[i] = b[i].getValue();
         }
-        final double accurateValue = MathArrays.linearCombination(a, bDouble);
+        final double accurateValue = LinearCombination.value(a, bDouble);
 
         // compute a simple value, with all partial derivatives
         DerivativeStructure simpleValue = b[0].getField().getZero();
@@ -1020,7 +1021,7 @@ public class DerivativeStructure implements RealFieldElement<DerivativeStructure
         throws DimensionMismatchException {
 
         // compute an accurate value, taking care of cancellations
-        final double accurateValue = MathArrays.linearCombination(a1.getValue(), b1.getValue(),
+        final double accurateValue = LinearCombination.value(a1.getValue(), b1.getValue(),
                                                                   a2.getValue(), b2.getValue());
 
         // compute a simple value, with all partial derivatives
@@ -1044,7 +1045,7 @@ public class DerivativeStructure implements RealFieldElement<DerivativeStructure
         throws DimensionMismatchException {
 
         // compute an accurate value, taking care of cancellations
-        final double accurateValue = MathArrays.linearCombination(a1, b1.getValue(),
+        final double accurateValue = LinearCombination.value(a1, b1.getValue(),
                                                                   a2, b2.getValue());
 
         // compute a simple value, with all partial derivatives
@@ -1069,7 +1070,7 @@ public class DerivativeStructure implements RealFieldElement<DerivativeStructure
         throws DimensionMismatchException {
 
         // compute an accurate value, taking care of cancellations
-        final double accurateValue = MathArrays.linearCombination(a1.getValue(), b1.getValue(),
+        final double accurateValue = LinearCombination.value(a1.getValue(), b1.getValue(),
                                                                   a2.getValue(), b2.getValue(),
                                                                   a3.getValue(), b3.getValue());
 
@@ -1095,7 +1096,7 @@ public class DerivativeStructure implements RealFieldElement<DerivativeStructure
         throws DimensionMismatchException {
 
         // compute an accurate value, taking care of cancellations
-        final double accurateValue = MathArrays.linearCombination(a1, b1.getValue(),
+        final double accurateValue = LinearCombination.value(a1, b1.getValue(),
                                                                   a2, b2.getValue(),
                                                                   a3, b3.getValue());
 
@@ -1122,7 +1123,7 @@ public class DerivativeStructure implements RealFieldElement<DerivativeStructure
         throws DimensionMismatchException {
 
         // compute an accurate value, taking care of cancellations
-        final double accurateValue = MathArrays.linearCombination(a1.getValue(), b1.getValue(),
+        final double accurateValue = LinearCombination.value(a1.getValue(), b1.getValue(),
                                                                   a2.getValue(), b2.getValue(),
                                                                   a3.getValue(), b3.getValue(),
                                                                   a4.getValue(), b4.getValue());
@@ -1150,7 +1151,7 @@ public class DerivativeStructure implements RealFieldElement<DerivativeStructure
         throws DimensionMismatchException {
 
         // compute an accurate value, taking care of cancellations
-        final double accurateValue = MathArrays.linearCombination(a1, b1.getValue(),
+        final double accurateValue = LinearCombination.value(a1, b1.getValue(),
                                                                   a2, b2.getValue(),
                                                                   a3, b3.getValue(),
                                                                   a4, b4.getValue());

http://git-wip-us.apache.org/repos/asf/commons-math/blob/3200db16/src/main/java/org/apache/commons/math4/analysis/differentiation/SparseGradient.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/analysis/differentiation/SparseGradient.java
b/src/main/java/org/apache/commons/math4/analysis/differentiation/SparseGradient.java
index c642fed..13893cd 100644
--- a/src/main/java/org/apache/commons/math4/analysis/differentiation/SparseGradient.java
+++ b/src/main/java/org/apache/commons/math4/analysis/differentiation/SparseGradient.java
@@ -21,14 +21,14 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 
+import org.apache.commons.numbers.arrays.LinearCombination;
+import org.apache.commons.numbers.core.Precision;
 import org.apache.commons.math4.Field;
 import org.apache.commons.math4.FieldElement;
 import org.apache.commons.math4.RealFieldElement;
 import org.apache.commons.math4.exception.DimensionMismatchException;
 import org.apache.commons.math4.util.FastMath;
-import org.apache.commons.math4.util.MathArrays;
 import org.apache.commons.math4.util.MathUtils;
-import org.apache.commons.numbers.core.Precision;
 
 /**
  * First derivative computation with large number of variables.
@@ -752,7 +752,7 @@ public class SparseGradient implements RealFieldElement<SparseGradient>,
Seriali
         for (int i = 0; i < b.length; ++i) {
             bDouble[i] = b[i].getValue();
         }
-        out.value = MathArrays.linearCombination(aDouble, bDouble);
+        out.value = LinearCombination.value(aDouble, bDouble);
 
         return out;
 
@@ -773,7 +773,7 @@ public class SparseGradient implements RealFieldElement<SparseGradient>,
Seriali
         for (int i = 0; i < b.length; ++i) {
             bDouble[i] = b[i].getValue();
         }
-        out.value = MathArrays.linearCombination(a, bDouble);
+        out.value = LinearCombination.value(a, bDouble);
 
         return out;
 
@@ -788,7 +788,7 @@ public class SparseGradient implements RealFieldElement<SparseGradient>,
Seriali
         SparseGradient out = a1.multiply(b1).add(a2.multiply(b2));
 
         // recompute an accurate value, taking care of cancellations
-        out.value = MathArrays.linearCombination(a1.value, b1.value, a2.value, b2.value);
+        out.value = LinearCombination.value(a1.value, b1.value, a2.value, b2.value);
 
         return out;
 
@@ -803,7 +803,7 @@ public class SparseGradient implements RealFieldElement<SparseGradient>,
Seriali
         SparseGradient out = b1.multiply(a1).add(b2.multiply(a2));
 
         // recompute an accurate value, taking care of cancellations
-        out.value = MathArrays.linearCombination(a1, b1.value, a2, b2.value);
+        out.value = LinearCombination.value(a1, b1.value, a2, b2.value);
 
         return out;
 
@@ -819,7 +819,7 @@ public class SparseGradient implements RealFieldElement<SparseGradient>,
Seriali
         SparseGradient out = a1.multiply(b1).add(a2.multiply(b2)).add(a3.multiply(b3));
 
         // recompute an accurate value, taking care of cancellations
-        out.value = MathArrays.linearCombination(a1.value, b1.value,
+        out.value = LinearCombination.value(a1.value, b1.value,
                                                  a2.value, b2.value,
                                                  a3.value, b3.value);
 
@@ -837,7 +837,7 @@ public class SparseGradient implements RealFieldElement<SparseGradient>,
Seriali
         SparseGradient out = b1.multiply(a1).add(b2.multiply(a2)).add(b3.multiply(a3));
 
         // recompute an accurate value, taking care of cancellations
-        out.value = MathArrays.linearCombination(a1, b1.value,
+        out.value = LinearCombination.value(a1, b1.value,
                                                  a2, b2.value,
                                                  a3, b3.value);
 
@@ -856,7 +856,7 @@ public class SparseGradient implements RealFieldElement<SparseGradient>,
Seriali
         SparseGradient out = a1.multiply(b1).add(a2.multiply(b2)).add(a3.multiply(b3)).add(a4.multiply(b4));
 
         // recompute an accurate value, taking care of cancellations
-        out.value = MathArrays.linearCombination(a1.value, b1.value,
+        out.value = LinearCombination.value(a1.value, b1.value,
                                                  a2.value, b2.value,
                                                  a3.value, b3.value,
                                                  a4.value, b4.value);
@@ -876,7 +876,7 @@ public class SparseGradient implements RealFieldElement<SparseGradient>,
Seriali
         SparseGradient out = b1.multiply(a1).add(b2.multiply(a2)).add(b3.multiply(a3)).add(b4.multiply(a4));
 
         // recompute an accurate value, taking care of cancellations
-        out.value = MathArrays.linearCombination(a1, b1.value,
+        out.value = LinearCombination.value(a1, b1.value,
                                                  a2, b2.value,
                                                  a3, b3.value,
                                                  a4, b4.value);

http://git-wip-us.apache.org/repos/asf/commons-math/blob/3200db16/src/main/java/org/apache/commons/math4/analysis/interpolation/BicubicInterpolatingFunction.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/analysis/interpolation/BicubicInterpolatingFunction.java
b/src/main/java/org/apache/commons/math4/analysis/interpolation/BicubicInterpolatingFunction.java
index 4ded79d..aa23502 100644
--- a/src/main/java/org/apache/commons/math4/analysis/interpolation/BicubicInterpolatingFunction.java
+++ b/src/main/java/org/apache/commons/math4/analysis/interpolation/BicubicInterpolatingFunction.java
@@ -18,6 +18,7 @@ package org.apache.commons.math4.analysis.interpolation;
 
 import java.util.Arrays;
 
+import org.apache.commons.numbers.arrays.LinearCombination;
 import org.apache.commons.math4.analysis.BivariateFunction;
 import org.apache.commons.math4.exception.DimensionMismatchException;
 import org.apache.commons.math4.exception.NoDataException;
@@ -319,7 +320,7 @@ class BicubicFunction implements BivariateFunction {
     private double apply(double[] pX, double[] pY, double[][] coeff) {
         double result = 0;
         for (int i = 0; i < N; i++) {
-            final double r = MathArrays.linearCombination(coeff[i], pY);
+            final double r = LinearCombination.value(coeff[i], pY);
             result += r * pX[i];
         }
 

http://git-wip-us.apache.org/repos/asf/commons-math/blob/3200db16/src/main/java/org/apache/commons/math4/analysis/interpolation/InterpolatingMicrosphere.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/analysis/interpolation/InterpolatingMicrosphere.java
b/src/main/java/org/apache/commons/math4/analysis/interpolation/InterpolatingMicrosphere.java
index 4887d80..893a760 100644
--- a/src/main/java/org/apache/commons/math4/analysis/interpolation/InterpolatingMicrosphere.java
+++ b/src/main/java/org/apache/commons/math4/analysis/interpolation/InterpolatingMicrosphere.java
@@ -18,6 +18,8 @@ package org.apache.commons.math4.analysis.interpolation;
 
 import java.util.List;
 import java.util.ArrayList;
+import org.apache.commons.numbers.arrays.CosAngle;
+import org.apache.commons.numbers.arrays.SafeNorm;
 import org.apache.commons.math4.random.UnitSphereRandomVectorGenerator;
 import org.apache.commons.math4.exception.DimensionMismatchException;
 import org.apache.commons.math4.exception.NotPositiveException;
@@ -220,7 +222,7 @@ public class InterpolatingMicrosphere {
         for (int i = 0; i < numSamples; i++) {
             // Vector between interpolation point and current sample point.
             final double[] diff = MathArrays.ebeSubtract(samplePoints[i], point);
-            final double diffNorm = MathArrays.safeNorm(diff);
+            final double diffNorm = SafeNorm.value(diff);
 
             if (FastMath.abs(diffNorm) < noInterpolationTolerance) {
                 // No need to interpolate, as the interpolation point is
@@ -301,7 +303,7 @@ public class InterpolatingMicrosphere {
                             double weight) {
         for (int i = 0; i < size; i++) {
             final double[] n = microsphere.get(i).getNormal();
-            final double cos = MathArrays.cosAngle(n, sampleDirection);
+            final double cos = CosAngle.value(n, sampleDirection);
 
             if (cos > 0) {
                 final double illumination = cos * weight;

http://git-wip-us.apache.org/repos/asf/commons-math/blob/3200db16/src/main/java/org/apache/commons/math4/geometry/euclidean/threed/Cartesian3D.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/geometry/euclidean/threed/Cartesian3D.java
b/src/main/java/org/apache/commons/math4/geometry/euclidean/threed/Cartesian3D.java
index a1468b9..774a5ba 100644
--- a/src/main/java/org/apache/commons/math4/geometry/euclidean/threed/Cartesian3D.java
+++ b/src/main/java/org/apache/commons/math4/geometry/euclidean/threed/Cartesian3D.java
@@ -20,6 +20,7 @@ package org.apache.commons.math4.geometry.euclidean.threed;
 import java.io.Serializable;
 import java.text.NumberFormat;
 
+import org.apache.commons.numbers.arrays.LinearCombination;
 import org.apache.commons.math4.exception.DimensionMismatchException;
 import org.apache.commons.math4.exception.MathArithmeticException;
 import org.apache.commons.math4.exception.util.LocalizedFormats;
@@ -27,7 +28,6 @@ import org.apache.commons.math4.geometry.Point;
 import org.apache.commons.math4.geometry.Space;
 import org.apache.commons.math4.geometry.Vector;
 import org.apache.commons.math4.util.FastMath;
-import org.apache.commons.math4.util.MathArrays;
 import org.apache.commons.math4.util.MathUtils;
 
 /**
@@ -153,9 +153,9 @@ public class Cartesian3D extends Vector3D implements Serializable, Point<Euclide
      * @param u2 second base (unscaled) vector
      */
     public Cartesian3D(double a1, Cartesian3D u1, double a2, Cartesian3D u2) {
-        this.x = MathArrays.linearCombination(a1, u1.x, a2, u2.x);
-        this.y = MathArrays.linearCombination(a1, u1.y, a2, u2.y);
-        this.z = MathArrays.linearCombination(a1, u1.z, a2, u2.z);
+        this.x = LinearCombination.value(a1, u1.x, a2, u2.x);
+        this.y = LinearCombination.value(a1, u1.y, a2, u2.y);
+        this.z = LinearCombination.value(a1, u1.z, a2, u2.z);
     }
 
     /** Linear constructor
@@ -170,9 +170,9 @@ public class Cartesian3D extends Vector3D implements Serializable, Point<Euclide
      */
     public Cartesian3D(double a1, Cartesian3D u1, double a2, Cartesian3D u2,
                     double a3, Cartesian3D u3) {
-        this.x = MathArrays.linearCombination(a1, u1.x, a2, u2.x, a3, u3.x);
-        this.y = MathArrays.linearCombination(a1, u1.y, a2, u2.y, a3, u3.y);
-        this.z = MathArrays.linearCombination(a1, u1.z, a2, u2.z, a3, u3.z);
+        this.x = LinearCombination.value(a1, u1.x, a2, u2.x, a3, u3.x);
+        this.y = LinearCombination.value(a1, u1.y, a2, u2.y, a3, u3.y);
+        this.z = LinearCombination.value(a1, u1.z, a2, u2.z, a3, u3.z);
     }
 
     /** Linear constructor
@@ -189,9 +189,9 @@ public class Cartesian3D extends Vector3D implements Serializable, Point<Euclide
      */
     public Cartesian3D(double a1, Cartesian3D u1, double a2, Cartesian3D u2,
                     double a3, Cartesian3D u3, double a4, Cartesian3D u4) {
-        this.x = MathArrays.linearCombination(a1, u1.x, a2, u2.x, a3, u3.x, a4, u4.x);
-        this.y = MathArrays.linearCombination(a1, u1.y, a2, u2.y, a3, u3.y, a4, u4.y);
-        this.z = MathArrays.linearCombination(a1, u1.z, a2, u2.z, a3, u3.z, a4, u4.z);
+        this.x = LinearCombination.value(a1, u1.x, a2, u2.x, a3, u3.x, a4, u4.x);
+        this.y = LinearCombination.value(a1, u1.y, a2, u2.y, a3, u3.y, a4, u4.y);
+        this.z = LinearCombination.value(a1, u1.z, a2, u2.z, a3, u3.z, a4, u4.z);
     }
 
     /** Get the abscissa of the vector.
@@ -466,12 +466,12 @@ public class Cartesian3D extends Vector3D implements Serializable, Point<Euclide
      * algorithms to preserve accuracy and reduce cancellation effects.
      * It should be very accurate even for nearly orthogonal vectors.
      * </p>
-     * @see MathArrays#linearCombination(double, double, double, double, double, double)
+     * @see LinearCombination#value(double, double, double, double, double, double)
      */
     @Override
     public double dotProduct(final Vector<Euclidean3D> v) {
         final Cartesian3D v3 = (Cartesian3D) v;
-        return MathArrays.linearCombination(x, v3.x, y, v3.y, z, v3.z);
+        return LinearCombination.value(x, v3.x, y, v3.y, z, v3.z);
     }
 
     /** Compute the cross-product of the instance with another vector.
@@ -480,9 +480,9 @@ public class Cartesian3D extends Vector3D implements Serializable, Point<Euclide
      */
     public Cartesian3D crossProduct(final Vector<Euclidean3D> v) {
         final Cartesian3D v3 = (Cartesian3D) v;
-        return new Cartesian3D(MathArrays.linearCombination(y, v3.z, -z, v3.y),
-                            MathArrays.linearCombination(z, v3.x, -x, v3.z),
-                            MathArrays.linearCombination(x, v3.y, -y, v3.x));
+        return new Cartesian3D(LinearCombination.value(y, v3.z, -z, v3.y),
+                            LinearCombination.value(z, v3.x, -x, v3.z),
+                            LinearCombination.value(x, v3.y, -y, v3.x));
     }
 
     /** {@inheritDoc} */

http://git-wip-us.apache.org/repos/asf/commons-math/blob/3200db16/src/main/java/org/apache/commons/math4/geometry/euclidean/threed/Rotation.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/geometry/euclidean/threed/Rotation.java
b/src/main/java/org/apache/commons/math4/geometry/euclidean/threed/Rotation.java
index 59517ba..4d18e52 100644
--- a/src/main/java/org/apache/commons/math4/geometry/euclidean/threed/Rotation.java
+++ b/src/main/java/org/apache/commons/math4/geometry/euclidean/threed/Rotation.java
@@ -19,11 +19,11 @@ package org.apache.commons.math4.geometry.euclidean.threed;
 
 import java.io.Serializable;
 
+import org.apache.commons.numbers.arrays.LinearCombination;
 import org.apache.commons.math4.exception.MathArithmeticException;
 import org.apache.commons.math4.exception.MathIllegalArgumentException;
 import org.apache.commons.math4.exception.util.LocalizedFormats;
 import org.apache.commons.math4.util.FastMath;
-import org.apache.commons.math4.util.MathArrays;
 
 /**
  * This class implements rotations in a three-dimensional space.
@@ -290,19 +290,19 @@ public class Rotation implements Serializable {
       // buid a matrix transforming the first base into the second one
       final double[][] m = new double[][] {
           {
-              MathArrays.linearCombination(u1.getX(), v1.getX(), u2.getX(), v2.getX(), u3.getX(),
v3.getX()),
-              MathArrays.linearCombination(u1.getY(), v1.getX(), u2.getY(), v2.getX(), u3.getY(),
v3.getX()),
-              MathArrays.linearCombination(u1.getZ(), v1.getX(), u2.getZ(), v2.getX(), u3.getZ(),
v3.getX())
+              LinearCombination.value(u1.getX(), v1.getX(), u2.getX(), v2.getX(), u3.getX(),
v3.getX()),
+              LinearCombination.value(u1.getY(), v1.getX(), u2.getY(), v2.getX(), u3.getY(),
v3.getX()),
+              LinearCombination.value(u1.getZ(), v1.getX(), u2.getZ(), v2.getX(), u3.getZ(),
v3.getX())
           },
           {
-              MathArrays.linearCombination(u1.getX(), v1.getY(), u2.getX(), v2.getY(), u3.getX(),
v3.getY()),
-              MathArrays.linearCombination(u1.getY(), v1.getY(), u2.getY(), v2.getY(), u3.getY(),
v3.getY()),
-              MathArrays.linearCombination(u1.getZ(), v1.getY(), u2.getZ(), v2.getY(), u3.getZ(),
v3.getY())
+              LinearCombination.value(u1.getX(), v1.getY(), u2.getX(), v2.getY(), u3.getX(),
v3.getY()),
+              LinearCombination.value(u1.getY(), v1.getY(), u2.getY(), v2.getY(), u3.getY(),
v3.getY()),
+              LinearCombination.value(u1.getZ(), v1.getY(), u2.getZ(), v2.getY(), u3.getZ(),
v3.getY())
           },
           {
-              MathArrays.linearCombination(u1.getX(), v1.getZ(), u2.getX(), v2.getZ(), u3.getX(),
v3.getZ()),
-              MathArrays.linearCombination(u1.getY(), v1.getZ(), u2.getY(), v2.getZ(), u3.getY(),
v3.getZ()),
-              MathArrays.linearCombination(u1.getZ(), v1.getZ(), u2.getZ(), v2.getZ(), u3.getZ(),
v3.getZ())
+              LinearCombination.value(u1.getX(), v1.getZ(), u2.getX(), v2.getZ(), u3.getX(),
v3.getZ()),
+              LinearCombination.value(u1.getY(), v1.getZ(), u2.getY(), v2.getZ(), u3.getY(),
v3.getZ()),
+              LinearCombination.value(u1.getZ(), v1.getZ(), u2.getZ(), v2.getZ(), u3.getZ(),
v3.getZ())
           }
       };
 

http://git-wip-us.apache.org/repos/asf/commons-math/blob/3200db16/src/main/java/org/apache/commons/math4/geometry/euclidean/twod/Cartesian2D.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/geometry/euclidean/twod/Cartesian2D.java
b/src/main/java/org/apache/commons/math4/geometry/euclidean/twod/Cartesian2D.java
index 7e68362..1198ff6 100644
--- a/src/main/java/org/apache/commons/math4/geometry/euclidean/twod/Cartesian2D.java
+++ b/src/main/java/org/apache/commons/math4/geometry/euclidean/twod/Cartesian2D.java
@@ -18,6 +18,7 @@ package org.apache.commons.math4.geometry.euclidean.twod;
 
 import java.text.NumberFormat;
 
+import org.apache.commons.numbers.arrays.LinearCombination;
 import org.apache.commons.math4.exception.DimensionMismatchException;
 import org.apache.commons.math4.exception.MathArithmeticException;
 import org.apache.commons.math4.exception.util.LocalizedFormats;
@@ -25,7 +26,6 @@ import org.apache.commons.math4.geometry.Point;
 import org.apache.commons.math4.geometry.Space;
 import org.apache.commons.math4.geometry.Vector;
 import org.apache.commons.math4.util.FastMath;
-import org.apache.commons.math4.util.MathArrays;
 import org.apache.commons.math4.util.MathUtils;
 
 /** This class represents a 2D point or a 2D vector.
@@ -267,7 +267,7 @@ public class Cartesian2D extends Vector2D implements Point<Euclidean2D>
{
         double threshold = normProduct * 0.9999;
         if ((dot < -threshold) || (dot > threshold)) {
             // the vectors are almost aligned, compute using the sine
-            final double n = FastMath.abs(MathArrays.linearCombination(v1.x, v2.y, -v1.y,
v2.x));
+            final double n = FastMath.abs(LinearCombination.value(v1.x, v2.y, -v1.y, v2.x));
             if (dot >= 0) {
                 return FastMath.asin(n / normProduct);
             }
@@ -356,7 +356,7 @@ public class Cartesian2D extends Vector2D implements Point<Euclidean2D>
{
     @Override
     public double dotProduct(final Vector<Euclidean2D> v) {
         final Cartesian2D v2 = (Cartesian2D) v;
-        return MathArrays.linearCombination(x, v2.x, y, v2.y);
+        return LinearCombination.value(x, v2.x, y, v2.y);
     }
 
     /**
@@ -384,7 +384,7 @@ public class Cartesian2D extends Vector2D implements Point<Euclidean2D>
{
         final double y1 = getY() - p1.getY();
         final double x2 = getX() - p1.getX();
         final double y2 = p2.getY() - p1.getY();
-        return MathArrays.linearCombination(x1, y1, -x2, y2);
+        return LinearCombination.value(x1, y1, -x2, y2);
     }
 
     /** Compute the distance between two points according to the L<sub>2</sub>
norm.

http://git-wip-us.apache.org/repos/asf/commons-math/blob/3200db16/src/main/java/org/apache/commons/math4/geometry/euclidean/twod/Line.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/geometry/euclidean/twod/Line.java b/src/main/java/org/apache/commons/math4/geometry/euclidean/twod/Line.java
index 561cdc7..076179b 100644
--- a/src/main/java/org/apache/commons/math4/geometry/euclidean/twod/Line.java
+++ b/src/main/java/org/apache/commons/math4/geometry/euclidean/twod/Line.java
@@ -16,6 +16,7 @@
  */
 package org.apache.commons.math4.geometry.euclidean.twod;
 
+import org.apache.commons.numbers.arrays.LinearCombination;
 import org.apache.commons.math4.exception.MathIllegalArgumentException;
 import org.apache.commons.math4.exception.util.LocalizedFormats;
 import org.apache.commons.math4.geometry.Point;
@@ -29,7 +30,6 @@ import org.apache.commons.math4.geometry.partitioning.Hyperplane;
 import org.apache.commons.math4.geometry.partitioning.SubHyperplane;
 import org.apache.commons.math4.geometry.partitioning.Transform;
 import org.apache.commons.math4.util.FastMath;
-import org.apache.commons.math4.util.MathArrays;
 import org.apache.commons.math4.util.MathUtils;
 
 /** This class represents an oriented line in the 2D plane.
@@ -158,7 +158,7 @@ public class Line implements Hyperplane<Euclidean2D>, Embedding<Euclidean2D,
Euc
             angle        = FastMath.PI + FastMath.atan2(-dy, -dx);
             cos          = dx / d;
             sin          = dy / d;
-            originOffset = MathArrays.linearCombination(p2.getX(), p1.getY(), -p1.getX(),
p2.getY()) / d;
+            originOffset = LinearCombination.value(p2.getX(), p1.getY(), -p1.getX(), p2.getY())
/ d;
         }
     }
 
@@ -171,7 +171,7 @@ public class Line implements Hyperplane<Euclidean2D>, Embedding<Euclidean2D,
Euc
         this.angle   = MathUtils.normalizeAngle(alpha, FastMath.PI);
         cos          = FastMath.cos(this.angle);
         sin          = FastMath.sin(this.angle);
-        originOffset = MathArrays.linearCombination(cos, p.getY(), -sin, p.getX());
+        originOffset = LinearCombination.value(cos, p.getY(), -sin, p.getX());
     }
 
     /** Revert the instance.
@@ -257,7 +257,7 @@ public class Line implements Hyperplane<Euclidean2D>, Embedding<Euclidean2D,
Euc
      * the specified space point
      */
     public Cartesian1D toSubSpace(final Cartesian2D cartesian) {
-        return new Cartesian1D(MathArrays.linearCombination(cos, cartesian.getX(), sin, cartesian.getY()));
+        return new Cartesian1D(LinearCombination.value(cos, cartesian.getX(), sin, cartesian.getY()));
     }
 
     /** Transform a sub-space point into a space point.
@@ -267,8 +267,8 @@ public class Line implements Hyperplane<Euclidean2D>, Embedding<Euclidean2D,
Euc
      */
     public Cartesian2D toSpace(Cartesian1D cartesian) {
         final double abscissa = cartesian.getX();
-        return new Cartesian2D(MathArrays.linearCombination(abscissa, cos, -originOffset,
sin),
-                            MathArrays.linearCombination(abscissa, sin,  originOffset, cos));
+        return new Cartesian2D(LinearCombination.value(abscissa, cos, -originOffset, sin),
+                            LinearCombination.value(abscissa, sin,  originOffset, cos));
     }
 
     /** Get the intersection point of the instance and another line.
@@ -277,12 +277,12 @@ public class Line implements Hyperplane<Euclidean2D>, Embedding<Euclidean2D,
Euc
      * or null if there are no intersection points
      */
     public Cartesian2D intersection(final Line other) {
-        final double d = MathArrays.linearCombination(sin, other.cos, -other.sin, cos);
+        final double d = LinearCombination.value(sin, other.cos, -other.sin, cos);
         if (FastMath.abs(d) < tolerance) {
             return null;
         }
-        return new Cartesian2D(MathArrays.linearCombination(cos, other.originOffset, -other.cos,
originOffset) / d,
-                            MathArrays.linearCombination(sin, other.originOffset, -other.sin,
originOffset) / d);
+        return new Cartesian2D(LinearCombination.value(cos, other.originOffset, -other.cos,
originOffset) / d,
+                            LinearCombination.value(sin, other.originOffset, -other.sin,
originOffset) / d);
     }
 
     /** {@inheritDoc}
@@ -328,7 +328,7 @@ public class Line implements Hyperplane<Euclidean2D>, Embedding<Euclidean2D,
Euc
      */
     public double getOffset(final Line line) {
         return originOffset +
-               (MathArrays.linearCombination(cos, line.cos, sin, line.sin) > 0 ? -line.originOffset
: line.originOffset);
+               (LinearCombination.value(cos, line.cos, sin, line.sin) > 0 ? -line.originOffset
: line.originOffset);
     }
 
     /** Get the offset (oriented distance) of a vector.
@@ -350,14 +350,14 @@ public class Line implements Hyperplane<Euclidean2D>, Embedding<Euclidean2D,
Euc
      * @return offset of the point
      */
     public double getOffset(Cartesian2D cartesian) {
-        return MathArrays.linearCombination(sin, cartesian.getX(), -cos, cartesian.getY(),
1.0, originOffset);
+        return LinearCombination.value(sin, cartesian.getX(), -cos, cartesian.getY(), 1.0,
originOffset);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean sameOrientationAs(final Hyperplane<Euclidean2D> other) {
         final Line otherL = (Line) other;
-        return MathArrays.linearCombination(sin, otherL.sin, cos, otherL.cos) >= 0.0;
+        return LinearCombination.value(sin, otherL.sin, cos, otherL.cos) >= 0.0;
     }
 
     /** Get one point from the plane.
@@ -369,8 +369,8 @@ public class Line implements Hyperplane<Euclidean2D>, Embedding<Euclidean2D,
Euc
     public Cartesian2D getPointAt(final Cartesian1D abscissa, final double offset) {
         final double x       = abscissa.getX();
         final double dOffset = offset - originOffset;
-        return new Cartesian2D(MathArrays.linearCombination(x, cos,  dOffset, sin),
-                            MathArrays.linearCombination(x, sin, -dOffset, cos));
+        return new Cartesian2D(LinearCombination.value(x, cos,  dOffset, sin),
+                            LinearCombination.value(x, sin, -dOffset, cos));
     }
 
     /** Check if the line contains a point.
@@ -400,14 +400,14 @@ public class Line implements Hyperplane<Euclidean2D>, Embedding<Euclidean2D,
Euc
      * (they can have either the same or opposite orientations)
      */
     public boolean isParallelTo(final Line line) {
-        return FastMath.abs(MathArrays.linearCombination(sin, line.cos, -cos, line.sin))
< tolerance;
+        return FastMath.abs(LinearCombination.value(sin, line.cos, -cos, line.sin)) <
tolerance;
     }
 
     /** Translate the line to force it passing by a point.
      * @param p point by which the line should pass
      */
     public void translateToPoint(final Cartesian2D p) {
-        originOffset = MathArrays.linearCombination(cos, p.getY(), -sin, p.getX());
+        originOffset = LinearCombination.value(cos, p.getY(), -sin, p.getX());
     }
 
     /** Get the angle of the line.
@@ -524,9 +524,9 @@ public class Line implements Hyperplane<Euclidean2D>, Embedding<Euclidean2D,
Euc
             this.cX1 = cX1;
             this.cY1 = cY1;
 
-            c1Y = MathArrays.linearCombination(cXY, cY1, -cYY, cX1);
-            c1X = MathArrays.linearCombination(cXX, cY1, -cYX, cX1);
-            c11 = MathArrays.linearCombination(cXX, cYY, -cYX, cXY);
+            c1Y = LinearCombination.value(cXY, cY1, -cYY, cX1);
+            c1X = LinearCombination.value(cXX, cY1, -cYX, cX1);
+            c11 = LinearCombination.value(cXX, cYY, -cYX, cXY);
 
             if (FastMath.abs(c11) < 1.0e-20) {
                 throw new MathIllegalArgumentException(LocalizedFormats.NON_INVERTIBLE_TRANSFORM);
@@ -540,17 +540,17 @@ public class Line implements Hyperplane<Euclidean2D>, Embedding<Euclidean2D,
Euc
             final Cartesian2D p2D = (Cartesian2D) point;
             final double  x   = p2D.getX();
             final double  y   = p2D.getY();
-            return new Cartesian2D(MathArrays.linearCombination(cXX, x, cXY, y, cX1, 1),
-                                MathArrays.linearCombination(cYX, x, cYY, y, cY1, 1));
+            return new Cartesian2D(LinearCombination.value(cXX, x, cXY, y, cX1, 1),
+                                LinearCombination.value(cYX, x, cYY, y, cY1, 1));
         }
 
         /** {@inheritDoc} */
         @Override
         public Line apply(final Hyperplane<Euclidean2D> hyperplane) {
             final Line   line    = (Line) hyperplane;
-            final double rOffset = MathArrays.linearCombination(c1X, line.cos, c1Y, line.sin,
c11, line.originOffset);
-            final double rCos    = MathArrays.linearCombination(cXX, line.cos, cXY, line.sin);
-            final double rSin    = MathArrays.linearCombination(cYX, line.cos, cYY, line.sin);
+            final double rOffset = LinearCombination.value(c1X, line.cos, c1Y, line.sin,
c11, line.originOffset);
+            final double rCos    = LinearCombination.value(cXX, line.cos, cXY, line.sin);
+            final double rSin    = LinearCombination.value(cYX, line.cos, cYY, line.sin);
             final double inv     = 1.0 / FastMath.sqrt(rSin * rSin + rCos * rCos);
             return new Line(FastMath.PI + FastMath.atan2(-rSin, -rCos),
                             inv * rCos, inv * rSin,

http://git-wip-us.apache.org/repos/asf/commons-math/blob/3200db16/src/main/java/org/apache/commons/math4/geometry/euclidean/twod/hull/ConvexHull2D.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/geometry/euclidean/twod/hull/ConvexHull2D.java
b/src/main/java/org/apache/commons/math4/geometry/euclidean/twod/hull/ConvexHull2D.java
index 239c85f..0ba9fa9 100644
--- a/src/main/java/org/apache/commons/math4/geometry/euclidean/twod/hull/ConvexHull2D.java
+++ b/src/main/java/org/apache/commons/math4/geometry/euclidean/twod/hull/ConvexHull2D.java
@@ -18,6 +18,8 @@ package org.apache.commons.math4.geometry.euclidean.twod.hull;
 
 import java.io.Serializable;
 
+import org.apache.commons.numbers.arrays.LinearCombination;
+import org.apache.commons.numbers.core.Precision;
 import org.apache.commons.math4.exception.InsufficientDataException;
 import org.apache.commons.math4.exception.MathIllegalArgumentException;
 import org.apache.commons.math4.exception.util.LocalizedFormats;
@@ -28,8 +30,6 @@ import org.apache.commons.math4.geometry.euclidean.twod.Cartesian2D;
 import org.apache.commons.math4.geometry.hull.ConvexHull;
 import org.apache.commons.math4.geometry.partitioning.Region;
 import org.apache.commons.math4.geometry.partitioning.RegionFactory;
-import org.apache.commons.math4.util.MathArrays;
-import org.apache.commons.numbers.core.Precision;
 
 /**
  * This class represents a convex hull in an two-dimensional euclidean space.
@@ -91,7 +91,7 @@ public class ConvexHull2D implements ConvexHull<Euclidean2D, Cartesian2D>,
Seria
             final Cartesian2D d1 = p2.subtract(p1);
             final Cartesian2D d2 = p3.subtract(p2);
 
-            final double crossProduct = MathArrays.linearCombination(d1.getX(), d2.getY(),
-d1.getY(), d2.getX());
+            final double crossProduct = LinearCombination.value(d1.getX(), d2.getY(), -d1.getY(),
d2.getX());
             final int cmp = Precision.compareTo(crossProduct, 0.0, tolerance);
             // in case of collinear points the cross product will be zero
             if (cmp != 0.0) {

http://git-wip-us.apache.org/repos/asf/commons-math/blob/3200db16/src/main/java/org/apache/commons/math4/util/Decimal64.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/util/Decimal64.java b/src/main/java/org/apache/commons/math4/util/Decimal64.java
index b8f4999..1bbd2ea 100644
--- a/src/main/java/org/apache/commons/math4/util/Decimal64.java
+++ b/src/main/java/org/apache/commons/math4/util/Decimal64.java
@@ -16,6 +16,7 @@
  */
 package org.apache.commons.math4.util;
 
+import org.apache.commons.numbers.arrays.LinearCombination;
 import org.apache.commons.math4.Field;
 import org.apache.commons.math4.RealFieldElement;
 import org.apache.commons.math4.exception.DimensionMismatchException;
@@ -659,7 +660,7 @@ public class Decimal64 extends Number
             aDouble[i] = a[i].value;
             bDouble[i] = b[i].value;
         }
-        return new Decimal64(MathArrays.linearCombination(aDouble, bDouble));
+        return new Decimal64(LinearCombination.value(aDouble, bDouble));
     }
 
     /** {@inheritDoc}
@@ -675,7 +676,7 @@ public class Decimal64 extends Number
         for (int i = 0; i < a.length; ++i) {
             bDouble[i] = b[i].value;
         }
-        return new Decimal64(MathArrays.linearCombination(a, bDouble));
+        return new Decimal64(LinearCombination.value(a, bDouble));
     }
 
     /** {@inheritDoc}
@@ -684,7 +685,7 @@ public class Decimal64 extends Number
     @Override
     public Decimal64 linearCombination(final Decimal64 a1, final Decimal64 b1,
                                        final Decimal64 a2, final Decimal64 b2) {
-        return new Decimal64(MathArrays.linearCombination(a1.value, b1.value,
+        return new Decimal64(LinearCombination.value(a1.value, b1.value,
                                                           a2.value, b2.value));
     }
 
@@ -694,7 +695,7 @@ public class Decimal64 extends Number
     @Override
     public Decimal64 linearCombination(final double a1, final Decimal64 b1,
                                        final double a2, final Decimal64 b2) {
-        return new Decimal64(MathArrays.linearCombination(a1, b1.value,
+        return new Decimal64(LinearCombination.value(a1, b1.value,
                                                           a2, b2.value));
     }
 
@@ -705,7 +706,7 @@ public class Decimal64 extends Number
     public Decimal64 linearCombination(final Decimal64 a1, final Decimal64 b1,
                                        final Decimal64 a2, final Decimal64 b2,
                                        final Decimal64 a3, final Decimal64 b3) {
-        return new Decimal64(MathArrays.linearCombination(a1.value, b1.value,
+        return new Decimal64(LinearCombination.value(a1.value, b1.value,
                                                           a2.value, b2.value,
                                                           a3.value, b3.value));
     }
@@ -717,7 +718,7 @@ public class Decimal64 extends Number
     public Decimal64 linearCombination(final double a1, final Decimal64 b1,
                                        final double a2, final Decimal64 b2,
                                        final double a3, final Decimal64 b3) {
-        return new Decimal64(MathArrays.linearCombination(a1, b1.value,
+        return new Decimal64(LinearCombination.value(a1, b1.value,
                                                           a2, b2.value,
                                                           a3, b3.value));
     }
@@ -730,7 +731,7 @@ public class Decimal64 extends Number
                                        final Decimal64 a2, final Decimal64 b2,
                                        final Decimal64 a3, final Decimal64 b3,
                                        final Decimal64 a4, final Decimal64 b4) {
-        return new Decimal64(MathArrays.linearCombination(a1.value, b1.value,
+        return new Decimal64(LinearCombination.value(a1.value, b1.value,
                                                           a2.value, b2.value,
                                                           a3.value, b3.value,
                                                           a4.value, b4.value));
@@ -744,7 +745,7 @@ public class Decimal64 extends Number
                                        final double a2, final Decimal64 b2,
                                        final double a3, final Decimal64 b3,
                                        final double a4, final Decimal64 b4) {
-        return new Decimal64(MathArrays.linearCombination(a1, b1.value,
+        return new Decimal64(LinearCombination.value(a1, b1.value,
                                                           a2, b2.value,
                                                           a3, b3.value,
                                                           a4, b4.value));


Mime
View raw message