Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/ArrayRealVectorTest.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/ArrayRealVectorTest.java?rev=1039411&r1=1039410&r2=1039411&view=diff ============================================================================== --- commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/ArrayRealVectorTest.java (original) +++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/ArrayRealVectorTest.java Fri Nov 26 15:24:28 2010 @@ -18,20 +18,47 @@ package org.apache.commons.math.linear; import java.io.Serializable; import java.util.Iterator; - -import junit.framework.TestCase; +import org.junit.Assert; +import org.junit.Test; import org.apache.commons.math.TestUtils; import org.apache.commons.math.analysis.UnivariateRealFunction; import org.apache.commons.math.util.FastMath; import org.apache.commons.math.exception.OutOfRangeException; +import org.apache.commons.math.analysis.function.Abs; +import org.apache.commons.math.analysis.function.Acosh; +import org.apache.commons.math.analysis.function.Acos; +import org.apache.commons.math.analysis.function.Asinh; +import org.apache.commons.math.analysis.function.Asin; +import org.apache.commons.math.analysis.function.Atanh; +import org.apache.commons.math.analysis.function.Atan; +import org.apache.commons.math.analysis.function.Cbrt; +import org.apache.commons.math.analysis.function.Cosh; +import org.apache.commons.math.analysis.function.Cos; +import org.apache.commons.math.analysis.function.Exp; +import org.apache.commons.math.analysis.function.Expm1; +import org.apache.commons.math.analysis.function.Inverse; +import org.apache.commons.math.analysis.function.Log10; +import org.apache.commons.math.analysis.function.Log1p; +import org.apache.commons.math.analysis.function.Log; +import org.apache.commons.math.analysis.function.Pow; +import org.apache.commons.math.analysis.function.Sinh; +import org.apache.commons.math.analysis.function.Sin; +import org.apache.commons.math.analysis.function.Sqrt; +import org.apache.commons.math.analysis.function.Tanh; +import org.apache.commons.math.analysis.function.Tan; +import org.apache.commons.math.analysis.function.Floor; +import org.apache.commons.math.analysis.function.Ceil; +import org.apache.commons.math.analysis.function.Rint; +import org.apache.commons.math.analysis.function.Signum; +import org.apache.commons.math.analysis.function.Ulp; /** * Test cases for the {...@link ArrayRealVector} class. * * @version $Revision$ $Date$ */ -public class ArrayRealVectorTest extends TestCase { +public class ArrayRealVectorTest { // protected double[][] ma1 = {{1d, 2d, 3d}, {4d, 5d, 6d}, {7d, 8d, 9d}}; @@ -167,190 +194,6 @@ public class ArrayRealVectorTest extends throw unsupported(); } - public RealVector mapExp() { - throw unsupported(); - } - - public RealVector mapExpToSelf() { - throw unsupported(); - } - - public RealVector mapExpm1() { - throw unsupported(); - } - - public RealVector mapExpm1ToSelf() { - throw unsupported(); - } - - public RealVector mapLog() { - throw unsupported(); - } - - public RealVector mapLogToSelf() { - throw unsupported(); - } - - public RealVector mapLog10() { - throw unsupported(); - } - - public RealVector mapLog10ToSelf() { - throw unsupported(); - } - - public RealVector mapLog1p() { - throw unsupported(); - } - - public RealVector mapLog1pToSelf() { - throw unsupported(); - } - - public RealVector mapCosh() { - throw unsupported(); - } - - public RealVector mapCoshToSelf() { - throw unsupported(); - } - - public RealVector mapSinh() { - throw unsupported(); - } - - public RealVector mapSinhToSelf() { - throw unsupported(); - } - - public RealVector mapTanh() { - throw unsupported(); - } - - public RealVector mapTanhToSelf() { - throw unsupported(); - } - - public RealVector mapCos() { - throw unsupported(); - } - - public RealVector mapCosToSelf() { - throw unsupported(); - } - - public RealVector mapSin() { - throw unsupported(); - } - - public RealVector mapSinToSelf() { - throw unsupported(); - } - - public RealVector mapTan() { - throw unsupported(); - } - - public RealVector mapTanToSelf() { - throw unsupported(); - } - - public RealVector mapAcos() { - throw unsupported(); - } - - public RealVector mapAcosToSelf() { - throw unsupported(); - } - - public RealVector mapAsin() { - throw unsupported(); - } - - public RealVector mapAsinToSelf() { - throw unsupported(); - } - - public RealVector mapAtan() { - throw unsupported(); - } - - public RealVector mapAtanToSelf() { - throw unsupported(); - } - - public RealVector mapInv() { - throw unsupported(); - } - - public RealVector mapInvToSelf() { - throw unsupported(); - } - - public RealVector mapAbs() { - throw unsupported(); - } - - public RealVector mapAbsToSelf() { - throw unsupported(); - } - - public RealVector mapSqrt() { - throw unsupported(); - } - - public RealVector mapSqrtToSelf() { - throw unsupported(); - } - - public RealVector mapCbrt() { - throw unsupported(); - } - - public RealVector mapCbrtToSelf() { - throw unsupported(); - } - - public RealVector mapCeil() { - throw unsupported(); - } - - public RealVector mapCeilToSelf() { - throw unsupported(); - } - - public RealVector mapFloor() { - throw unsupported(); - } - - public RealVector mapFloorToSelf() { - throw unsupported(); - } - - public RealVector mapRint() { - throw unsupported(); - } - - public RealVector mapRintToSelf() { - throw unsupported(); - } - - public RealVector mapSignum() { - throw unsupported(); - } - - public RealVector mapSignumToSelf() { - throw unsupported(); - } - - public RealVector mapUlp() { - throw unsupported(); - } - - public RealVector mapUlpToSelf() { - throw unsupported(); - } - public RealVector ebeMultiply(RealVector v) { throw unsupported(); } @@ -501,114 +344,116 @@ public class ArrayRealVectorTest extends } + @Test public void testConstructors() { ArrayRealVector v0 = new ArrayRealVector(); - assertEquals("testData len", 0, v0.getDimension()); + Assert.assertEquals("testData len", 0, v0.getDimension()); ArrayRealVector v1 = new ArrayRealVector(7); - assertEquals("testData len", 7, v1.getDimension()); - assertEquals("testData is 0.0 ", 0.0, v1.getEntry(6)); + Assert.assertEquals("testData len", 7, v1.getDimension()); + Assert.assertEquals("testData is 0.0 ", 0.0, v1.getEntry(6), 0); ArrayRealVector v2 = new ArrayRealVector(5, 1.23); - assertEquals("testData len", 5, v2.getDimension()); - assertEquals("testData is 1.23 ", 1.23, v2.getEntry(4)); + Assert.assertEquals("testData len", 5, v2.getDimension()); + Assert.assertEquals("testData is 1.23 ", 1.23, v2.getEntry(4), 0); ArrayRealVector v3 = new ArrayRealVector(vec1); - assertEquals("testData len", 3, v3.getDimension()); - assertEquals("testData is 2.0 ", 2.0, v3.getEntry(1)); + Assert.assertEquals("testData len", 3, v3.getDimension()); + Assert.assertEquals("testData is 2.0 ", 2.0, v3.getEntry(1), 0); ArrayRealVector v3_bis = new ArrayRealVector(vec1, true); - assertEquals("testData len", 3, v3_bis.getDimension()); - assertEquals("testData is 2.0 ", 2.0, v3_bis.getEntry(1)); - assertNotSame(v3_bis.getDataRef(), vec1); - assertNotSame(v3_bis.getData(), vec1); + Assert.assertEquals("testData len", 3, v3_bis.getDimension()); + Assert.assertEquals("testData is 2.0 ", 2.0, v3_bis.getEntry(1), 0); + Assert.assertNotSame(v3_bis.getDataRef(), vec1); + Assert.assertNotSame(v3_bis.getData(), vec1); ArrayRealVector v3_ter = new ArrayRealVector(vec1, false); - assertEquals("testData len", 3, v3_ter.getDimension()); - assertEquals("testData is 2.0 ", 2.0, v3_ter.getEntry(1)); - assertSame(v3_ter.getDataRef(), vec1); - assertNotSame(v3_ter.getData(), vec1); + Assert.assertEquals("testData len", 3, v3_ter.getDimension()); + Assert.assertEquals("testData is 2.0 ", 2.0, v3_ter.getEntry(1), 0); + Assert.assertSame(v3_ter.getDataRef(), vec1); + Assert.assertNotSame(v3_ter.getData(), vec1); ArrayRealVector v4 = new ArrayRealVector(vec4, 3, 2); - assertEquals("testData len", 2, v4.getDimension()); - assertEquals("testData is 4.0 ", 4.0, v4.getEntry(0)); + Assert.assertEquals("testData len", 2, v4.getDimension()); + Assert.assertEquals("testData is 4.0 ", 4.0, v4.getEntry(0), 0); try { new ArrayRealVector(vec4, 8, 3); - fail("IllegalArgumentException expected"); + Assert.fail("IllegalArgumentException expected"); } catch (IllegalArgumentException ex) { // expected behavior } RealVector v5_i = new ArrayRealVector(dvec1); - assertEquals("testData len", 9, v5_i.getDimension()); - assertEquals("testData is 9.0 ", 9.0, v5_i.getEntry(8)); + Assert.assertEquals("testData len", 9, v5_i.getDimension()); + Assert.assertEquals("testData is 9.0 ", 9.0, v5_i.getEntry(8), 0); ArrayRealVector v5 = new ArrayRealVector(dvec1); - assertEquals("testData len", 9, v5.getDimension()); - assertEquals("testData is 9.0 ", 9.0, v5.getEntry(8)); + Assert.assertEquals("testData len", 9, v5.getDimension()); + Assert.assertEquals("testData is 9.0 ", 9.0, v5.getEntry(8), 0); ArrayRealVector v6 = new ArrayRealVector(dvec1, 3, 2); - assertEquals("testData len", 2, v6.getDimension()); - assertEquals("testData is 4.0 ", 4.0, v6.getEntry(0)); + Assert.assertEquals("testData len", 2, v6.getDimension()); + Assert.assertEquals("testData is 4.0 ", 4.0, v6.getEntry(0), 0); try { new ArrayRealVector(dvec1, 8, 3); - fail("IllegalArgumentException expected"); + Assert.fail("IllegalArgumentException expected"); } catch (IllegalArgumentException ex) { // expected behavior } ArrayRealVector v7 = new ArrayRealVector(v1); - assertEquals("testData len", 7, v7.getDimension()); - assertEquals("testData is 0.0 ", 0.0, v7.getEntry(6)); + Assert.assertEquals("testData len", 7, v7.getDimension()); + Assert.assertEquals("testData is 0.0 ", 0.0, v7.getEntry(6), 0); RealVectorTestImpl v7_i = new RealVectorTestImpl(vec1); ArrayRealVector v7_2 = new ArrayRealVector(v7_i); - assertEquals("testData len", 3, v7_2.getDimension()); - assertEquals("testData is 0.0 ", 2.0d, v7_2.getEntry(1)); + Assert.assertEquals("testData len", 3, v7_2.getDimension()); + Assert.assertEquals("testData is 0.0 ", 2.0d, v7_2.getEntry(1), 0); ArrayRealVector v8 = new ArrayRealVector(v1, true); - assertEquals("testData len", 7, v8.getDimension()); - assertEquals("testData is 0.0 ", 0.0, v8.getEntry(6)); - assertNotSame("testData not same object ", v1.data, v8.data); + Assert.assertEquals("testData len", 7, v8.getDimension()); + Assert.assertEquals("testData is 0.0 ", 0.0, v8.getEntry(6), 0); + Assert.assertNotSame("testData not same object ", v1.data, v8.data); ArrayRealVector v8_2 = new ArrayRealVector(v1, false); - assertEquals("testData len", 7, v8_2.getDimension()); - assertEquals("testData is 0.0 ", 0.0, v8_2.getEntry(6)); - assertEquals("testData same object ", v1.data, v8_2.data); + Assert.assertEquals("testData len", 7, v8_2.getDimension()); + Assert.assertEquals("testData is 0.0 ", 0.0, v8_2.getEntry(6), 0); + Assert.assertEquals("testData same object ", v1.data, v8_2.data); ArrayRealVector v9 = new ArrayRealVector(v1, v3); - assertEquals("testData len", 10, v9.getDimension()); - assertEquals("testData is 1.0 ", 1.0, v9.getEntry(7)); + Assert.assertEquals("testData len", 10, v9.getDimension()); + Assert.assertEquals("testData is 1.0 ", 1.0, v9.getEntry(7), 0); ArrayRealVector v10 = new ArrayRealVector(v2, new RealVectorTestImpl(vec3)); - assertEquals("testData len", 8, v10.getDimension()); - assertEquals("testData is 1.23 ", 1.23, v10.getEntry(4)); - assertEquals("testData is 7.0 ", 7.0, v10.getEntry(5)); + Assert.assertEquals("testData len", 8, v10.getDimension()); + Assert.assertEquals("testData is 1.23 ", 1.23, v10.getEntry(4), 0); + Assert.assertEquals("testData is 7.0 ", 7.0, v10.getEntry(5), 0); ArrayRealVector v11 = new ArrayRealVector(new RealVectorTestImpl(vec3), v2); - assertEquals("testData len", 8, v11.getDimension()); - assertEquals("testData is 9.0 ", 9.0, v11.getEntry(2)); - assertEquals("testData is 1.23 ", 1.23, v11.getEntry(3)); + Assert.assertEquals("testData len", 8, v11.getDimension()); + Assert.assertEquals("testData is 9.0 ", 9.0, v11.getEntry(2), 0); + Assert.assertEquals("testData is 1.23 ", 1.23, v11.getEntry(3), 0); ArrayRealVector v12 = new ArrayRealVector(v2, vec3); - assertEquals("testData len", 8, v12.getDimension()); - assertEquals("testData is 1.23 ", 1.23, v12.getEntry(4)); - assertEquals("testData is 7.0 ", 7.0, v12.getEntry(5)); + Assert.assertEquals("testData len", 8, v12.getDimension()); + Assert.assertEquals("testData is 1.23 ", 1.23, v12.getEntry(4), 0); + Assert.assertEquals("testData is 7.0 ", 7.0, v12.getEntry(5), 0); ArrayRealVector v13 = new ArrayRealVector(vec3, v2); - assertEquals("testData len", 8, v13.getDimension()); - assertEquals("testData is 9.0 ", 9.0, v13.getEntry(2)); - assertEquals("testData is 1.23 ", 1.23, v13.getEntry(3)); + Assert.assertEquals("testData len", 8, v13.getDimension()); + Assert.assertEquals("testData is 9.0 ", 9.0, v13.getEntry(2), 0); + Assert.assertEquals("testData is 1.23 ", 1.23, v13.getEntry(3), 0); ArrayRealVector v14 = new ArrayRealVector(vec3, vec4); - assertEquals("testData len", 12, v14.getDimension()); - assertEquals("testData is 9.0 ", 9.0, v14.getEntry(2)); - assertEquals("testData is 1.0 ", 1.0, v14.getEntry(3)); + Assert.assertEquals("testData len", 12, v14.getDimension()); + Assert.assertEquals("testData is 9.0 ", 9.0, v14.getEntry(2), 0); + Assert.assertEquals("testData is 1.0 ", 1.0, v14.getEntry(3), 0); - } + } + @Test public void testDataInOut() { ArrayRealVector v1 = new ArrayRealVector(vec1); @@ -617,88 +462,88 @@ public class ArrayRealVectorTest extends RealVectorTestImpl v2_t = new RealVectorTestImpl(vec2); RealVector v_append_1 = v1.append(v2); - assertEquals("testData len", 6, v_append_1.getDimension()); - assertEquals("testData is 4.0 ", 4.0, v_append_1.getEntry(3)); + Assert.assertEquals("testData len", 6, v_append_1.getDimension()); + Assert.assertEquals("testData is 4.0 ", 4.0, v_append_1.getEntry(3), 0); RealVector v_append_2 = v1.append(2.0); - assertEquals("testData len", 4, v_append_2.getDimension()); - assertEquals("testData is 2.0 ", 2.0, v_append_2.getEntry(3)); + Assert.assertEquals("testData len", 4, v_append_2.getDimension()); + Assert.assertEquals("testData is 2.0 ", 2.0, v_append_2.getEntry(3), 0); RealVector v_append_3 = v1.append(vec2); - assertEquals("testData len", 6, v_append_3.getDimension()); - assertEquals("testData is ", 4.0, v_append_3.getEntry(3)); + Assert.assertEquals("testData len", 6, v_append_3.getDimension()); + Assert.assertEquals("testData is ", 4.0, v_append_3.getEntry(3), 0); RealVector v_append_4 = v1.append(v2_t); - assertEquals("testData len", 6, v_append_4.getDimension()); - assertEquals("testData is 4.0 ", 4.0, v_append_4.getEntry(3)); + Assert.assertEquals("testData len", 6, v_append_4.getDimension()); + Assert.assertEquals("testData is 4.0 ", 4.0, v_append_4.getEntry(3), 0); RealVector v_append_5 = v1.append((RealVector) v2); - assertEquals("testData len", 6, v_append_5.getDimension()); - assertEquals("testData is 4.0 ", 4.0, v_append_5.getEntry(3)); + Assert.assertEquals("testData len", 6, v_append_5.getDimension()); + Assert.assertEquals("testData is 4.0 ", 4.0, v_append_5.getEntry(3), 0); RealVector v_copy = v1.copy(); - assertEquals("testData len", 3, v_copy.getDimension()); - assertNotSame("testData not same object ", v1.data, v_copy.getData()); + Assert.assertEquals("testData len", 3, v_copy.getDimension()); + Assert.assertNotSame("testData not same object ", v1.data, v_copy.getData()); double[] a_double = v1.toArray(); - assertEquals("testData len", 3, a_double.length); - assertNotSame("testData not same object ", v1.data, a_double); + Assert.assertEquals("testData len", 3, a_double.length); + Assert.assertNotSame("testData not same object ", v1.data, a_double); // ArrayRealVector vout4 = (ArrayRealVector) v1.clone(); -// assertEquals("testData len", 3, vout4.getDimension()); -// assertEquals("testData not same object ", v1.data, vout4.data); +// Assert.assertEquals("testData len", 3, vout4.getDimension()); +// Assert.assertEquals("testData not same object ", v1.data, vout4.data); RealVector vout5 = v4.getSubVector(3, 3); - assertEquals("testData len", 3, vout5.getDimension()); - assertEquals("testData is 4.0 ", 5.0, vout5.getEntry(1)); + Assert.assertEquals("testData len", 3, vout5.getDimension()); + Assert.assertEquals("testData is 4.0 ", 5.0, vout5.getEntry(1), 0); try { v4.getSubVector(3, 7); - fail("OutOfRangeException expected"); + Assert.fail("OutOfRangeException expected"); } catch (OutOfRangeException ex) { // expected behavior } ArrayRealVector v_set1 = (ArrayRealVector) v1.copy(); v_set1.setEntry(1, 11.0); - assertEquals("testData is 11.0 ", 11.0, v_set1.getEntry(1)); + Assert.assertEquals("testData is 11.0 ", 11.0, v_set1.getEntry(1), 0); try { v_set1.setEntry(3, 11.0); - fail("OutOfRangeException expected"); + Assert.fail("OutOfRangeException expected"); } catch (OutOfRangeException ex) { // expected behavior } ArrayRealVector v_set2 = (ArrayRealVector) v4.copy(); v_set2.set(3, v1); - assertEquals("testData is 1.0 ", 1.0, v_set2.getEntry(3)); - assertEquals("testData is 7.0 ", 7.0, v_set2.getEntry(6)); + Assert.assertEquals("testData is 1.0 ", 1.0, v_set2.getEntry(3), 0); + Assert.assertEquals("testData is 7.0 ", 7.0, v_set2.getEntry(6), 0); try { v_set2.set(7, v1); - fail("OutOfRangeException expected"); + Assert.fail("OutOfRangeException expected"); } catch (OutOfRangeException ex) { // expected behavior } ArrayRealVector v_set3 = (ArrayRealVector) v1.copy(); v_set3.set(13.0); - assertEquals("testData is 13.0 ", 13.0, v_set3.getEntry(2)); + Assert.assertEquals("testData is 13.0 ", 13.0, v_set3.getEntry(2), 0); try { v_set3.getEntry(23); - fail("ArrayIndexOutOfBoundsException expected"); + Assert.fail("ArrayIndexOutOfBoundsException expected"); } catch (ArrayIndexOutOfBoundsException ex) { // expected behavior } ArrayRealVector v_set4 = (ArrayRealVector) v4.copy(); v_set4.setSubVector(3, v2_t); - assertEquals("testData is 1.0 ", 4.0, v_set4.getEntry(3)); - assertEquals("testData is 7.0 ", 7.0, v_set4.getEntry(6)); + Assert.assertEquals("testData is 1.0 ", 4.0, v_set4.getEntry(3), 0); + Assert.assertEquals("testData is 7.0 ", 7.0, v_set4.getEntry(6), 0); try { v_set4.setSubVector(7, v2_t); - fail("OutOfRangeException expected"); + Assert.fail("OutOfRangeException expected"); } catch (OutOfRangeException ex) { // expected behavior } @@ -706,12 +551,13 @@ public class ArrayRealVectorTest extends ArrayRealVector vout10 = (ArrayRealVector) v1.copy(); ArrayRealVector vout10_2 = (ArrayRealVector) v1.copy(); - assertEquals(vout10, vout10_2); + Assert.assertEquals(vout10, vout10_2); vout10_2.setEntry(0, 1.1); - assertNotSame(vout10, vout10_2); + Assert.assertNotSame(vout10, vout10_2); } + @Test public void testMapFunctions() { ArrayRealVector v1 = new ArrayRealVector(vec1); @@ -771,124 +617,124 @@ public class ArrayRealVectorTest extends assertClose("compare vectors" ,result_mapPowToSelf,v_mapPowToSelf.getData(),normTolerance); //octave = exp(v1) - RealVector v_mapExp = v1.mapExp(); + RealVector v_mapExp = v1.map(new Exp()); double[] result_mapExp = {2.718281828459045e+00d,7.389056098930650e+00d, 2.008553692318767e+01d}; assertClose("compare vectors" ,result_mapExp,v_mapExp.getData(),normTolerance); //octave = exp(v1) RealVector v_mapExpToSelf = v1.copy(); - v_mapExpToSelf.mapExpToSelf(); + v_mapExpToSelf.mapToSelf(new Exp()); double[] result_mapExpToSelf = {2.718281828459045e+00d,7.389056098930650e+00d, 2.008553692318767e+01d}; assertClose("compare vectors" ,result_mapExpToSelf,v_mapExpToSelf.getData(),normTolerance); //octave = ??? - RealVector v_mapExpm1 = v1.mapExpm1(); + RealVector v_mapExpm1 = v1.map(new Expm1()); double[] result_mapExpm1 = {1.718281828459045d,6.38905609893065d, 19.085536923187668d}; assertClose("compare vectors" ,result_mapExpm1,v_mapExpm1.getData(),normTolerance); //octave = ??? RealVector v_mapExpm1ToSelf = v1.copy(); - v_mapExpm1ToSelf.mapExpm1ToSelf(); + v_mapExpm1ToSelf.mapToSelf(new Expm1()); double[] result_mapExpm1ToSelf = {1.718281828459045d,6.38905609893065d, 19.085536923187668d}; assertClose("compare vectors" ,result_mapExpm1ToSelf,v_mapExpm1ToSelf.getData(),normTolerance); //octave = log(v1) - RealVector v_mapLog = v1.mapLog(); + RealVector v_mapLog = v1.map(new Log()); double[] result_mapLog = {0d,6.931471805599453e-01d, 1.098612288668110e+00d}; assertClose("compare vectors" ,result_mapLog,v_mapLog.getData(),normTolerance); //octave = log(v1) RealVector v_mapLogToSelf = v1.copy(); - v_mapLogToSelf.mapLogToSelf(); + v_mapLogToSelf.mapToSelf(new Log()); double[] result_mapLogToSelf = {0d,6.931471805599453e-01d, 1.098612288668110e+00d}; assertClose("compare vectors" ,result_mapLogToSelf,v_mapLogToSelf.getData(),normTolerance); //octave = log10(v1) - RealVector v_mapLog10 = v1.mapLog10(); + RealVector v_mapLog10 = v1.map(new Log10()); double[] result_mapLog10 = {0d,3.010299956639812e-01d, 4.771212547196624e-01d}; assertClose("compare vectors" ,result_mapLog10,v_mapLog10.getData(),normTolerance); //octave = log(v1) RealVector v_mapLog10ToSelf = v1.copy(); - v_mapLog10ToSelf.mapLog10ToSelf(); + v_mapLog10ToSelf.mapToSelf(new Log10()); double[] result_mapLog10ToSelf = {0d,3.010299956639812e-01d, 4.771212547196624e-01d}; assertClose("compare vectors" ,result_mapLog10ToSelf,v_mapLog10ToSelf.getData(),normTolerance); //octave = ??? - RealVector v_mapLog1p = v1.mapLog1p(); + RealVector v_mapLog1p = v1.map(new Log1p()); double[] result_mapLog1p = {0.6931471805599453d,1.0986122886681096d,1.3862943611198906d}; assertClose("compare vectors" ,result_mapLog1p,v_mapLog1p.getData(),normTolerance); //octave = ??? RealVector v_mapLog1pToSelf = v1.copy(); - v_mapLog1pToSelf.mapLog1pToSelf(); + v_mapLog1pToSelf.mapToSelf(new Log1p()); double[] result_mapLog1pToSelf = {0.6931471805599453d,1.0986122886681096d,1.3862943611198906d}; assertClose("compare vectors" ,result_mapLog1pToSelf,v_mapLog1pToSelf.getData(),normTolerance); //octave = cosh(v1) - RealVector v_mapCosh = v1.mapCosh(); + RealVector v_mapCosh = v1.map(new Cosh()); double[] result_mapCosh = {1.543080634815244e+00d,3.762195691083631e+00d, 1.006766199577777e+01d}; assertClose("compare vectors" ,result_mapCosh,v_mapCosh.getData(),normTolerance); //octave = cosh(v1) RealVector v_mapCoshToSelf = v1.copy(); - v_mapCoshToSelf.mapCoshToSelf(); + v_mapCoshToSelf.mapToSelf(new Cosh()); double[] result_mapCoshToSelf = {1.543080634815244e+00d,3.762195691083631e+00d, 1.006766199577777e+01d}; assertClose("compare vectors" ,result_mapCoshToSelf,v_mapCoshToSelf.getData(),normTolerance); //octave = sinh(v1) - RealVector v_mapSinh = v1.mapSinh(); + RealVector v_mapSinh = v1.map(new Sinh()); double[] result_mapSinh = {1.175201193643801e+00d,3.626860407847019e+00d, 1.001787492740990e+01d}; assertClose("compare vectors" ,result_mapSinh,v_mapSinh.getData(),normTolerance); //octave = sinh(v1) RealVector v_mapSinhToSelf = v1.copy(); - v_mapSinhToSelf.mapSinhToSelf(); + v_mapSinhToSelf.mapToSelf(new Sinh()); double[] result_mapSinhToSelf = {1.175201193643801e+00d,3.626860407847019e+00d, 1.001787492740990e+01d}; assertClose("compare vectors" ,result_mapSinhToSelf,v_mapSinhToSelf.getData(),normTolerance); //octave = tanh(v1) - RealVector v_mapTanh = v1.mapTanh(); + RealVector v_mapTanh = v1.map(new Tanh()); double[] result_mapTanh = {7.615941559557649e-01d,9.640275800758169e-01d,9.950547536867305e-01d}; assertClose("compare vectors" ,result_mapTanh,v_mapTanh.getData(),normTolerance); //octave = tanh(v1) RealVector v_mapTanhToSelf = v1.copy(); - v_mapTanhToSelf.mapTanhToSelf(); + v_mapTanhToSelf.mapToSelf(new Tanh()); double[] result_mapTanhToSelf = {7.615941559557649e-01d,9.640275800758169e-01d,9.950547536867305e-01d}; assertClose("compare vectors" ,result_mapTanhToSelf,v_mapTanhToSelf.getData(),normTolerance); //octave = cos(v1) - RealVector v_mapCos = v1.mapCos(); + RealVector v_mapCos = v1.map(new Cos()); double[] result_mapCos = {5.403023058681398e-01d,-4.161468365471424e-01d, -9.899924966004454e-01d}; assertClose("compare vectors" ,result_mapCos,v_mapCos.getData(),normTolerance); //octave = cos(v1) RealVector v_mapCosToSelf = v1.copy(); - v_mapCosToSelf.mapCosToSelf(); + v_mapCosToSelf.mapToSelf(new Cos()); double[] result_mapCosToSelf = {5.403023058681398e-01d,-4.161468365471424e-01d, -9.899924966004454e-01d}; assertClose("compare vectors" ,result_mapCosToSelf,v_mapCosToSelf.getData(),normTolerance); //octave = sin(v1) - RealVector v_mapSin = v1.mapSin(); + RealVector v_mapSin = v1.map(new Sin()); double[] result_mapSin = {8.414709848078965e-01d,9.092974268256817e-01d,1.411200080598672e-01d}; assertClose("compare vectors" ,result_mapSin,v_mapSin.getData(),normTolerance); //octave = sin(v1) RealVector v_mapSinToSelf = v1.copy(); - v_mapSinToSelf.mapSinToSelf(); + v_mapSinToSelf.mapToSelf(new Sin()); double[] result_mapSinToSelf = {8.414709848078965e-01d,9.092974268256817e-01d,1.411200080598672e-01d}; assertClose("compare vectors" ,result_mapSinToSelf,v_mapSinToSelf.getData(),normTolerance); //octave = tan(v1) - RealVector v_mapTan = v1.mapTan(); + RealVector v_mapTan = v1.map(new Tan()); double[] result_mapTan = {1.557407724654902e+00d,-2.185039863261519e+00d,-1.425465430742778e-01d}; assertClose("compare vectors" ,result_mapTan,v_mapTan.getData(),normTolerance); //octave = tan(v1) RealVector v_mapTanToSelf = v1.copy(); - v_mapTanToSelf.mapTanToSelf(); + v_mapTanToSelf.mapToSelf(new Tan()); double[] result_mapTanToSelf = {1.557407724654902e+00d,-2.185039863261519e+00d,-1.425465430742778e-01d}; assertClose("compare vectors" ,result_mapTanToSelf,v_mapTanToSelf.getData(),normTolerance); @@ -896,46 +742,46 @@ public class ArrayRealVectorTest extends ArrayRealVector vat = new ArrayRealVector(vat_a); //octave = acos(vat) - RealVector v_mapAcos = vat.mapAcos(); + RealVector v_mapAcos = vat.map(new Acos()); double[] result_mapAcos = {1.570796326794897e+00d,1.047197551196598e+00d, 0.0d}; assertClose("compare vectors" ,result_mapAcos,v_mapAcos.getData(),normTolerance); //octave = acos(vat) RealVector v_mapAcosToSelf = vat.copy(); - v_mapAcosToSelf.mapAcosToSelf(); + v_mapAcosToSelf.mapToSelf(new Acos()); double[] result_mapAcosToSelf = {1.570796326794897e+00d,1.047197551196598e+00d, 0.0d}; assertClose("compare vectors" ,result_mapAcosToSelf,v_mapAcosToSelf.getData(),normTolerance); //octave = asin(vat) - RealVector v_mapAsin = vat.mapAsin(); + RealVector v_mapAsin = vat.map(new Asin()); double[] result_mapAsin = {0.0d,5.235987755982989e-01d,1.570796326794897e+00d}; assertClose("compare vectors" ,result_mapAsin,v_mapAsin.getData(),normTolerance); //octave = asin(vat) RealVector v_mapAsinToSelf = vat.copy(); - v_mapAsinToSelf.mapAsinToSelf(); + v_mapAsinToSelf.mapToSelf(new Asin()); double[] result_mapAsinToSelf = {0.0d,5.235987755982989e-01d,1.570796326794897e+00d}; assertClose("compare vectors" ,result_mapAsinToSelf,v_mapAsinToSelf.getData(),normTolerance); //octave = atan(vat) - RealVector v_mapAtan = vat.mapAtan(); + RealVector v_mapAtan = vat.map(new Atan()); double[] result_mapAtan = {0.0d,4.636476090008061e-01d,7.853981633974483e-01d}; assertClose("compare vectors" ,result_mapAtan,v_mapAtan.getData(),normTolerance); //octave = atan(vat) RealVector v_mapAtanToSelf = vat.copy(); - v_mapAtanToSelf.mapAtanToSelf(); + v_mapAtanToSelf.mapToSelf(new Atan()); double[] result_mapAtanToSelf = {0.0d,4.636476090008061e-01d,7.853981633974483e-01d}; assertClose("compare vectors" ,result_mapAtanToSelf,v_mapAtanToSelf.getData(),normTolerance); //octave = v1 .^-1 - RealVector v_mapInv = v1.mapInv(); + RealVector v_mapInv = v1.map(new Inverse()); double[] result_mapInv = {1d,0.5d,3.333333333333333e-01d}; assertClose("compare vectors" ,result_mapInv,v_mapInv.getData(),normTolerance); //octave = v1 .^-1 RealVector v_mapInvToSelf = v1.copy(); - v_mapInvToSelf.mapInvToSelf(); + v_mapInvToSelf.mapToSelf(new Inverse()); double[] result_mapInvToSelf = {1d,0.5d,3.333333333333333e-01d}; assertClose("compare vectors" ,result_mapInvToSelf,v_mapInvToSelf.getData(),normTolerance); @@ -943,24 +789,24 @@ public class ArrayRealVectorTest extends ArrayRealVector abs_v = new ArrayRealVector(abs_a); //octave = abs(abs_v) - RealVector v_mapAbs = abs_v.mapAbs(); + RealVector v_mapAbs = abs_v.map(new Abs()); double[] result_mapAbs = {1d,0d,1d}; assertClose("compare vectors" ,result_mapAbs,v_mapAbs.getData(),normTolerance); //octave = abs(abs_v) RealVector v_mapAbsToSelf = abs_v.copy(); - v_mapAbsToSelf.mapAbsToSelf(); + v_mapAbsToSelf.mapToSelf(new Abs()); double[] result_mapAbsToSelf = {1d,0d,1d}; assertClose("compare vectors" ,result_mapAbsToSelf,v_mapAbsToSelf.getData(),normTolerance); //octave = sqrt(v1) - RealVector v_mapSqrt = v1.mapSqrt(); + RealVector v_mapSqrt = v1.map(new Sqrt()); double[] result_mapSqrt = {1d,1.414213562373095e+00d,1.732050807568877e+00d}; assertClose("compare vectors" ,result_mapSqrt,v_mapSqrt.getData(),normTolerance); //octave = sqrt(v1) RealVector v_mapSqrtToSelf = v1.copy(); - v_mapSqrtToSelf.mapSqrtToSelf(); + v_mapSqrtToSelf.mapToSelf(new Sqrt()); double[] result_mapSqrtToSelf = {1d,1.414213562373095e+00d,1.732050807568877e+00d}; assertClose("compare vectors" ,result_mapSqrtToSelf,v_mapSqrtToSelf.getData(),normTolerance); @@ -968,13 +814,13 @@ public class ArrayRealVectorTest extends ArrayRealVector cbrt_v = new ArrayRealVector(cbrt_a); //octave = ??? - RealVector v_mapCbrt = cbrt_v.mapCbrt(); + RealVector v_mapCbrt = cbrt_v.map(new Cbrt()); double[] result_mapCbrt = {-1.2599210498948732d,0d,1.2599210498948732d}; assertClose("compare vectors" ,result_mapCbrt,v_mapCbrt.getData(),normTolerance); //octave = ??? RealVector v_mapCbrtToSelf = cbrt_v.copy(); - v_mapCbrtToSelf.mapCbrtToSelf(); + v_mapCbrtToSelf.mapToSelf(new Cbrt()); double[] result_mapCbrtToSelf = {-1.2599210498948732d,0d,1.2599210498948732d}; assertClose("compare vectors" ,result_mapCbrtToSelf,v_mapCbrtToSelf.getData(),normTolerance); @@ -982,64 +828,64 @@ public class ArrayRealVectorTest extends ArrayRealVector ceil_v = new ArrayRealVector(ceil_a); //octave = ceil(ceil_v) - RealVector v_mapCeil = ceil_v.mapCeil(); + RealVector v_mapCeil = ceil_v.map(new Ceil()); double[] result_mapCeil = {-1d,1d,2d}; assertClose("compare vectors" ,result_mapCeil,v_mapCeil.getData(),normTolerance); //octave = ceil(ceil_v) RealVector v_mapCeilToSelf = ceil_v.copy(); - v_mapCeilToSelf.mapCeilToSelf(); + v_mapCeilToSelf.mapToSelf(new Ceil()); double[] result_mapCeilToSelf = {-1d,1d,2d}; assertClose("compare vectors" ,result_mapCeilToSelf,v_mapCeilToSelf.getData(),normTolerance); //octave = floor(ceil_v) - RealVector v_mapFloor = ceil_v.mapFloor(); + RealVector v_mapFloor = ceil_v.map(new Floor()); double[] result_mapFloor = {-2d,0d,1d}; assertClose("compare vectors" ,result_mapFloor,v_mapFloor.getData(),normTolerance); //octave = floor(ceil_v) RealVector v_mapFloorToSelf = ceil_v.copy(); - v_mapFloorToSelf.mapFloorToSelf(); + v_mapFloorToSelf.mapToSelf(new Floor()); double[] result_mapFloorToSelf = {-2d,0d,1d}; assertClose("compare vectors" ,result_mapFloorToSelf,v_mapFloorToSelf.getData(),normTolerance); //octave = ??? - RealVector v_mapRint = ceil_v.mapRint(); + RealVector v_mapRint = ceil_v.map(new Rint()); double[] result_mapRint = {-1d,1d,1d}; assertClose("compare vectors" ,result_mapRint,v_mapRint.getData(),normTolerance); //octave = ??? RealVector v_mapRintToSelf = ceil_v.copy(); - v_mapRintToSelf.mapRintToSelf(); + v_mapRintToSelf.mapToSelf(new Rint()); double[] result_mapRintToSelf = {-1d,1d,1d}; assertClose("compare vectors" ,result_mapRintToSelf,v_mapRintToSelf.getData(),normTolerance); //octave = ??? - RealVector v_mapSignum = ceil_v.mapSignum(); + RealVector v_mapSignum = ceil_v.map(new Signum()); double[] result_mapSignum = {-1d,1d,1d}; assertClose("compare vectors" ,result_mapSignum,v_mapSignum.getData(),normTolerance); //octave = ??? RealVector v_mapSignumToSelf = ceil_v.copy(); - v_mapSignumToSelf.mapSignumToSelf(); + v_mapSignumToSelf.mapToSelf(new Signum()); double[] result_mapSignumToSelf = {-1d,1d,1d}; assertClose("compare vectors" ,result_mapSignumToSelf,v_mapSignumToSelf.getData(),normTolerance); // Is with the used resolutions of limited value as test //octave = ??? - RealVector v_mapUlp = ceil_v.mapUlp(); + RealVector v_mapUlp = ceil_v.map(new Ulp()); double[] result_mapUlp = {2.220446049250313E-16d,1.1102230246251565E-16d,2.220446049250313E-16d}; assertClose("compare vectors" ,result_mapUlp,v_mapUlp.getData(),normTolerance); //octave = ??? RealVector v_mapUlpToSelf = ceil_v.copy(); - v_mapUlpToSelf.mapUlpToSelf(); + v_mapUlpToSelf.mapToSelf(new Ulp()); double[] result_mapUlpToSelf = {2.220446049250313E-16d,1.1102230246251565E-16d,2.220446049250313E-16d}; assertClose("compare vectors" ,result_mapUlpToSelf,v_mapUlpToSelf.getData(),normTolerance); - } + @Test public void testBasicFunctions() { ArrayRealVector v1 = new ArrayRealVector(vec1); ArrayRealVector v2 = new ArrayRealVector(vec2); @@ -1050,53 +896,53 @@ public class ArrayRealVectorTest extends // emacs calc: [-4, 0, 3, 1, -6, 3] A --> 8.4261497731763586307 double d_getNorm = v5.getNorm(); - assertEquals("compare values ", 8.4261497731763586307, d_getNorm); + Assert.assertEquals("compare values ", 8.4261497731763586307, d_getNorm, normTolerance); // emacs calc: [-4, 0, 3, 1, -6, 3] vN --> 17 double d_getL1Norm = v5.getL1Norm(); - assertEquals("compare values ", 17.0, d_getL1Norm); + Assert.assertEquals("compare values ", 17.0, d_getL1Norm, normTolerance); // emacs calc: [-4, 0, 3, 1, -6, 3] vn --> 6 double d_getLInfNorm = v5.getLInfNorm(); - assertEquals("compare values ", 6.0, d_getLInfNorm); + Assert.assertEquals("compare values ", 6.0, d_getLInfNorm, normTolerance); //octave = sqrt(sumsq(v1-v2)) double dist = v1.getDistance(v2); - assertEquals("compare values ",v1.subtract(v2).getNorm(), dist ); + Assert.assertEquals("compare values ",v1.subtract(v2).getNorm(), dist, normTolerance); //octave = sqrt(sumsq(v1-v2)) double dist_2 = v1.getDistance(v2_t); - assertEquals("compare values ", v1.subtract(v2).getNorm(),dist_2 ); + Assert.assertEquals("compare values ", v1.subtract(v2).getNorm(),dist_2, normTolerance); //octave = sqrt(sumsq(v1-v2)) double dist_3 = v1.getDistance((RealVector) v2); - assertEquals("compare values ", v1.subtract(v2).getNorm(),dist_3 ); + Assert.assertEquals("compare values ", v1.subtract(v2).getNorm(),dist_3, normTolerance); //octave = ??? double d_getL1Distance = v1. getL1Distance(v2); - assertEquals("compare values ",9d, d_getL1Distance ); + Assert.assertEquals("compare values ", 9d, d_getL1Distance, normTolerance); - double d_getL1Distance_2 = v1. getL1Distance(v2_t); - assertEquals("compare values ",9d, d_getL1Distance_2 ); + double d_getL1Distance_2 = v1.getL1Distance(v2_t); + Assert.assertEquals("compare values ", 9d, d_getL1Distance_2, normTolerance); - double d_getL1Distance_3 = v1. getL1Distance((RealVector) v2); - assertEquals("compare values ",9d, d_getL1Distance_3 ); + double d_getL1Distance_3 = v1.getL1Distance((RealVector) v2); + Assert.assertEquals("compare values ", 9d, d_getL1Distance_3, normTolerance); //octave = ??? - double d_getLInfDistance = v1. getLInfDistance(v2); - assertEquals("compare values ",3d, d_getLInfDistance ); + double d_getLInfDistance = v1.getLInfDistance(v2); + Assert.assertEquals("compare values ", 3d, d_getLInfDistance, normTolerance); double d_getLInfDistance_2 = v1. getLInfDistance(v2_t); - assertEquals("compare values ",3d, d_getLInfDistance_2 ); + Assert.assertEquals("compare values ", 3d, d_getLInfDistance_2, normTolerance); double d_getLInfDistance_3 = v1. getLInfDistance((RealVector) v2); - assertEquals("compare values ",3d, d_getLInfDistance_3 ); + Assert.assertEquals("compare values ", 3d, d_getLInfDistance_3, normTolerance); //octave = v1 + v2 ArrayRealVector v_add = v1.add(v2); double[] result_add = {5d, 7d, 9d}; - assertClose("compare vect" ,v_add.getData(),result_add,normTolerance); + assertClose("compare vect" ,v_add.getData(), result_add, normTolerance); RealVectorTestImpl vt2 = new RealVectorTestImpl(vec2); RealVector v_add_i = v1.add(vt2); @@ -1140,20 +986,20 @@ public class ArrayRealVectorTest extends // octave dot(v1,v2) double dot = v1.dotProduct(v2); - assertEquals("compare val ",32d, dot); + Assert.assertEquals("compare val ",32d, dot, normTolerance); // octave dot(v1,v2_t) double dot_2 = v1.dotProduct(v2_t); - assertEquals("compare val ",32d, dot_2); + Assert.assertEquals("compare val ",32d, dot_2, normTolerance); RealMatrix m_outerProduct = v1.outerProduct(v2); - assertEquals("compare val ",4d, m_outerProduct.getEntry(0,0)); + Assert.assertEquals("compare val ",4d, m_outerProduct.getEntry(0,0), normTolerance); RealMatrix m_outerProduct_2 = v1.outerProduct(v2_t); - assertEquals("compare val ",4d, m_outerProduct_2.getEntry(0,0)); + Assert.assertEquals("compare val ",4d, m_outerProduct_2.getEntry(0,0), normTolerance); RealMatrix m_outerProduct_3 = v1.outerProduct((RealVector) v2); - assertEquals("compare val ",4d, m_outerProduct_3.getEntry(0,0)); + Assert.assertEquals("compare val ",4d, m_outerProduct_3.getEntry(0,0), normTolerance); RealVector v_unitVector = v1.unitVector(); RealVector v_unitVector_2 = v1.mapDivide(v1.getNorm()); @@ -1161,7 +1007,7 @@ public class ArrayRealVectorTest extends try { v_null.unitVector(); - fail("Expecting ArithmeticException"); + Assert.fail("Expecting ArithmeticException"); } catch (ArithmeticException ex) { // expected behavior } @@ -1171,7 +1017,7 @@ public class ArrayRealVectorTest extends assertClose("compare vect" ,v_unitVector_2.getData(),v_unitize.getData(),normTolerance); try { v_null.unitize(); - fail("Expecting ArithmeticException"); + Assert.fail("Expecting ArithmeticException"); } catch (ArithmeticException ex) { // expected behavior } @@ -1190,109 +1036,114 @@ public class ArrayRealVectorTest extends } + @Test public void testMisc() { ArrayRealVector v1 = new ArrayRealVector(vec1); ArrayRealVector v4 = new ArrayRealVector(vec4); RealVector v4_2 = new ArrayRealVector(vec4); String out1 = v1.toString(); - assertTrue("some output ", out1.length()!=0); + Assert.assertTrue("some output ", out1.length()!=0); /* double[] dout1 = v1.copyOut(); - assertEquals("testData len", 3, dout1.length); - assertNotSame("testData not same object ", v1.data, dout1); + Assert.assertEquals("testData len", 3, dout1.length); + Assert.assertNotSame("testData not same object ", v1.data, dout1); */ try { v1.checkVectorDimensions(2); - fail("IllegalArgumentException expected"); + Assert.fail("IllegalArgumentException expected"); } catch (IllegalArgumentException ex) { // expected behavior } try { v1.checkVectorDimensions(v4); - fail("IllegalArgumentException expected"); + Assert.fail("IllegalArgumentException expected"); } catch (IllegalArgumentException ex) { // expected behavior } try { v1.checkVectorDimensions(v4_2); - fail("IllegalArgumentException expected"); + Assert.fail("IllegalArgumentException expected"); } catch (IllegalArgumentException ex) { // expected behavior } } + @Test public void testPredicates() { ArrayRealVector v = new ArrayRealVector(new double[] { 0, 1, 2 }); - assertFalse(v.isNaN()); + Assert.assertFalse(v.isNaN()); v.setEntry(1, Double.NaN); - assertTrue(v.isNaN()); + Assert.assertTrue(v.isNaN()); - assertFalse(v.isInfinite()); + Assert.assertFalse(v.isInfinite()); v.setEntry(0, Double.POSITIVE_INFINITY); - assertFalse(v.isInfinite()); + Assert.assertFalse(v.isInfinite()); v.setEntry(1, 1); - assertTrue(v.isInfinite()); + Assert.assertTrue(v.isInfinite()); v.setEntry(0, 1); - assertFalse(v.isInfinite()); + Assert.assertFalse(v.isInfinite()); v.setEntry(0, 0); - assertEquals(v, new ArrayRealVector(new double[] { 0, 1, 2 })); - assertNotSame(v, new ArrayRealVector(new double[] { 0, 1, 2 + FastMath.ulp(2)})); - assertNotSame(v, new ArrayRealVector(new double[] { 0, 1, 2, 3 })); + Assert.assertEquals(v, new ArrayRealVector(new double[] { 0, 1, 2 })); + Assert.assertNotSame(v, new ArrayRealVector(new double[] { 0, 1, 2 + FastMath.ulp(2)})); + Assert.assertNotSame(v, new ArrayRealVector(new double[] { 0, 1, 2, 3 })); - assertEquals(new ArrayRealVector(new double[] { Double.NaN, 1, 2 }).hashCode(), + Assert.assertEquals(new ArrayRealVector(new double[] { Double.NaN, 1, 2 }).hashCode(), new ArrayRealVector(new double[] { 0, Double.NaN, 2 }).hashCode()); - assertTrue(new ArrayRealVector(new double[] { Double.NaN, 1, 2 }).hashCode() != + Assert.assertTrue(new ArrayRealVector(new double[] { Double.NaN, 1, 2 }).hashCode() != new ArrayRealVector(new double[] { 0, 1, 2 }).hashCode()); - assertTrue(v.equals(v)); - assertTrue(v.equals(v.copy())); - assertFalse(v.equals(null)); - assertFalse(v.equals(v.getDataRef())); - assertFalse(v.equals(v.getSubVector(0, v.getDimension() - 1))); - assertTrue(v.equals(v.getSubVector(0, v.getDimension()))); + Assert.assertTrue(v.equals(v)); + Assert.assertTrue(v.equals(v.copy())); + Assert.assertFalse(v.equals(null)); + Assert.assertFalse(v.equals(v.getDataRef())); + Assert.assertFalse(v.equals(v.getSubVector(0, v.getDimension() - 1))); + Assert.assertTrue(v.equals(v.getSubVector(0, v.getDimension()))); } + @Test public void testSerial() { ArrayRealVector v = new ArrayRealVector(new double[] { 0, 1, 2 }); - assertEquals(v,TestUtils.serializeAndRecover(v)); + Assert.assertEquals(v,TestUtils.serializeAndRecover(v)); } + @Test public void testZeroVectors() { - assertEquals(0, new ArrayRealVector(new double[0]).getDimension()); - assertEquals(0, new ArrayRealVector(new double[0], true).getDimension()); - assertEquals(0, new ArrayRealVector(new double[0], false).getDimension()); + Assert.assertEquals(0, new ArrayRealVector(new double[0]).getDimension()); + Assert.assertEquals(0, new ArrayRealVector(new double[0], true).getDimension()); + Assert.assertEquals(0, new ArrayRealVector(new double[0], false).getDimension()); } + @Test public void testMinMax() { ArrayRealVector v1 = new ArrayRealVector(new double[] { 0, -6, 4, 12, 7 }); - assertEquals(1, v1.getMinIndex()); - assertEquals(-6, v1.getMinValue(), 1.0e-12); - assertEquals(3, v1.getMaxIndex()); - assertEquals(12, v1.getMaxValue(), 1.0e-12); + Assert.assertEquals(1, v1.getMinIndex()); + Assert.assertEquals(-6, v1.getMinValue(), 1.0e-12); + Assert.assertEquals(3, v1.getMaxIndex()); + Assert.assertEquals(12, v1.getMaxValue(), 1.0e-12); ArrayRealVector v2 = new ArrayRealVector(new double[] { Double.NaN, 3, Double.NaN, -2 }); - assertEquals(3, v2.getMinIndex()); - assertEquals(-2, v2.getMinValue(), 1.0e-12); - assertEquals(1, v2.getMaxIndex()); - assertEquals(3, v2.getMaxValue(), 1.0e-12); + Assert.assertEquals(3, v2.getMinIndex()); + Assert.assertEquals(-2, v2.getMinValue(), 1.0e-12); + Assert.assertEquals(1, v2.getMaxIndex()); + Assert.assertEquals(3, v2.getMaxValue(), 1.0e-12); ArrayRealVector v3 = new ArrayRealVector(new double[] { Double.NaN, Double.NaN }); - assertEquals(-1, v3.getMinIndex()); - assertTrue(Double.isNaN(v3.getMinValue())); - assertEquals(-1, v3.getMaxIndex()); - assertTrue(Double.isNaN(v3.getMaxValue())); + Assert.assertEquals(-1, v3.getMinIndex()); + Assert.assertTrue(Double.isNaN(v3.getMinValue())); + Assert.assertEquals(-1, v3.getMaxIndex()); + Assert.assertTrue(Double.isNaN(v3.getMaxValue())); ArrayRealVector v4 = new ArrayRealVector(new double[0]); - assertEquals(-1, v4.getMinIndex()); - assertTrue(Double.isNaN(v4.getMinValue())); - assertEquals(-1, v4.getMaxIndex()); - assertTrue(Double.isNaN(v4.getMaxValue())); + Assert.assertEquals(-1, v4.getMinIndex()); + Assert.assertTrue(Double.isNaN(v4.getMinValue())); + Assert.assertEquals(-1, v4.getMaxIndex()); + Assert.assertTrue(Double.isNaN(v4.getMaxValue())); } @@ -1300,11 +1151,10 @@ public class ArrayRealVectorTest extends protected void assertClose(String msg, double[] m, double[] n, double tolerance) { if (m.length != n.length) { - fail("vectors have different lengths"); + Assert.fail("vectors have different lengths"); } for (int i = 0; i < m.length; i++) { - assertEquals(msg + " " + i + " elements differ", m[i],n[i],tolerance); + Assert.assertEquals(msg + " " + i + " elements differ", m[i],n[i],tolerance); } } - }
