Java tutorial
/* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor. */ package lirmm.inria.fr.math; import org.apache.commons.math3.exception.DimensionMismatchException; import org.apache.commons.math3.exception.MathIllegalArgumentException; import org.apache.commons.math3.exception.NoDataException; import org.apache.commons.math3.exception.NumberIsTooSmallException; import org.apache.commons.math3.exception.OutOfRangeException; import org.apache.commons.math3.linear.ArrayRealVector; import org.apache.commons.math3.linear.DefaultRealMatrixChangingVisitor; import org.apache.commons.math3.linear.DefaultRealMatrixPreservingVisitor; import org.apache.commons.math3.linear.LUDecomposition; import org.apache.commons.math3.linear.MatrixDimensionMismatchException; import org.apache.commons.math3.linear.NonSquareMatrixException; import org.apache.commons.math3.linear.RealMatrix; import org.apache.commons.math3.linear.RealVector; import org.apache.commons.math3.util.FastMath; import org.junit.Assert; import org.junit.Test; /** * * @author rbouadjenek */ public class BigSparseRealMatrixTest { // 3 x 3 identity matrix protected double[][] id = { { 1d, 0d, 0d }, { 0d, 1d, 0d }, { 0d, 0d, 1d } }; // Test data for group operations protected double[][] testData = { { 1d, 2d, 3d }, { 2d, 5d, 3d }, { 1d, 0d, 8d } }; protected double[][] testDataLU = { { 2d, 5d, 3d }, { .5d, -2.5d, 6.5d }, { 0.5d, 0.2d, .2d } }; protected double[][] testDataPlus2 = { { 3d, 4d, 5d }, { 4d, 7d, 5d }, { 3d, 2d, 10d } }; protected double[][] testDataMinus = { { -1d, -2d, -3d }, { -2d, -5d, -3d }, { -1d, 0d, -8d } }; protected double[] testDataRow1 = { 1d, 2d, 3d }; protected double[] testDataCol3 = { 3d, 3d, 8d }; protected double[][] testDataInv = { { -40d, 16d, 9d }, { 13d, -5d, -3d }, { 5d, -2d, -1d } }; protected double[] preMultTest = { 8, 12, 33 }; protected double[][] testData2 = { { 1d, 2d, 3d }, { 2d, 5d, 3d } }; protected double[][] testData2T = { { 1d, 2d }, { 2d, 5d }, { 3d, 3d } }; protected double[][] testDataPlusInv = { { -39d, 18d, 12d }, { 15d, 0d, 0d }, { 6d, -2d, 7d } }; // lu decomposition tests protected double[][] luData = { { 2d, 3d, 3d }, { 0d, 5d, 7d }, { 6d, 9d, 8d } }; protected double[][] luDataLUDecomposition = { { 6d, 9d, 8d }, { 0d, 5d, 7d }, { 0.33333333333333, 0d, 0.33333333333333 } }; // singular matrices protected double[][] singular = { { 2d, 3d }, { 2d, 3d } }; protected double[][] bigSingular = { { 1d, 2d, 3d, 4d }, { 2d, 5d, 3d, 4d }, { 7d, 3d, 256d, 1930d }, { 3d, 7d, 6d, 8d } }; // 4th row = 1st + 2nd protected double[][] detData = { { 1d, 2d, 3d }, { 4d, 5d, 6d }, { 7d, 8d, 10d } }; protected double[][] detData2 = { { 1d, 3d }, { 2d, 4d } }; // vectors protected double[] testVector = { 1, 2, 3 }; protected double[] testVector2 = { 1, 2, 3, 4 }; // submatrix accessor tests protected double[][] subTestData = { { 1, 2, 3, 4 }, { 1.5, 2.5, 3.5, 4.5 }, { 2, 4, 6, 8 }, { 4, 5, 6, 7 } }; // array selections protected double[][] subRows02Cols13 = { { 2, 4 }, { 4, 8 } }; protected double[][] subRows03Cols12 = { { 2, 3 }, { 5, 6 } }; protected double[][] subRows03Cols123 = { { 2, 3, 4 }, { 5, 6, 7 } }; // effective permutations protected double[][] subRows20Cols123 = { { 4, 6, 8 }, { 2, 3, 4 } }; protected double[][] subRows31Cols31 = { { 7, 5 }, { 4.5, 2.5 } }; // contiguous ranges protected double[][] subRows01Cols23 = { { 3, 4 }, { 3.5, 4.5 } }; protected double[][] subRows23Cols00 = { { 2 }, { 4 } }; protected double[][] subRows00Cols33 = { { 4 } }; // row matrices protected double[][] subRow0 = { { 1, 2, 3, 4 } }; protected double[][] subRow3 = { { 4, 5, 6, 7 } }; // column matrices protected double[][] subColumn1 = { { 2 }, { 2.5 }, { 4 }, { 5 } }; protected double[][] subColumn3 = { { 4 }, { 4.5 }, { 8 }, { 7 } }; // tolerances protected double entryTolerance = 10E-16; protected double normTolerance = 10E-14; protected double powerTolerance = 10E-16; @Test public void testMath870() { // Caveat: This implementation assumes that, for any {@code x}, // the equality {@code x * 0d == 0d} holds. But it is is not true for // {@code NaN}. Moreover, zero entries will lose their sign. // Some operations (that involve {@code NaN} and/or infinities) may // thus give incorrect results. BigSparseRealMatrix a = new BigSparseRealMatrix(3, 3); BigSparseRealMatrix x = new BigSparseRealMatrix(3, 1); x.setEntry(0, 0, Double.NaN); x.setEntry(2, 0, Double.NEGATIVE_INFINITY); BigSparseRealMatrix b = a.multiply(x); for (int i = 0; i < b.getRowDimension(); ++i) { for (int j = 0; j < b.getColumnDimension(); ++j) { // NaNs and infinities have disappeared, this is a limitation of our implementation Assert.assertEquals(0.0, b.getEntry(i, j), 1.0e-20); } } } @Test public void testDimensions() { BigSparseRealMatrix m = new BigSparseRealMatrix(testData); BigSparseRealMatrix m2 = new BigSparseRealMatrix(testData2); Assert.assertEquals("testData row dimension", 3, m.getRowDimension()); Assert.assertEquals("testData column dimension", 3, m.getColumnDimension()); Assert.assertTrue("testData is square", m.isSquare()); Assert.assertEquals("testData2 row dimension", 2, m2.getRowDimension()); Assert.assertEquals("testData2 column dimension", 3, m2.getColumnDimension()); Assert.assertTrue("testData2 is not square", !m2.isSquare()); } /** * test copy functions */ @Test public void testCopyFunctions() { BigSparseRealMatrix m1 = new BigSparseRealMatrix(testData); BigSparseRealMatrix m2 = new BigSparseRealMatrix(m1.getData()); Assert.assertEquals(m2, m1); BigSparseRealMatrix m3 = new BigSparseRealMatrix(testData); BigSparseRealMatrix m4 = new BigSparseRealMatrix(m3.getData()); Assert.assertEquals(m4, m3); } /** * test add */ @Test public void testAdd() { BigSparseRealMatrix m = new BigSparseRealMatrix(testData); BigSparseRealMatrix mInv = new BigSparseRealMatrix(testDataInv); RealMatrix mPlusMInv = m.add(mInv); double[][] sumEntries = mPlusMInv.getData(); for (int row = 0; row < m.getRowDimension(); row++) { for (int col = 0; col < m.getColumnDimension(); col++) { Assert.assertEquals("sum entry entry", testDataPlusInv[row][col], sumEntries[row][col], entryTolerance); } } } /** * test add failure */ @Test public void testAddFail() { BigSparseRealMatrix m = new BigSparseRealMatrix(testData); BigSparseRealMatrix m2 = new BigSparseRealMatrix(testData2); try { m.add(m2); Assert.fail("MathIllegalArgumentException expected"); } catch (MathIllegalArgumentException ex) { // ignored } } /** * test norm */ @Test public void testNorm() { BigSparseRealMatrix m = new BigSparseRealMatrix(testData); BigSparseRealMatrix m2 = new BigSparseRealMatrix(testData2); Assert.assertEquals("testData norm", 14d, m.getNorm(), entryTolerance); Assert.assertEquals("testData2 norm", 7d, m2.getNorm(), entryTolerance); } /** * test Frobenius norm */ @Test public void testFrobeniusNorm() { BigSparseRealMatrix m = new BigSparseRealMatrix(testData); BigSparseRealMatrix m2 = new BigSparseRealMatrix(testData2); Assert.assertEquals("testData Frobenius norm", FastMath.sqrt(117.0), m.getFrobeniusNorm(), entryTolerance); Assert.assertEquals("testData2 Frobenius norm", FastMath.sqrt(52.0), m2.getFrobeniusNorm(), entryTolerance); System.out.println(m2.getFrobeniusNorm()); } /** * test m-n = m + -n */ @Test public void testPlusMinus() { BigSparseRealMatrix m = new BigSparseRealMatrix(testData); BigSparseRealMatrix m2 = new BigSparseRealMatrix(testDataInv); TestUtils.assertEquals("m-n = m + -n", m.subtract(m2), m2.scalarMultiply(-1d).add(m), entryTolerance); try { m.subtract(new BigSparseRealMatrix(testData2)); Assert.fail("Expecting illegalArgumentException"); } catch (MathIllegalArgumentException ex) { // ignored } } /** * test specialOperation */ @Test public void testMultiply() { BigSparseRealMatrix m = new BigSparseRealMatrix(testData); BigSparseRealMatrix mInv = new BigSparseRealMatrix(testDataInv); BigSparseRealMatrix identity = new BigSparseRealMatrix(id); BigSparseRealMatrix m2 = new BigSparseRealMatrix(testData2); TestUtils.assertEquals("inverse multiply", m.multiply(mInv), identity, entryTolerance); TestUtils.assertEquals("inverse multiply", mInv.multiply(m), identity, entryTolerance); TestUtils.assertEquals("identity multiply", m.multiply(identity), m, entryTolerance); TestUtils.assertEquals("identity multiply", identity.multiply(mInv), mInv, entryTolerance); TestUtils.assertEquals("identity multiply", m2.multiply(identity), m2, entryTolerance); try { m.multiply(new BigSparseRealMatrix(bigSingular)); Assert.fail("Expecting illegalArgumentException"); } catch (MathIllegalArgumentException ex) { // ignored } } //Additional Test for BigSparseRealMatrixTest.testMultiply private double[][] d3 = new double[][] { { 1, 2, 3, 4 }, { 5, 6, 7, 8 } }; private double[][] d4 = new double[][] { { 1 }, { 2 }, { 3 }, { 4 } }; private double[][] d5 = new double[][] { { 30 }, { 70 } }; @Test public void testMultiply2() { RealMatrix m3 = new BigSparseRealMatrix(d3); RealMatrix m4 = new BigSparseRealMatrix(d4); RealMatrix m5 = new BigSparseRealMatrix(d5); TestUtils.assertEquals("m3*m4=m5", m3.multiply(m4), m5, entryTolerance); } @Test public void testPower() { BigSparseRealMatrix m = new BigSparseRealMatrix(testData); BigSparseRealMatrix mInv = new BigSparseRealMatrix(testDataInv); BigSparseRealMatrix mPlusInv = new BigSparseRealMatrix(testDataPlusInv); BigSparseRealMatrix identity = new BigSparseRealMatrix(id); TestUtils.assertEquals("m^0", m.power(0), identity, entryTolerance); TestUtils.assertEquals("mInv^0", mInv.power(0), identity, entryTolerance); TestUtils.assertEquals("mPlusInv^0", mPlusInv.power(0), identity, entryTolerance); TestUtils.assertEquals("m^1", m.power(1), m, entryTolerance); TestUtils.assertEquals("mInv^1", mInv.power(1), mInv, entryTolerance); TestUtils.assertEquals("mPlusInv^1", mPlusInv.power(1), mPlusInv, entryTolerance); RealMatrix C1 = m.copy(); RealMatrix C2 = mInv.copy(); RealMatrix C3 = mPlusInv.copy(); for (int i = 2; i <= 10; ++i) { C1 = C1.multiply(m); C2 = C2.multiply(mInv); C3 = C3.multiply(mPlusInv); TestUtils.assertEquals("m^" + i, m.power(i), C1, entryTolerance); TestUtils.assertEquals("mInv^" + i, mInv.power(i), C2, entryTolerance); TestUtils.assertEquals("mPlusInv^" + i, mPlusInv.power(i), C3, entryTolerance); } try { BigSparseRealMatrix mNotSquare = new BigSparseRealMatrix(testData2T); mNotSquare.power(2); Assert.fail("Expecting NonSquareMatrixException"); } catch (NonSquareMatrixException ex) { // ignored } try { m.power(-1); Assert.fail("Expecting IllegalArgumentException"); } catch (IllegalArgumentException ex) { // ignored } } /** * test trace */ @Test public void testTrace() { RealMatrix m = new BigSparseRealMatrix(id); Assert.assertEquals("identity trace", 3d, m.getTrace(), entryTolerance); m = new BigSparseRealMatrix(testData2); try { m.getTrace(); Assert.fail("Expecting NonSquareMatrixException"); } catch (NonSquareMatrixException ex) { // ignored } } /** * test sclarAdd */ @Test public void testScalarAdd() { RealMatrix m = new BigSparseRealMatrix(testData); TestUtils.assertEquals("scalar add", new BigSparseRealMatrix(testDataPlus2), m.scalarAdd(2d), entryTolerance); } /** * test operate */ @Test public void testOperate() { RealMatrix m = new BigSparseRealMatrix(id); TestUtils.assertEquals("identity operate", testVector, m.operate(testVector), entryTolerance); TestUtils.assertEquals("identity operate", testVector, m.operate(new ArrayRealVector(testVector)).toArray(), entryTolerance); m = new BigSparseRealMatrix(bigSingular); try { m.operate(testVector); Assert.fail("Expecting illegalArgumentException"); } catch (MathIllegalArgumentException ex) { // ignored } } /** * test issue MATH-209 */ @Test public void testMath209() { RealMatrix a = new BigSparseRealMatrix(new double[][] { { 1, 2 }, { 3, 4 }, { 5, 6 } }); double[] b = a.operate(new double[] { 1, 1 }); Assert.assertEquals(a.getRowDimension(), b.length); Assert.assertEquals(3.0, b[0], 1.0e-12); Assert.assertEquals(7.0, b[1], 1.0e-12); Assert.assertEquals(11.0, b[2], 1.0e-12); } /** * test transpose */ @Test public void testTranspose() { RealMatrix m = new BigSparseRealMatrix(testData); RealMatrix mIT = new LUDecomposition(m).getSolver().getInverse().transpose(); RealMatrix mTI = new LUDecomposition(m.transpose()).getSolver().getInverse(); TestUtils.assertEquals("inverse-transpose", mIT, mTI, normTolerance); m = new BigSparseRealMatrix(testData2); RealMatrix mt = new BigSparseRealMatrix(testData2T); TestUtils.assertEquals("transpose", mt, m.transpose(), normTolerance); } /** * test preMultiply by vector */ @Test public void testPremultiplyVector() { RealMatrix m = new BigSparseRealMatrix(testData); TestUtils.assertEquals("premultiply", m.preMultiply(testVector), preMultTest, normTolerance); TestUtils.assertEquals("premultiply", m.preMultiply(new ArrayRealVector(testVector).toArray()), preMultTest, normTolerance); m = new BigSparseRealMatrix(bigSingular); try { m.preMultiply(testVector); Assert.fail("expecting MathIllegalArgumentException"); } catch (MathIllegalArgumentException ex) { // ignored } } @Test public void testPremultiply() { RealMatrix m3 = new BigSparseRealMatrix(d3); RealMatrix m4 = new BigSparseRealMatrix(d4); RealMatrix m5 = new BigSparseRealMatrix(d5); TestUtils.assertEquals("m3*m4=m5", m4.preMultiply(m3), m5, entryTolerance); BigSparseRealMatrix m = new BigSparseRealMatrix(testData); BigSparseRealMatrix mInv = new BigSparseRealMatrix(testDataInv); BigSparseRealMatrix identity = new BigSparseRealMatrix(id); TestUtils.assertEquals("inverse multiply", m.preMultiply(mInv), identity, entryTolerance); TestUtils.assertEquals("inverse multiply", mInv.preMultiply(m), identity, entryTolerance); TestUtils.assertEquals("identity multiply", m.preMultiply(identity), m, entryTolerance); TestUtils.assertEquals("identity multiply", identity.preMultiply(mInv), mInv, entryTolerance); try { m.preMultiply(new BigSparseRealMatrix(bigSingular)); Assert.fail("Expecting illegalArgumentException"); } catch (MathIllegalArgumentException ex) { // ignored } } @Test public void testGetVectors() { RealMatrix m = new BigSparseRealMatrix(testData); TestUtils.assertEquals("get row", m.getRow(0), testDataRow1, entryTolerance); TestUtils.assertEquals("get col", m.getColumn(2), testDataCol3, entryTolerance); try { m.getRow(10); Assert.fail("expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // ignored } try { m.getColumn(-1); Assert.fail("expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // ignored } } @Test public void testGetEntry() { RealMatrix m = new BigSparseRealMatrix(testData); Assert.assertEquals("get entry", m.getEntry(0, 1), 2d, entryTolerance); try { m.getEntry(10, 4); Assert.fail("Expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // expected } } /** * test examples in user guide */ @Test public void testExamples() { // Create a real matrix with two rows and three columns double[][] matrixData = { { 1d, 2d, 3d }, { 2d, 5d, 3d } }; RealMatrix m = new BigSparseRealMatrix(matrixData); // One more with three rows, two columns double[][] matrixData2 = { { 1d, 2d }, { 2d, 5d }, { 1d, 7d } }; RealMatrix n = new BigSparseRealMatrix(matrixData2); // Now specialOperation m by n RealMatrix p = m.multiply(n); Assert.assertEquals(2, p.getRowDimension()); Assert.assertEquals(2, p.getColumnDimension()); // Invert p RealMatrix pInverse = new LUDecomposition(p).getSolver().getInverse(); Assert.assertEquals(2, pInverse.getRowDimension()); Assert.assertEquals(2, pInverse.getColumnDimension()); // Solve example double[][] coefficientsData = { { 2, 3, -2 }, { -1, 7, 6 }, { 4, -3, -5 } }; RealMatrix coefficients = new BigSparseRealMatrix(coefficientsData); RealVector constants = new ArrayRealVector(new double[] { 1, -2, 1 }, false); RealVector solution = new LUDecomposition(coefficients).getSolver().solve(constants); final double cst0 = constants.getEntry(0); final double cst1 = constants.getEntry(1); final double cst2 = constants.getEntry(2); final double sol0 = solution.getEntry(0); final double sol1 = solution.getEntry(1); final double sol2 = solution.getEntry(2); Assert.assertEquals(2 * sol0 + 3 * sol1 - 2 * sol2, cst0, 1E-12); Assert.assertEquals(-1 * sol0 + 7 * sol1 + 6 * sol2, cst1, 1E-12); Assert.assertEquals(4 * sol0 - 3 * sol1 - 5 * sol2, cst2, 1E-12); } // test submatrix accessors @Test public void testGetSubMatrix() { RealMatrix m = new BigSparseRealMatrix(subTestData); checkGetSubMatrix(m, subRows23Cols00, 2, 3, 0, 0, false); checkGetSubMatrix(m, subRows00Cols33, 0, 0, 3, 3, false); checkGetSubMatrix(m, subRows01Cols23, 0, 1, 2, 3, false); checkGetSubMatrix(m, subRows02Cols13, new int[] { 0, 2 }, new int[] { 1, 3 }, false); checkGetSubMatrix(m, subRows03Cols12, new int[] { 0, 3 }, new int[] { 1, 2 }, false); checkGetSubMatrix(m, subRows03Cols123, new int[] { 0, 3 }, new int[] { 1, 2, 3 }, false); checkGetSubMatrix(m, subRows20Cols123, new int[] { 2, 0 }, new int[] { 1, 2, 3 }, false); checkGetSubMatrix(m, subRows31Cols31, new int[] { 3, 1 }, new int[] { 3, 1 }, false); checkGetSubMatrix(m, subRows31Cols31, new int[] { 3, 1 }, new int[] { 3, 1 }, false); checkGetSubMatrix(m, null, 1, 0, 2, 4, true); checkGetSubMatrix(m, null, -1, 1, 2, 2, true); checkGetSubMatrix(m, null, 1, 0, 2, 2, true); checkGetSubMatrix(m, null, 1, 0, 2, 4, true); checkGetSubMatrix(m, null, new int[] {}, new int[] { 0 }, true); checkGetSubMatrix(m, null, new int[] { 0 }, new int[] { 4 }, true); } private void checkGetSubMatrix(RealMatrix m, double[][] reference, int startRow, int endRow, int startColumn, int endColumn, boolean mustFail) { try { RealMatrix sub = m.getSubMatrix(startRow, endRow, startColumn, endColumn); Assert.assertEquals(new BigSparseRealMatrix(reference), sub); if (mustFail) { Assert.fail("Expecting OutOfRangeException or NumberIsTooSmallException or NoDataException"); } } catch (OutOfRangeException e) { if (!mustFail) { throw e; } } catch (NumberIsTooSmallException e) { if (!mustFail) { throw e; } } catch (NoDataException e) { if (!mustFail) { throw e; } } } private void checkGetSubMatrix(RealMatrix m, double[][] reference, int[] selectedRows, int[] selectedColumns, boolean mustFail) { try { RealMatrix sub = m.getSubMatrix(selectedRows, selectedColumns); Assert.assertEquals(new BigSparseRealMatrix(reference), sub); if (mustFail) { Assert.fail("Expecting OutOfRangeException or NumberIsTooSmallException or NoDataException"); } } catch (OutOfRangeException e) { if (!mustFail) { throw e; } } catch (NumberIsTooSmallException e) { if (!mustFail) { throw e; } } catch (NoDataException e) { if (!mustFail) { throw e; } } } @Test public void testCopySubMatrix() { RealMatrix m = new BigSparseRealMatrix(subTestData); checkCopy(m, subRows23Cols00, 2, 3, 0, 0, false); checkCopy(m, subRows00Cols33, 0, 0, 3, 3, false); checkCopy(m, subRows01Cols23, 0, 1, 2, 3, false); checkCopy(m, subRows02Cols13, new int[] { 0, 2 }, new int[] { 1, 3 }, false); checkCopy(m, subRows03Cols12, new int[] { 0, 3 }, new int[] { 1, 2 }, false); checkCopy(m, subRows03Cols123, new int[] { 0, 3 }, new int[] { 1, 2, 3 }, false); checkCopy(m, subRows20Cols123, new int[] { 2, 0 }, new int[] { 1, 2, 3 }, false); checkCopy(m, subRows31Cols31, new int[] { 3, 1 }, new int[] { 3, 1 }, false); checkCopy(m, subRows31Cols31, new int[] { 3, 1 }, new int[] { 3, 1 }, false); checkCopy(m, null, 1, 0, 2, 4, true); checkCopy(m, null, -1, 1, 2, 2, true); checkCopy(m, null, 1, 0, 2, 2, true); checkCopy(m, null, 1, 0, 2, 4, true); checkCopy(m, null, new int[] {}, new int[] { 0 }, true); checkCopy(m, null, new int[] { 0 }, new int[] { 4 }, true); // rectangular check double[][] copy = new double[][] { { 0, 0, 0 }, { 0, 0 } }; checkCopy(m, copy, 0, 1, 0, 2, true); checkCopy(m, copy, new int[] { 0, 1 }, new int[] { 0, 1, 2 }, true); } private void checkCopy(RealMatrix m, double[][] reference, int startRow, int endRow, int startColumn, int endColumn, boolean mustFail) { try { double[][] sub = (reference == null) ? new double[1][1] : createIdenticalCopy(reference); m.copySubMatrix(startRow, endRow, startColumn, endColumn, sub); Assert.assertEquals(new BigSparseRealMatrix(reference), new BigSparseRealMatrix(sub)); if (mustFail) { Assert.fail("Expecting OutOfRangeException or NumberIsTooSmallException or NoDataException"); } } catch (OutOfRangeException e) { if (!mustFail) { throw e; } } catch (NumberIsTooSmallException e) { if (!mustFail) { throw e; } } catch (NoDataException e) { if (!mustFail) { throw e; } } catch (MatrixDimensionMismatchException e) { if (!mustFail) { throw e; } } } private void checkCopy(RealMatrix m, double[][] reference, int[] selectedRows, int[] selectedColumns, boolean mustFail) { try { double[][] sub = (reference == null) ? new double[1][1] : createIdenticalCopy(reference); m.copySubMatrix(selectedRows, selectedColumns, sub); Assert.assertEquals(new BigSparseRealMatrix(reference), new BigSparseRealMatrix(sub)); if (mustFail) { Assert.fail("Expecting OutOfRangeException or NumberIsTooSmallException or NoDataException"); } } catch (OutOfRangeException e) { if (!mustFail) { throw e; } } catch (NumberIsTooSmallException e) { if (!mustFail) { throw e; } } catch (NoDataException e) { if (!mustFail) { throw e; } } catch (MatrixDimensionMismatchException e) { if (!mustFail) { throw e; } } } private double[][] createIdenticalCopy(final double[][] matrix) { final double[][] matrixCopy = new double[matrix.length][]; for (int i = 0; i < matrixCopy.length; i++) { matrixCopy[i] = new double[matrix[i].length]; } return matrixCopy; } @Test public void testGetRowMatrix() { RealMatrix m = new BigSparseRealMatrix(subTestData); RealMatrix mRow0 = new BigSparseRealMatrix(subRow0); RealMatrix mRow3 = new BigSparseRealMatrix(subRow3); Assert.assertEquals("Row0", mRow0, m.getRowMatrix(0)); Assert.assertEquals("Row3", mRow3, m.getRowMatrix(3)); try { m.getRowMatrix(-1); Assert.fail("Expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // expected } try { m.getRowMatrix(4); Assert.fail("Expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // expected } } @Test public void testSetRowMatrix() { RealMatrix m = new BigSparseRealMatrix(subTestData); RealMatrix mRow3 = new BigSparseRealMatrix(subRow3); Assert.assertNotSame(mRow3, m.getRowMatrix(0)); m.setRowMatrix(0, mRow3); Assert.assertEquals(mRow3, m.getRowMatrix(0)); try { m.setRowMatrix(-1, mRow3); Assert.fail("Expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // expected } try { m.setRowMatrix(0, m); Assert.fail("Expecting MatrixDimensionMismatchException"); } catch (MatrixDimensionMismatchException ex) { // expected } } @Test public void testGetColumnMatrix() { RealMatrix m = new BigSparseRealMatrix(subTestData); RealMatrix mColumn1 = new BigSparseRealMatrix(subColumn1); RealMatrix mColumn3 = new BigSparseRealMatrix(subColumn3); Assert.assertEquals("Column1", mColumn1, m.getColumnMatrix(1)); Assert.assertEquals("Column3", mColumn3, m.getColumnMatrix(3)); try { m.getColumnMatrix(-1); Assert.fail("Expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // expected } try { m.getColumnMatrix(4); Assert.fail("Expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // expected } } @Test public void testSetColumnMatrix() { RealMatrix m = new BigSparseRealMatrix(subTestData); RealMatrix mColumn3 = new BigSparseRealMatrix(subColumn3); Assert.assertNotSame(mColumn3, m.getColumnMatrix(1)); m.setColumnMatrix(1, mColumn3); Assert.assertEquals(mColumn3, m.getColumnMatrix(1)); try { m.setColumnMatrix(-1, mColumn3); Assert.fail("Expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // expected } try { m.setColumnMatrix(0, m); Assert.fail("Expecting MatrixDimensionMismatchException"); } catch (MatrixDimensionMismatchException ex) { // expected } } @Test public void testGetRowVector() { RealMatrix m = new BigSparseRealMatrix(subTestData); RealVector mRow0 = new ArrayRealVector(subRow0[0]); RealVector mRow3 = new ArrayRealVector(subRow3[0]); Assert.assertEquals("Row0", mRow0, m.getRowVector(0)); Assert.assertEquals("Row3", mRow3, m.getRowVector(3)); try { m.getRowVector(-1); Assert.fail("Expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // expected } try { m.getRowVector(4); Assert.fail("Expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // expected } } @Test public void testSetRowVector() { RealMatrix m = new BigSparseRealMatrix(subTestData); RealVector mRow3 = new ArrayRealVector(subRow3[0]); Assert.assertNotSame(mRow3, m.getRowMatrix(0)); m.setRowVector(0, mRow3); Assert.assertEquals(mRow3, m.getRowVector(0)); try { m.setRowVector(-1, mRow3); Assert.fail("Expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // expected } try { m.setRowVector(0, new ArrayRealVector(5)); Assert.fail("Expecting MatrixDimensionMismatchException"); } catch (MatrixDimensionMismatchException ex) { // expected } } @Test public void testGetColumnVector() { RealMatrix m = new BigSparseRealMatrix(subTestData); RealVector mColumn1 = columnToVector(subColumn1); RealVector mColumn3 = columnToVector(subColumn3); Assert.assertEquals("Column1", mColumn1, m.getColumnVector(1)); Assert.assertEquals("Column3", mColumn3, m.getColumnVector(3)); try { m.getColumnVector(-1); Assert.fail("Expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // expected } try { m.getColumnVector(4); Assert.fail("Expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // expected } } @Test public void testSetColumnVector() { RealMatrix m = new BigSparseRealMatrix(subTestData); RealVector mColumn3 = columnToVector(subColumn3); Assert.assertNotSame(mColumn3, m.getColumnVector(1)); m.setColumnVector(1, mColumn3); Assert.assertEquals(mColumn3, m.getColumnVector(1)); try { m.setColumnVector(-1, mColumn3); Assert.fail("Expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // expected } try { m.setColumnVector(0, new ArrayRealVector(5)); Assert.fail("Expecting MatrixDimensionMismatchException"); } catch (MatrixDimensionMismatchException ex) { // expected } } private RealVector columnToVector(double[][] column) { double[] data = new double[column.length]; for (int i = 0; i < data.length; ++i) { data[i] = column[i][0]; } return new ArrayRealVector(data, false); } @Test public void testGetRow() { RealMatrix m = new BigSparseRealMatrix(subTestData); checkArrays(subRow0[0], m.getRow(0)); checkArrays(subRow3[0], m.getRow(3)); try { m.getRow(-1); Assert.fail("Expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // expected } try { m.getRow(4); Assert.fail("Expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // expected } } @Test public void testSetRow() { RealMatrix m = new BigSparseRealMatrix(subTestData); Assert.assertTrue(subRow3[0][0] != m.getRow(0)[0]); m.setRow(0, subRow3[0]); checkArrays(subRow3[0], m.getRow(0)); try { m.setRow(-1, subRow3[0]); Assert.fail("Expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // expected } try { m.setRow(0, new double[5]); Assert.fail("Expecting MatrixDimensionMismatchException"); } catch (MatrixDimensionMismatchException ex) { // expected } } @Test public void testGetColumn() { RealMatrix m = new BigSparseRealMatrix(subTestData); double[] mColumn1 = columnToArray(subColumn1); double[] mColumn3 = columnToArray(subColumn3); checkArrays(mColumn1, m.getColumn(1)); checkArrays(mColumn3, m.getColumn(3)); try { m.getColumn(-1); Assert.fail("Expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // expected } try { m.getColumn(4); Assert.fail("Expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // expected } } @Test public void testSetColumn() { RealMatrix m = new BigSparseRealMatrix(subTestData); double[] mColumn3 = columnToArray(subColumn3); Assert.assertTrue(mColumn3[0] != m.getColumn(1)[0]); m.setColumn(1, mColumn3); checkArrays(mColumn3, m.getColumn(1)); try { m.setColumn(-1, mColumn3); Assert.fail("Expecting OutOfRangeException"); } catch (OutOfRangeException ex) { // expected } try { m.setColumn(0, new double[5]); Assert.fail("Expecting MatrixDimensionMismatchException"); } catch (MatrixDimensionMismatchException ex) { // expected } } private double[] columnToArray(double[][] column) { double[] data = new double[column.length]; for (int i = 0; i < data.length; ++i) { data[i] = column[i][0]; } return data; } private void checkArrays(double[] expected, double[] actual) { Assert.assertEquals(expected.length, actual.length); for (int i = 0; i < expected.length; ++i) { Assert.assertEquals(expected[i], actual[i], 0); } } @Test public void testEqualsAndHashCode() { BigSparseRealMatrix m = new BigSparseRealMatrix(testData); BigSparseRealMatrix m1 = (BigSparseRealMatrix) m.copy(); BigSparseRealMatrix mt = (BigSparseRealMatrix) m.transpose(); Assert.assertTrue(m.hashCode() != mt.hashCode()); Assert.assertEquals(m.hashCode(), m1.hashCode()); Assert.assertEquals(m, m); Assert.assertEquals(m, m1); Assert.assertFalse(m.equals(null)); Assert.assertFalse(m.equals(mt)); Assert.assertFalse(m.equals(new BigSparseRealMatrix(bigSingular))); } // @Test // public void testSetSubMatrix() { // BigSparseRealMatrix m = new BigSparseRealMatrix(testData); // m.setSubMatrix(detData2,1,1); // RealMatrix expected = MatrixUtils.createRealMatrix // (new double[][] {{1.0,2.0,3.0},{2.0,1.0,3.0},{1.0,2.0,4.0}}); // Assert.assertEquals(expected, m); // // m.setSubMatrix(detData2,0,0); // expected = MatrixUtils.createRealMatrix // (new double[][] {{1.0,3.0,3.0},{2.0,4.0,3.0},{1.0,2.0,4.0}}); // Assert.assertEquals(expected, m); // // m.setSubMatrix(testDataPlus2,0,0); // expected = MatrixUtils.createRealMatrix // (new double[][] {{3.0,4.0,5.0},{4.0,7.0,5.0},{3.0,2.0,10.0}}); // Assert.assertEquals(expected, m); // // // dimension overflow // try { // m.setSubMatrix(testData,1,1); // Assert.fail("expecting OutOfRangeException"); // } catch (OutOfRangeException e) { // // expected // } // // dimension underflow // try { // m.setSubMatrix(testData,-1,1); // Assert.fail("expecting OutOfRangeException"); // } catch (OutOfRangeException e) { // // expected // } // try { // m.setSubMatrix(testData,1,-1); // Assert.fail("expecting OutOfRangeException"); // } catch (OutOfRangeException e) { // // expected // } // // // null // try { // m.setSubMatrix(null,1,1); // Assert.fail("expecting NullArgumentException"); // } catch (NullArgumentException e) { // // expected // } // BigSparseRealMatrix m2 = new BigSparseRealMatrix(); // try { // m2.setSubMatrix(testData,0,1); // Assert.fail("expecting MathIllegalStateException"); // } catch (MathIllegalStateException e) { // // expected // } // try { // m2.setSubMatrix(testData,1,0); // Assert.fail("expecting MathIllegalStateException"); // } catch (MathIllegalStateException e) { // // expected // } // // // ragged // try { // m.setSubMatrix(new double[][] {{1}, {2, 3}}, 0, 0); // Assert.fail("expecting MathIllegalArgumentException"); // } catch (MathIllegalArgumentException e) { // // expected // } // // // empty // try { // m.setSubMatrix(new double[][] {{}}, 0, 0); // Assert.fail("expecting MathIllegalArgumentException"); // } catch (MathIllegalArgumentException e) { // // expected // } // } @Test public void testWalk() { int rows = 150; int columns = 75; RealMatrix m = new BigSparseRealMatrix(rows, columns); m.walkInRowOrder(new SetVisitor()); GetVisitor getVisitor = new GetVisitor(); m.walkInOptimizedOrder(getVisitor); Assert.assertEquals(rows * columns, getVisitor.getCount()); m = new BigSparseRealMatrix(rows, columns); m.walkInRowOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2); getVisitor = new GetVisitor(); m.walkInOptimizedOrder(getVisitor, 1, rows - 2, 1, columns - 2); Assert.assertEquals((rows - 2) * (columns - 2), getVisitor.getCount()); for (int i = 0; i < rows; ++i) { Assert.assertEquals(0.0, m.getEntry(i, 0), 0); Assert.assertEquals(0.0, m.getEntry(i, columns - 1), 0); } for (int j = 0; j < columns; ++j) { Assert.assertEquals(0.0, m.getEntry(0, j), 0); Assert.assertEquals(0.0, m.getEntry(rows - 1, j), 0); } m = new BigSparseRealMatrix(rows, columns); m.walkInColumnOrder(new SetVisitor()); getVisitor = new GetVisitor(); m.walkInOptimizedOrder(getVisitor); Assert.assertEquals(rows * columns, getVisitor.getCount()); m = new BigSparseRealMatrix(rows, columns); m.walkInColumnOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2); getVisitor = new GetVisitor(); m.walkInOptimizedOrder(getVisitor, 1, rows - 2, 1, columns - 2); Assert.assertEquals((rows - 2) * (columns - 2), getVisitor.getCount()); for (int i = 0; i < rows; ++i) { Assert.assertEquals(0.0, m.getEntry(i, 0), 0); Assert.assertEquals(0.0, m.getEntry(i, columns - 1), 0); } for (int j = 0; j < columns; ++j) { Assert.assertEquals(0.0, m.getEntry(0, j), 0); Assert.assertEquals(0.0, m.getEntry(rows - 1, j), 0); } m = new BigSparseRealMatrix(rows, columns); m.walkInOptimizedOrder(new SetVisitor()); getVisitor = new GetVisitor(); m.walkInRowOrder(getVisitor); Assert.assertEquals(rows * columns, getVisitor.getCount()); m = new BigSparseRealMatrix(rows, columns); m.walkInOptimizedOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2); getVisitor = new GetVisitor(); m.walkInRowOrder(getVisitor, 1, rows - 2, 1, columns - 2); Assert.assertEquals((rows - 2) * (columns - 2), getVisitor.getCount()); for (int i = 0; i < rows; ++i) { Assert.assertEquals(0.0, m.getEntry(i, 0), 0); Assert.assertEquals(0.0, m.getEntry(i, columns - 1), 0); } for (int j = 0; j < columns; ++j) { Assert.assertEquals(0.0, m.getEntry(0, j), 0); Assert.assertEquals(0.0, m.getEntry(rows - 1, j), 0); } m = new BigSparseRealMatrix(rows, columns); m.walkInOptimizedOrder(new SetVisitor()); getVisitor = new GetVisitor(); m.walkInColumnOrder(getVisitor); Assert.assertEquals(rows * columns, getVisitor.getCount()); m = new BigSparseRealMatrix(rows, columns); m.walkInOptimizedOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2); getVisitor = new GetVisitor(); m.walkInColumnOrder(getVisitor, 1, rows - 2, 1, columns - 2); Assert.assertEquals((rows - 2) * (columns - 2), getVisitor.getCount()); for (int i = 0; i < rows; ++i) { Assert.assertEquals(0.0, m.getEntry(i, 0), 0); Assert.assertEquals(0.0, m.getEntry(i, columns - 1), 0); } for (int j = 0; j < columns; ++j) { Assert.assertEquals(0.0, m.getEntry(0, j), 0); Assert.assertEquals(0.0, m.getEntry(rows - 1, j), 0); } } @Test public void testSerial() { BigSparseRealMatrix m = new BigSparseRealMatrix(testData); Assert.assertEquals(m, TestUtils.serializeAndRecover(m)); } private static class SetVisitor extends DefaultRealMatrixChangingVisitor { @Override public double visit(int i, int j, double value) { return i + j / 1024.0; } } private static class GetVisitor extends DefaultRealMatrixPreservingVisitor { private int count = 0; @Override public void visit(int i, int j, double value) { ++count; Assert.assertEquals(i + j / 1024.0, value, 0.0); } public int getCount() { return count; } } //--------------- -----------------Protected methods /** * extracts the l and u matrices from compact lu representation */ protected void splitLU(RealMatrix lu, double[][] lowerData, double[][] upperData) { if (!lu.isSquare()) { throw new NonSquareMatrixException(lu.getRowDimension(), lu.getColumnDimension()); } if (lowerData.length != lowerData[0].length) { throw new DimensionMismatchException(lowerData.length, lowerData[0].length); } if (upperData.length != upperData[0].length) { throw new DimensionMismatchException(upperData.length, upperData[0].length); } if (lowerData.length != upperData.length) { throw new DimensionMismatchException(lowerData.length, upperData.length); } if (lowerData.length != lu.getRowDimension()) { throw new DimensionMismatchException(lowerData.length, lu.getRowDimension()); } int n = lu.getRowDimension(); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (j < i) { lowerData[i][j] = lu.getEntry(i, j); upperData[i][j] = 0d; } else if (i == j) { lowerData[i][j] = 1d; upperData[i][j] = lu.getEntry(i, j); } else { lowerData[i][j] = 0d; upperData[i][j] = lu.getEntry(i, j); } } } } /** * Returns the result of applying the given row permutation to the matrix */ protected RealMatrix permuteRows(RealMatrix matrix, int[] permutation) { if (!matrix.isSquare()) { throw new NonSquareMatrixException(matrix.getRowDimension(), matrix.getColumnDimension()); } if (matrix.getRowDimension() != permutation.length) { throw new DimensionMismatchException(matrix.getRowDimension(), permutation.length); } int n = matrix.getRowDimension(); int m = matrix.getColumnDimension(); double out[][] = new double[m][n]; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { out[i][j] = matrix.getEntry(permutation[i], j); } } return new BigSparseRealMatrix(out); } }