You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by er...@apache.org on 2021/06/17 13:24:35 UTC
[commons-math] 02/02: Functionality has been moved to "Commons
Numbers" (cf. NUMBERS-164).
This is an automated email from the ASF dual-hosted git repository.
erans pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-math.git
commit 0a3c4023ddc1a1c14c85b54f8742a58401ee08d9
Author: Gilles Sadowski <gi...@gmail.com>
AuthorDate: Thu Jun 17 15:22:48 2021 +0200
Functionality has been moved to "Commons Numbers" (cf. NUMBERS-164).
---
.../commons/math4/legacy/core/MathArrays.java | 139 ---------------------
.../commons/math4/legacy/core/MathArraysTest.java | 101 ---------------
2 files changed, 240 deletions(-)
diff --git a/commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/MathArrays.java b/commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/MathArrays.java
index 10a8ed1..14ca994 100644
--- a/commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/MathArrays.java
+++ b/commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/MathArrays.java
@@ -610,145 +610,6 @@ public class MathArrays {
}
/**
- * Sort an array in ascending order in place and perform the same reordering
- * of entries on other arrays. For example, if
- * {@code x = [3, 1, 2], y = [1, 2, 3]} and {@code z = [0, 5, 7]}, then
- * {@code sortInPlace(x, y, z)} will update {@code x} to {@code [1, 2, 3]},
- * {@code y} to {@code [2, 3, 1]} and {@code z} to {@code [5, 7, 0]}.
- *
- * @param x Array to be sorted and used as a pattern for permutation
- * of the other arrays.
- * @param yList Set of arrays whose permutations of entries will follow
- * those performed on {@code x}.
- * @throws DimensionMismatchException if any {@code y} is not the same
- * size as {@code x}.
- * @throws NullArgumentException if {@code x} or any {@code y} is null.
- * @since 3.0
- */
- public static void sortInPlace(double[] x, double[] ... yList) {
- sortInPlace(x, OrderDirection.INCREASING, yList);
- }
-
- /**
- * Helper data structure holding a (double, integer) pair.
- */
- private static class PairDoubleInteger {
- /** Key */
- private final double key;
- /** Value */
- private final int value;
-
- /**
- * @param key Key.
- * @param value Value.
- */
- PairDoubleInteger(double key, int value) {
- this.key = key;
- this.value = value;
- }
-
- /** @return the key. */
- public double getKey() {
- return key;
- }
-
- /** @return the value. */
- public int getValue() {
- return value;
- }
- }
-
- /**
- * Sort an array in place and perform the same reordering of entries on
- * other arrays. This method works the same as the other
- * {@link #sortInPlace(double[], double[][]) sortInPlace} method, but
- * allows the order of the sort to be provided in the {@code dir}
- * parameter.
- *
- * @param x Array to be sorted and used as a pattern for permutation
- * of the other arrays.
- * @param dir Order direction.
- * @param yList Set of arrays whose permutations of entries will follow
- * those performed on {@code x}.
- * @throws DimensionMismatchException if any {@code y} is not the same
- * size as {@code x}.
- * @throws NullArgumentException if {@code x} or any {@code y} is null
- * @since 3.0
- */
- public static void sortInPlace(double[] x,
- final OrderDirection dir,
- double[] ... yList) {
- // Consistency checks.
- if (x == null) {
- throw new NullArgumentException();
- }
-
- final int yListLen = yList.length;
- final int len = x.length;
-
- for (int j = 0; j < yListLen; j++) {
- final double[] y = yList[j];
- if (y == null) {
- throw new NullArgumentException();
- }
- if (y.length != len) {
- throw new DimensionMismatchException(y.length, len);
- }
- }
-
- // Associate each abscissa "x[i]" with its index "i".
- final List<PairDoubleInteger> list
- = new ArrayList<>(len);
- for (int i = 0; i < len; i++) {
- list.add(new PairDoubleInteger(x[i], i));
- }
-
- // Create comparators for increasing and decreasing orders.
- final Comparator<PairDoubleInteger> comp
- = dir == MathArrays.OrderDirection.INCREASING ?
- new Comparator<PairDoubleInteger>() {
- /** {@inheritDoc} */
- @Override
- public int compare(PairDoubleInteger o1,
- PairDoubleInteger o2) {
- return Double.compare(o1.getKey(), o2.getKey());
- }
- } : new Comparator<PairDoubleInteger>() {
- /** {@inheritDoc} */
- @Override
- public int compare(PairDoubleInteger o1,
- PairDoubleInteger o2) {
- return Double.compare(o2.getKey(), o1.getKey());
- }
- };
-
- // Sort.
- Collections.sort(list, comp);
-
- // Modify the original array so that its elements are in
- // the prescribed order.
- // Retrieve indices of original locations.
- final int[] indices = new int[len];
- for (int i = 0; i < len; i++) {
- final PairDoubleInteger e = list.get(i);
- x[i] = e.getKey();
- indices[i] = e.getValue();
- }
-
- // In each of the associated arrays, move the
- // elements to their new location.
- for (int j = 0; j < yListLen; j++) {
- // Input array will be modified in place.
- final double[] yInPlace = yList[j];
- final double[] yOrig = yInPlace.clone();
-
- for (int i = 0; i < len; i++) {
- yInPlace[i] = yOrig[indices[i]];
- }
- }
- }
-
- /**
* Returns true iff both arguments are null or have same dimensions and all
* their elements are equal as defined by
* {@link Precision#equals(float,float)}.
diff --git a/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/MathArraysTest.java b/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/MathArraysTest.java
index 7904f9d..46b339b 100644
--- a/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/MathArraysTest.java
+++ b/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/MathArraysTest.java
@@ -438,107 +438,6 @@ public class MathArraysTest {
}
@Test
- public void testSortInPlace() {
- final double[] x1 = {2, 5, -3, 1, 4};
- final double[] x2 = {4, 25, 9, 1, 16};
- final double[] x3 = {8, 125, -27, 1, 64};
-
- MathArrays.sortInPlace(x1, x2, x3);
-
- Assert.assertEquals(-3, x1[0], AccurateMath.ulp(1d));
- Assert.assertEquals(9, x2[0], AccurateMath.ulp(1d));
- Assert.assertEquals(-27, x3[0], AccurateMath.ulp(1d));
-
- Assert.assertEquals(1, x1[1], AccurateMath.ulp(1d));
- Assert.assertEquals(1, x2[1], AccurateMath.ulp(1d));
- Assert.assertEquals(1, x3[1], AccurateMath.ulp(1d));
-
- Assert.assertEquals(2, x1[2], AccurateMath.ulp(1d));
- Assert.assertEquals(4, x2[2], AccurateMath.ulp(1d));
- Assert.assertEquals(8, x3[2], AccurateMath.ulp(1d));
-
- Assert.assertEquals(4, x1[3], AccurateMath.ulp(1d));
- Assert.assertEquals(16, x2[3], AccurateMath.ulp(1d));
- Assert.assertEquals(64, x3[3], AccurateMath.ulp(1d));
-
- Assert.assertEquals(5, x1[4], AccurateMath.ulp(1d));
- Assert.assertEquals(25, x2[4], AccurateMath.ulp(1d));
- Assert.assertEquals(125, x3[4], AccurateMath.ulp(1d));
- }
-
- @Test
- public void testSortInPlaceDecreasingOrder() {
- final double[] x1 = {2, 5, -3, 1, 4};
- final double[] x2 = {4, 25, 9, 1, 16};
- final double[] x3 = {8, 125, -27, 1, 64};
-
- MathArrays.sortInPlace(x1,
- MathArrays.OrderDirection.DECREASING,
- x2, x3);
-
- Assert.assertEquals(-3, x1[4], AccurateMath.ulp(1d));
- Assert.assertEquals(9, x2[4], AccurateMath.ulp(1d));
- Assert.assertEquals(-27, x3[4], AccurateMath.ulp(1d));
-
- Assert.assertEquals(1, x1[3], AccurateMath.ulp(1d));
- Assert.assertEquals(1, x2[3], AccurateMath.ulp(1d));
- Assert.assertEquals(1, x3[3], AccurateMath.ulp(1d));
-
- Assert.assertEquals(2, x1[2], AccurateMath.ulp(1d));
- Assert.assertEquals(4, x2[2], AccurateMath.ulp(1d));
- Assert.assertEquals(8, x3[2], AccurateMath.ulp(1d));
-
- Assert.assertEquals(4, x1[1], AccurateMath.ulp(1d));
- Assert.assertEquals(16, x2[1], AccurateMath.ulp(1d));
- Assert.assertEquals(64, x3[1], AccurateMath.ulp(1d));
-
- Assert.assertEquals(5, x1[0], AccurateMath.ulp(1d));
- Assert.assertEquals(25, x2[0], AccurateMath.ulp(1d));
- Assert.assertEquals(125, x3[0], AccurateMath.ulp(1d));
- }
-
- /** Example in javadoc */
- @Test
- public void testSortInPlaceExample() {
- final double[] x = {3, 1, 2};
- final double[] y = {1, 2, 3};
- final double[] z = {0, 5, 7};
- MathArrays.sortInPlace(x, y, z);
- final double[] sx = {1, 2, 3};
- final double[] sy = {2, 3, 1};
- final double[] sz = {5, 7, 0};
- Assert.assertTrue(Arrays.equals(sx, x));
- Assert.assertTrue(Arrays.equals(sy, y));
- Assert.assertTrue(Arrays.equals(sz, z));
- }
-
- @Test
- public void testSortInPlaceFailures() {
- final double[] nullArray = null;
- final double[] one = {1};
- final double[] two = {1, 2};
- final double[] onep = {2};
- try {
- MathArrays.sortInPlace(one, two);
- Assert.fail("Expecting DimensionMismatchException");
- } catch (DimensionMismatchException ex) {
- // expected
- }
- try {
- MathArrays.sortInPlace(one, nullArray);
- Assert.fail("Expecting NullArgumentException");
- } catch (NullArgumentException ex) {
- // expected
- }
- try {
- MathArrays.sortInPlace(one, onep, nullArray);
- Assert.fail("Expecting NullArgumentException");
- } catch (NullArgumentException ex) {
- // expected
- }
- }
-
- @Test
public void testArrayEquals() {
Assert.assertFalse(MathArrays.equals(new double[] { 1d }, null));
Assert.assertFalse(MathArrays.equals(null, new double[] { 1d }));