|
Commons Math example source code file (RealMatrixImplTest.java)
The Commons Math RealMatrixImplTest.java source code/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.math.linear; import junit.framework.TestCase; import org.apache.commons.math.TestUtils; /** * Test cases for the {@link RealMatrixImpl} class. * * @version $Revision: 902201 $ $Date: 2010-01-22 13:18:16 -0500 (Fri, 22 Jan 2010) $ */ @Deprecated public final class RealMatrixImplTest extends TestCase { // 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; public RealMatrixImplTest(String name) { super(name); } /** test dimensions */ public void testDimensions() { RealMatrixImpl m = new RealMatrixImpl(testData); RealMatrixImpl m2 = new RealMatrixImpl(testData2); assertEquals("testData row dimension",3,m.getRowDimension()); assertEquals("testData column dimension",3,m.getColumnDimension()); assertTrue("testData is square",m.isSquare()); assertEquals("testData2 row dimension",m2.getRowDimension(),2); assertEquals("testData2 column dimension",m2.getColumnDimension(),3); assertTrue("testData2 is not square",!m2.isSquare()); } /** test copy functions */ public void testCopyFunctions() { RealMatrixImpl m1 = new RealMatrixImpl(testData); RealMatrixImpl m2 = new RealMatrixImpl(m1.getData()); assertEquals(m2,m1); RealMatrixImpl m3 = new RealMatrixImpl(testData); RealMatrixImpl m4 = new RealMatrixImpl(m3.getData(), false); assertEquals(m4,m3); } /** test add */ public void testAdd() { RealMatrixImpl m = new RealMatrixImpl(testData); RealMatrixImpl mInv = new RealMatrixImpl(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++) { assertEquals("sum entry entry", testDataPlusInv[row][col],sumEntries[row][col], entryTolerance); } } } /** test add failure */ public void testAddFail() { RealMatrixImpl m = new RealMatrixImpl(testData); RealMatrixImpl m2 = new RealMatrixImpl(testData2); try { m.add(m2); fail("IllegalArgumentException expected"); } catch (IllegalArgumentException ex) { // ignored } } /** test norm */ public void testNorm() { RealMatrixImpl m = new RealMatrixImpl(testData); RealMatrixImpl m2 = new RealMatrixImpl(testData2); assertEquals("testData norm",14d,m.getNorm(),entryTolerance); assertEquals("testData2 norm",7d,m2.getNorm(),entryTolerance); } /** test Frobenius norm */ public void testFrobeniusNorm() { RealMatrixImpl m = new RealMatrixImpl(testData); RealMatrixImpl m2 = new RealMatrixImpl(testData2); assertEquals("testData Frobenius norm", Math.sqrt(117.0), m.getFrobeniusNorm(), entryTolerance); assertEquals("testData2 Frobenius norm", Math.sqrt(52.0), m2.getFrobeniusNorm(), entryTolerance); } /** test m-n = m + -n */ public void testPlusMinus() { RealMatrixImpl m = new RealMatrixImpl(testData); RealMatrixImpl m2 = new RealMatrixImpl(testDataInv); TestUtils.assertEquals("m-n = m + -n",m.subtract(m2), m2.scalarMultiply(-1d).add(m),entryTolerance); try { m.subtract(new RealMatrixImpl(testData2)); fail("Expecting illegalArgumentException"); } catch (IllegalArgumentException ex) { // ignored } } /** test multiply */ public void testMultiply() { RealMatrixImpl m = new RealMatrixImpl(testData); RealMatrixImpl mInv = new RealMatrixImpl(testDataInv); RealMatrixImpl identity = new RealMatrixImpl(id); RealMatrixImpl m2 = new RealMatrixImpl(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 RealMatrixImpl(bigSingular)); fail("Expecting illegalArgumentException"); } catch (IllegalArgumentException ex) { // ignored } } //Additional Test for RealMatrixImplTest.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}}; public void testMultiply2() { RealMatrix m3 = new RealMatrixImpl(d3); RealMatrix m4 = new RealMatrixImpl(d4); RealMatrix m5 = new RealMatrixImpl(d5); TestUtils.assertEquals("m3*m4=m5", m3.multiply(m4), m5, entryTolerance); } /** test trace */ public void testTrace() { RealMatrix m = new RealMatrixImpl(id); assertEquals("identity trace",3d,m.getTrace(),entryTolerance); m = new RealMatrixImpl(testData2); try { m.getTrace(); fail("Expecting NonSquareMatrixException"); } catch (NonSquareMatrixException ex) { // ignored } } /** test sclarAdd */ public void testScalarAdd() { RealMatrix m = new RealMatrixImpl(testData); TestUtils.assertEquals("scalar add",new RealMatrixImpl(testDataPlus2), m.scalarAdd(2d),entryTolerance); } /** test operate */ public void testOperate() { RealMatrix m = new RealMatrixImpl(id); TestUtils.assertEquals("identity operate", testVector, m.operate(testVector), entryTolerance); TestUtils.assertEquals("identity operate", testVector, m.operate(new ArrayRealVector(testVector)).getData(), entryTolerance); m = new RealMatrixImpl(bigSingular); try { m.operate(testVector); fail("Expecting illegalArgumentException"); } catch (IllegalArgumentException ex) { // ignored } } /** test issue MATH-209 */ public void testMath209() { RealMatrix a = new RealMatrixImpl(new double[][] { { 1, 2 }, { 3, 4 }, { 5, 6 } }, false); double[] b = a.operate(new double[] { 1, 1 }); assertEquals(a.getRowDimension(), b.length); assertEquals( 3.0, b[0], 1.0e-12); assertEquals( 7.0, b[1], 1.0e-12); assertEquals(11.0, b[2], 1.0e-12); } /** test transpose */ public void testTranspose() { RealMatrix m = new RealMatrixImpl(testData); RealMatrix mIT = new LUDecompositionImpl(m).getSolver().getInverse().transpose(); RealMatrix mTI = new LUDecompositionImpl(m.transpose()).getSolver().getInverse(); TestUtils.assertEquals("inverse-transpose", mIT, mTI, normTolerance); m = new RealMatrixImpl(testData2); RealMatrix mt = new RealMatrixImpl(testData2T); TestUtils.assertEquals("transpose",mt,m.transpose(),normTolerance); } /** test preMultiply by vector */ public void testPremultiplyVector() { RealMatrix m = new RealMatrixImpl(testData); TestUtils.assertEquals("premultiply", m.preMultiply(testVector), preMultTest, normTolerance); TestUtils.assertEquals("premultiply", m.preMultiply(new ArrayRealVector(testVector).getData()), preMultTest, normTolerance); m = new RealMatrixImpl(bigSingular); try { m.preMultiply(testVector); fail("expecting IllegalArgumentException"); } catch (IllegalArgumentException ex) { // ignored } } public void testPremultiply() { RealMatrix m3 = new RealMatrixImpl(d3); RealMatrix m4 = new RealMatrixImpl(d4); RealMatrix m5 = new RealMatrixImpl(d5); TestUtils.assertEquals("m3*m4=m5", m4.preMultiply(m3), m5, entryTolerance); RealMatrixImpl m = new RealMatrixImpl(testData); RealMatrixImpl mInv = new RealMatrixImpl(testDataInv); RealMatrixImpl identity = new RealMatrixImpl(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 RealMatrixImpl(bigSingular)); fail("Expecting illegalArgumentException"); } catch (IllegalArgumentException ex) { // ignored } } public void testGetVectors() { RealMatrix m = new RealMatrixImpl(testData); TestUtils.assertEquals("get row",m.getRow(0),testDataRow1,entryTolerance); TestUtils.assertEquals("get col",m.getColumn(2),testDataCol3,entryTolerance); try { m.getRow(10); fail("expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // ignored } try { m.getColumn(-1); fail("expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // ignored } } public void testGetEntry() { RealMatrix m = new RealMatrixImpl(testData); assertEquals("get entry",m.getEntry(0,1),2d,entryTolerance); try { m.getEntry(10, 4); fail ("Expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // expected } } /** test examples in user guide */ public void testExamples() { // Create a real matrix with two rows and three columns double[][] matrixData = { {1d,2d,3d}, {2d,5d,3d}}; RealMatrix m = new RealMatrixImpl(matrixData); // One more with three rows, two columns double[][] matrixData2 = { {1d,2d}, {2d,5d}, {1d, 7d}}; RealMatrix n = new RealMatrixImpl(matrixData2); // Now multiply m by n RealMatrix p = m.multiply(n); assertEquals(2, p.getRowDimension()); assertEquals(2, p.getColumnDimension()); // Invert p RealMatrix pInverse = new LUDecompositionImpl(p).getSolver().getInverse(); assertEquals(2, pInverse.getRowDimension()); assertEquals(2, pInverse.getColumnDimension()); // Solve example double[][] coefficientsData = {{2, 3, -2}, {-1, 7, 6}, {4, -3, -5}}; RealMatrix coefficients = new RealMatrixImpl(coefficientsData); double[] constants = {1, -2, 1}; double[] solution = new LUDecompositionImpl(coefficients).getSolver().solve(constants); assertEquals(2 * solution[0] + 3 * solution[1] -2 * solution[2], constants[0], 1E-12); assertEquals(-1 * solution[0] + 7 * solution[1] + 6 * solution[2], constants[1], 1E-12); assertEquals(4 * solution[0] - 3 * solution[1] -5 * solution[2], constants[2], 1E-12); } // test submatrix accessors public void testGetSubMatrix() { RealMatrix m = new RealMatrixImpl(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); assertEquals(new RealMatrixImpl(reference), sub); if (mustFail) { fail("Expecting MatrixIndexException"); } } catch (MatrixIndexException 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); assertEquals(new RealMatrixImpl(reference), sub); if (mustFail) { fail("Expecting MatrixIndexException"); } } catch (MatrixIndexException e) { if (!mustFail) { throw e; } } } public void testCopySubMatrix() { RealMatrix m = new RealMatrixImpl(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); } 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] : new double[reference.length][reference[0].length]; m.copySubMatrix(startRow, endRow, startColumn, endColumn, sub); assertEquals(new RealMatrixImpl(reference), new RealMatrixImpl(sub)); if (mustFail) { fail("Expecting MatrixIndexException"); } } catch (MatrixIndexException 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] : new double[reference.length][reference[0].length]; m.copySubMatrix(selectedRows, selectedColumns, sub); assertEquals(new RealMatrixImpl(reference), new RealMatrixImpl(sub)); if (mustFail) { fail("Expecting MatrixIndexException"); } } catch (MatrixIndexException e) { if (!mustFail) { throw e; } } } public void testGetRowMatrix() { RealMatrix m = new RealMatrixImpl(subTestData); RealMatrix mRow0 = new RealMatrixImpl(subRow0); RealMatrix mRow3 = new RealMatrixImpl(subRow3); assertEquals("Row0", mRow0, m.getRowMatrix(0)); assertEquals("Row3", mRow3, m.getRowMatrix(3)); try { m.getRowMatrix(-1); fail("Expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // expected } try { m.getRowMatrix(4); fail("Expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // expected } } public void testSetRowMatrix() { RealMatrix m = new RealMatrixImpl(subTestData); RealMatrix mRow3 = new RealMatrixImpl(subRow3); assertNotSame(mRow3, m.getRowMatrix(0)); m.setRowMatrix(0, mRow3); assertEquals(mRow3, m.getRowMatrix(0)); try { m.setRowMatrix(-1, mRow3); fail("Expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // expected } try { m.setRowMatrix(0, m); fail("Expecting InvalidMatrixException"); } catch (InvalidMatrixException ex) { // expected } } public void testGetColumnMatrix() { RealMatrix m = new RealMatrixImpl(subTestData); RealMatrix mColumn1 = new RealMatrixImpl(subColumn1); RealMatrix mColumn3 = new RealMatrixImpl(subColumn3); assertEquals("Column1", mColumn1, m.getColumnMatrix(1)); assertEquals("Column3", mColumn3, m.getColumnMatrix(3)); try { m.getColumnMatrix(-1); fail("Expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // expected } try { m.getColumnMatrix(4); fail("Expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // expected } } public void testSetColumnMatrix() { RealMatrix m = new RealMatrixImpl(subTestData); RealMatrix mColumn3 = new RealMatrixImpl(subColumn3); assertNotSame(mColumn3, m.getColumnMatrix(1)); m.setColumnMatrix(1, mColumn3); assertEquals(mColumn3, m.getColumnMatrix(1)); try { m.setColumnMatrix(-1, mColumn3); fail("Expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // expected } try { m.setColumnMatrix(0, m); fail("Expecting InvalidMatrixException"); } catch (InvalidMatrixException ex) { // expected } } public void testGetRowVector() { RealMatrix m = new RealMatrixImpl(subTestData); RealVector mRow0 = new ArrayRealVector(subRow0[0]); RealVector mRow3 = new ArrayRealVector(subRow3[0]); assertEquals("Row0", mRow0, m.getRowVector(0)); assertEquals("Row3", mRow3, m.getRowVector(3)); try { m.getRowVector(-1); fail("Expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // expected } try { m.getRowVector(4); fail("Expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // expected } } public void testSetRowVector() { RealMatrix m = new RealMatrixImpl(subTestData); RealVector mRow3 = new ArrayRealVector(subRow3[0]); assertNotSame(mRow3, m.getRowMatrix(0)); m.setRowVector(0, mRow3); assertEquals(mRow3, m.getRowVector(0)); try { m.setRowVector(-1, mRow3); fail("Expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // expected } try { m.setRowVector(0, new ArrayRealVector(5)); fail("Expecting InvalidMatrixException"); } catch (InvalidMatrixException ex) { // expected } } public void testGetColumnVector() { RealMatrix m = new RealMatrixImpl(subTestData); RealVector mColumn1 = columnToVector(subColumn1); RealVector mColumn3 = columnToVector(subColumn3); assertEquals("Column1", mColumn1, m.getColumnVector(1)); assertEquals("Column3", mColumn3, m.getColumnVector(3)); try { m.getColumnVector(-1); fail("Expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // expected } try { m.getColumnVector(4); fail("Expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // expected } } public void testSetColumnVector() { RealMatrix m = new RealMatrixImpl(subTestData); RealVector mColumn3 = columnToVector(subColumn3); assertNotSame(mColumn3, m.getColumnVector(1)); m.setColumnVector(1, mColumn3); assertEquals(mColumn3, m.getColumnVector(1)); try { m.setColumnVector(-1, mColumn3); fail("Expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // expected } try { m.setColumnVector(0, new ArrayRealVector(5)); fail("Expecting InvalidMatrixException"); } catch (InvalidMatrixException 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); } public void testGetRow() { RealMatrix m = new RealMatrixImpl(subTestData); checkArrays(subRow0[0], m.getRow(0)); checkArrays(subRow3[0], m.getRow(3)); try { m.getRow(-1); fail("Expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // expected } try { m.getRow(4); fail("Expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // expected } } public void testSetRow() { RealMatrix m = new RealMatrixImpl(subTestData); 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]); fail("Expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // expected } try { m.setRow(0, new double[5]); fail("Expecting InvalidMatrixException"); } catch (InvalidMatrixException ex) { // expected } } public void testGetColumn() { RealMatrix m = new RealMatrixImpl(subTestData); double[] mColumn1 = columnToArray(subColumn1); double[] mColumn3 = columnToArray(subColumn3); checkArrays(mColumn1, m.getColumn(1)); checkArrays(mColumn3, m.getColumn(3)); try { m.getColumn(-1); fail("Expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // expected } try { m.getColumn(4); fail("Expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // expected } } public void testSetColumn() { RealMatrix m = new RealMatrixImpl(subTestData); double[] mColumn3 = columnToArray(subColumn3); assertTrue(mColumn3[0] != m.getColumn(1)[0]); m.setColumn(1, mColumn3); checkArrays(mColumn3, m.getColumn(1)); try { m.setColumn(-1, mColumn3); fail("Expecting MatrixIndexException"); } catch (MatrixIndexException ex) { // expected } try { m.setColumn(0, new double[5]); fail("Expecting InvalidMatrixException"); } catch (InvalidMatrixException 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) { assertEquals(expected.length, actual.length); for (int i = 0; i < expected.length; ++i) { assertEquals(expected[i], actual[i]); } } public void testEqualsAndHashCode() { RealMatrixImpl m = new RealMatrixImpl(testData); RealMatrixImpl m1 = (RealMatrixImpl) m.copy(); RealMatrixImpl mt = (RealMatrixImpl) m.transpose(); assertTrue(m.hashCode() != mt.hashCode()); assertEquals(m.hashCode(), m1.hashCode()); assertEquals(m, m); assertEquals(m, m1); assertFalse(m.equals(null)); assertFalse(m.equals(mt)); assertFalse(m.equals(new RealMatrixImpl(bigSingular))); } public void testToString() { RealMatrixImpl m = new RealMatrixImpl(testData); assertEquals("RealMatrixImpl{{1.0,2.0,3.0},{2.0,5.0,3.0},{1.0,0.0,8.0}}", m.toString()); m = new RealMatrixImpl(); assertEquals("RealMatrixImpl{}", m.toString()); } public void testSetSubMatrix() throws Exception { RealMatrixImpl m = new RealMatrixImpl(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}}); 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}}); 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}}); assertEquals(expected, m); // dimension overflow try { m.setSubMatrix(testData,1,1); fail("expecting MatrixIndexException"); } catch (MatrixIndexException e) { // expected } // dimension underflow try { m.setSubMatrix(testData,-1,1); fail("expecting MatrixIndexException"); } catch (MatrixIndexException e) { // expected } try { m.setSubMatrix(testData,1,-1); fail("expecting MatrixIndexException"); } catch (MatrixIndexException e) { // expected } // null try { m.setSubMatrix(null,1,1); fail("expecting NullPointerException"); } catch (NullPointerException e) { // expected } RealMatrixImpl m2 = new RealMatrixImpl(); try { m2.setSubMatrix(testData,0,1); fail("expecting IllegalStateException"); } catch (IllegalStateException e) { // expected } try { m2.setSubMatrix(testData,1,0); fail("expecting IllegalStateException"); } catch (IllegalStateException e) { // expected } // ragged try { m.setSubMatrix(new double[][] {{1}, {2, 3}}, 0, 0); fail("expecting IllegalArgumentException"); } catch (IllegalArgumentException e) { // expected } // empty try { m.setSubMatrix(new double[][] {{}}, 0, 0); fail("expecting IllegalArgumentException"); } catch (IllegalArgumentException e) { // expected } } public void testWalk() { int rows = 150; int columns = 75; RealMatrix m = new RealMatrixImpl(rows, columns); m.walkInRowOrder(new SetVisitor()); GetVisitor getVisitor = new GetVisitor(); m.walkInOptimizedOrder(getVisitor); assertEquals(rows * columns, getVisitor.getCount()); m = new RealMatrixImpl(rows, columns); m.walkInRowOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2); getVisitor = new GetVisitor(); m.walkInOptimizedOrder(getVisitor, 1, rows - 2, 1, columns - 2); assertEquals((rows - 2) * (columns - 2), getVisitor.getCount()); for (int i = 0; i < rows; ++i) { assertEquals(0.0, m.getEntry(i, 0), 0); assertEquals(0.0, m.getEntry(i, columns - 1), 0); } for (int j = 0; j < columns; ++j) { assertEquals(0.0, m.getEntry(0, j), 0); assertEquals(0.0, m.getEntry(rows - 1, j), 0); } m = new RealMatrixImpl(rows, columns); m.walkInColumnOrder(new SetVisitor()); getVisitor = new GetVisitor(); m.walkInOptimizedOrder(getVisitor); assertEquals(rows * columns, getVisitor.getCount()); m = new RealMatrixImpl(rows, columns); m.walkInColumnOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2); getVisitor = new GetVisitor(); m.walkInOptimizedOrder(getVisitor, 1, rows - 2, 1, columns - 2); assertEquals((rows - 2) * (columns - 2), getVisitor.getCount()); for (int i = 0; i < rows; ++i) { assertEquals(0.0, m.getEntry(i, 0), 0); assertEquals(0.0, m.getEntry(i, columns - 1), 0); } for (int j = 0; j < columns; ++j) { assertEquals(0.0, m.getEntry(0, j), 0); assertEquals(0.0, m.getEntry(rows - 1, j), 0); } m = new RealMatrixImpl(rows, columns); m.walkInOptimizedOrder(new SetVisitor()); getVisitor = new GetVisitor(); m.walkInRowOrder(getVisitor); assertEquals(rows * columns, getVisitor.getCount()); m = new RealMatrixImpl(rows, columns); m.walkInOptimizedOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2); getVisitor = new GetVisitor(); m.walkInRowOrder(getVisitor, 1, rows - 2, 1, columns - 2); assertEquals((rows - 2) * (columns - 2), getVisitor.getCount()); for (int i = 0; i < rows; ++i) { assertEquals(0.0, m.getEntry(i, 0), 0); assertEquals(0.0, m.getEntry(i, columns - 1), 0); } for (int j = 0; j < columns; ++j) { assertEquals(0.0, m.getEntry(0, j), 0); assertEquals(0.0, m.getEntry(rows - 1, j), 0); } m = new RealMatrixImpl(rows, columns); m.walkInOptimizedOrder(new SetVisitor()); getVisitor = new GetVisitor(); m.walkInColumnOrder(getVisitor); assertEquals(rows * columns, getVisitor.getCount()); m = new RealMatrixImpl(rows, columns); m.walkInOptimizedOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2); getVisitor = new GetVisitor(); m.walkInColumnOrder(getVisitor, 1, rows - 2, 1, columns - 2); assertEquals((rows - 2) * (columns - 2), getVisitor.getCount()); for (int i = 0; i < rows; ++i) { assertEquals(0.0, m.getEntry(i, 0), 0); assertEquals(0.0, m.getEntry(i, columns - 1), 0); } for (int j = 0; j < columns; ++j) { assertEquals(0.0, m.getEntry(0, j), 0); assertEquals(0.0, m.getEntry(rows - 1, j), 0); } } public void testSerial() { RealMatrixImpl m = new RealMatrixImpl(testData); 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; 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) throws InvalidMatrixException { if (!lu.isSquare() || lowerData.length != lowerData[0].length || upperData.length != upperData[0].length || lowerData.length != upperData.length || lowerData.length != lu.getRowDimension()) { throw new InvalidMatrixException("incorrect dimensions"); } 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() || matrix.getRowDimension() != permutation.length) { throw new IllegalArgumentException("dimension mismatch"); } 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 RealMatrixImpl(out); } // /** Useful for debugging */ // private void dumpMatrix(RealMatrix m) { // for (int i = 0; i < m.getRowDimension(); i++) { // String os = ""; // for (int j = 0; j < m.getColumnDimension(); j++) { // os += m.getEntry(i, j) + " "; // } // System.out.println(os); // } // } } Other Commons Math examples (source code examples)Here is a short list of links related to this Commons Math RealMatrixImplTest.java source code file: |
... this post is sponsored by my books ... | |
#1 New Release! |
FP Best Seller |
Copyright 1998-2024 Alvin Alexander, alvinalexander.com
All Rights Reserved.
A percentage of advertising revenue from
pages under the /java/jwarehouse
URI on this website is
paid back to open source projects.