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 <er...@apache.org> Authored: Thu May 25 01:45:29 2017 +0200 Committer: Gilles <er...@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));
