Apache
/
commons-math
mirror of https://github.com/apache/commons-math.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Reverted commit about mapping functions in MathArrays. 

As discussed on the mailing list, the same result can be obtained with
existing higher level API, for example:

  new ArrayRealVector(array, false).map(f).toArray();
This commit is contained in:
Luc Maisonobe 2015-07-06 20:33:37 +02:00
parent 9575054ff0
commit 70538e67fb
3 changed files with 1 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/changes/changes.xml
View File

@ -70,10 +70,6 @@ If the output is not quite correct, check for invisible trailing spaces!
These can be useful to manage an OutOfRangeException without the need to access
the original x and y arrays.
</action>
<action dev="luc" type="add" >
Added mapping functions to MathArrays. These methods allow to map
any univariate or bivariate functions to arrays.
</action>
<action dev="tn" type="fix" issue="MATH-1240"> <!-- backported to 3.6 -->
"KolmogorovSmirnovTest#ksSum(...)" returned wrong result in case the provided
t-parameters was zero. This affected the calculation of "approximateP(...)" for

71
src/main/java/org/apache/commons/math4/util/MathArrays.java
View File

@ -25,8 +25,6 @@ import java.util.Comparator;
import java.util.List;
import org.apache.commons.math4.Field;
import org.apache.commons.math4.analysis.BivariateFunction;
import org.apache.commons.math4.analysis.UnivariateFunction;
import org.apache.commons.math4.distribution.UniformIntegerDistribution;
import org.apache.commons.math4.exception.DimensionMismatchException;
import org.apache.commons.math4.exception.MathArithmeticException;
@ -109,75 +107,6 @@ public class MathArrays {
}
}
/**
* Creates an array whose contents will be the element-by-element
* mapping of the function to argument.
*
* @param f function to map on elements
* @param a array of function parameters.
* @return a new array {@code r} where {@code r[i] = f(a[i])}.
* @since 4.0
*/
public static double[] map(final UnivariateFunction f, final double[] a) {
final double[] result = new double[a.length];
for (int i = 0; i < result.length; ++i) {
result[i] = f.value(a[i]);
}
return result;
}
/**
* Creates an array whose contents will be the element-by-element
* mapping of the function to arguments.
*
* @param f function to map on elements
* @param a array of first parameters of the function.
* @param b array of second parameters of the function.
* @return a new array {@code r} where {@code r[i] = f(a[i], b[i])}.
* @throws DimensionMismatchException if the array lengths differ.
* @since 4.0
*/
public static double[] map(final BivariateFunction f,
final double[] a, final double[] b) {
if (a.length != b.length) {
throw new DimensionMismatchException(a.length, b.length);
}
final double[] result = new double[a.length];
for (int i = 0; i < result.length; ++i) {
result[i] = f.value(a[i], b[i]);
}
return result;
}
/**
* Creates an array whose contents will be the element-by-element
* mapping of the function to arguments.
*
* @param f function to map on elements
* @param a array of first parameters of the function.
* @param b fixed value for second function parameter.
* @return a new array {@code r} where {@code r[i] = f(a[i])}.
* @since 4.0
*/
public static double[] map(final BivariateFunction f,
final double[] a, final double b) {
final double[] result = new double[a.length];
for (int i = 0; i < result.length; ++i) {
result[i] = f.value(a[i], b);
}
return result;
}
/**
* Creates an array whose contents will be the element-by-element
* addition of the arguments.

32
src/test/java/org/apache/commons/math4/util/MathArraysTest.java
View File

@ -16,8 +16,6 @@ package org.apache.commons.math4.util;
import java.util.Arrays;
import org.apache.commons.math4.TestUtils;
import org.apache.commons.math4.analysis.function.Abs;
import org.apache.commons.math4.analysis.function.Add;
import org.apache.commons.math4.exception.DimensionMismatchException;
import org.apache.commons.math4.exception.MathArithmeticException;
import org.apache.commons.math4.exception.MathIllegalArgumentException;
@ -77,36 +75,6 @@ public class MathArraysTest {
}
}
@Test
public void testMapUnivariate() {
final double[] expected = new double[] { 1, 2, 4, 8 };
final double[] observed =
MathArrays.map(new Abs(), new double[] { 1, -2, -4, 8});
TestUtils.assertEquals(expected, observed, 1.0e-15);
}
@Test
public void testMapBivariateTwoArrays() {
final double[] expected = new double[] { 1, 3, 6, 11 };
final double[] observed =
MathArrays.map(new Add(),
new double[] { 1, 2, 4, 8}, new double[] { 0, 1, 2, 3});
TestUtils.assertEquals(expected, observed, 1.0e-15);
}
@Test
public void testMapBivariateOneArray() {
final double[] expected = new double[] { 3.5, 4.5, 6.5, 10.5 };
final double[] observed =
MathArrays.map(new Add(), new double[] { 1, 2, 4, 8}, 2.5);
TestUtils.assertEquals(expected, observed, 1.0e-15);
}
@Test(expected=DimensionMismatchException.class)
public void testMapBivariatePrecondition() {
MathArrays.map(new Add(), new double[3], new double[4]);
}
@Test(expected=DimensionMismatchException.class)
public void testEbeAddPrecondition() {
MathArrays.ebeAdd(new double[3], new double[4]);