Return-Path: Delivered-To: apmail-commons-commits-archive@minotaur.apache.org Received: (qmail 30152 invoked from network); 5 Sep 2009 17:38:57 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (140.211.11.3) by minotaur.apache.org with SMTP; 5 Sep 2009 17:38:57 -0000 Received: (qmail 42552 invoked by uid 500); 5 Sep 2009 17:38:56 -0000 Delivered-To: apmail-commons-commits-archive@commons.apache.org Received: (qmail 42381 invoked by uid 500); 5 Sep 2009 17:38:55 -0000 Mailing-List: contact commits-help@commons.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@commons.apache.org Delivered-To: mailing list commits@commons.apache.org Received: (qmail 42221 invoked by uid 99); 5 Sep 2009 17:38:55 -0000 Received: from nike.apache.org (HELO nike.apache.org) (192.87.106.230) by apache.org (qpsmtpd/0.29) with ESMTP; Sat, 05 Sep 2009 17:38:55 +0000 X-ASF-Spam-Status: No, hits=-2000.0 required=10.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.4] (HELO eris.apache.org) (140.211.11.4) by apache.org (qpsmtpd/0.29) with ESMTP; Sat, 05 Sep 2009 17:38:44 +0000 Received: by eris.apache.org (Postfix, from userid 65534) id 9EFF223889D1; Sat, 5 Sep 2009 17:37:22 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r811685 [18/24] - in /commons/proper/math/trunk: ./ src/main/java/org/apache/commons/math/ src/main/java/org/apache/commons/math/analysis/ src/main/java/org/apache/commons/math/analysis/integration/ src/main/java/org/apache/commons/math/ana... Date: Sat, 05 Sep 2009 17:37:05 -0000 To: commits@commons.apache.org From: psteitz@apache.org X-Mailer: svnmailer-1.0.8 Message-Id: <20090905173722.9EFF223889D1@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/Array2DRowRealMatrixTest.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/Array2DRowRealMatrixTest.java?rev=811685&r1=811684&r2=811685&view=diff ============================================================================== --- commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/Array2DRowRealMatrixTest.java (original) +++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/Array2DRowRealMatrixTest.java Sat Sep 5 17:36:48 2009 @@ -5,9 +5,9 @@ * 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. @@ -29,45 +29,45 @@ */ public final class Array2DRowRealMatrixTest 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}, + 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 = + 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 = + 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}}; + {2, 4, 6, 8}, {4, 5, 6, 7}}; // array selections protected double[][] subRows02Cols13 = { {2, 4}, {4, 8}}; protected double[][] subRows03Cols12 = { {2, 3}, {5, 6}}; @@ -85,21 +85,21 @@ // 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 Array2DRowRealMatrixTest(String name) { super(name); } - + public static Test suite() { TestSuite suite = new TestSuite(Array2DRowRealMatrixTest.class); suite.setName("Array2DRowRealMatrix Tests"); return suite; } - + /** test dimensions */ public void testDimensions() { Array2DRowRealMatrix m = new Array2DRowRealMatrix(testData); @@ -110,8 +110,8 @@ 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() { Array2DRowRealMatrix m1 = new Array2DRowRealMatrix(testData); @@ -120,8 +120,8 @@ Array2DRowRealMatrix m3 = new Array2DRowRealMatrix(testData); Array2DRowRealMatrix m4 = new Array2DRowRealMatrix(m3.getData(), false); assertEquals(m4,m3); - } - + } + /** test add */ public void testAdd() { Array2DRowRealMatrix m = new Array2DRowRealMatrix(testData); @@ -134,9 +134,9 @@ testDataPlusInv[row][col],sumEntries[row][col], entryTolerance); } - } + } } - + /** test add failure */ public void testAddFail() { Array2DRowRealMatrix m = new Array2DRowRealMatrix(testData); @@ -148,7 +148,7 @@ // ignored } } - + /** test norm */ public void testNorm() { Array2DRowRealMatrix m = new Array2DRowRealMatrix(testData); @@ -156,7 +156,7 @@ assertEquals("testData norm",14d,m.getNorm(),entryTolerance); assertEquals("testData2 norm",7d,m2.getNorm(),entryTolerance); } - + /** test Frobenius norm */ public void testFrobeniusNorm() { Array2DRowRealMatrix m = new Array2DRowRealMatrix(testData); @@ -164,21 +164,21 @@ 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() { Array2DRowRealMatrix m = new Array2DRowRealMatrix(testData); Array2DRowRealMatrix m2 = new Array2DRowRealMatrix(testDataInv); TestUtils.assertEquals("m-n = m + -n",m.subtract(m2), - m2.scalarMultiply(-1d).add(m),entryTolerance); + m2.scalarMultiply(-1d).add(m),entryTolerance); try { m.subtract(new Array2DRowRealMatrix(testData2)); fail("Expecting illegalArgumentException"); } catch (IllegalArgumentException ex) { // ignored - } + } } - + /** test multiply */ public void testMultiply() { Array2DRowRealMatrix m = new Array2DRowRealMatrix(testData); @@ -194,28 +194,28 @@ TestUtils.assertEquals("identity multiply",identity.multiply(mInv), mInv,entryTolerance); TestUtils.assertEquals("identity multiply",m2.multiply(identity), - m2,entryTolerance); + m2,entryTolerance); try { m.multiply(new Array2DRowRealMatrix(bigSingular)); fail("Expecting illegalArgumentException"); } catch (IllegalArgumentException ex) { // ignored - } - } - + } + } + //Additional Test for Array2DRowRealMatrixTest.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 Array2DRowRealMatrix(d3); + + public void testMultiply2() { + RealMatrix m3 = new Array2DRowRealMatrix(d3); RealMatrix m4 = new Array2DRowRealMatrix(d4); RealMatrix m5 = new Array2DRowRealMatrix(d5); TestUtils.assertEquals("m3*m4=m5", m3.multiply(m4), m5, entryTolerance); - } - + } + /** test trace */ public void testTrace() { RealMatrix m = new Array2DRowRealMatrix(id); @@ -226,16 +226,16 @@ fail("Expecting NonSquareMatrixException"); } catch (NonSquareMatrixException ex) { // ignored - } + } } - + /** test sclarAdd */ public void testScalarAdd() { RealMatrix m = new Array2DRowRealMatrix(testData); TestUtils.assertEquals("scalar add",new Array2DRowRealMatrix(testDataPlus2), m.scalarAdd(2d),entryTolerance); } - + /** test operate */ public void testOperate() { RealMatrix m = new Array2DRowRealMatrix(id); @@ -249,7 +249,7 @@ fail("Expecting illegalArgumentException"); } catch (IllegalArgumentException ex) { // ignored - } + } } /** test issue MATH-209 */ @@ -263,10 +263,10 @@ assertEquals( 7.0, b[1], 1.0e-12); assertEquals(11.0, b[2], 1.0e-12); } - + /** test transpose */ public void testTranspose() { - RealMatrix m = new Array2DRowRealMatrix(testData); + RealMatrix m = new Array2DRowRealMatrix(testData); RealMatrix mIT = new LUDecompositionImpl(m).getSolver().getInverse().transpose(); RealMatrix mTI = new LUDecompositionImpl(m.transpose()).getSolver().getInverse(); TestUtils.assertEquals("inverse-transpose", mIT, mTI, normTolerance); @@ -274,7 +274,7 @@ RealMatrix mt = new Array2DRowRealMatrix(testData2T); TestUtils.assertEquals("transpose",mt,m.transpose(),normTolerance); } - + /** test preMultiply by vector */ public void testPremultiplyVector() { RealMatrix m = new Array2DRowRealMatrix(testData); @@ -290,13 +290,13 @@ // ignored } } - + public void testPremultiply() { - RealMatrix m3 = new Array2DRowRealMatrix(d3); + RealMatrix m3 = new Array2DRowRealMatrix(d3); RealMatrix m4 = new Array2DRowRealMatrix(d4); RealMatrix m5 = new Array2DRowRealMatrix(d5); TestUtils.assertEquals("m3*m4=m5", m4.preMultiply(m3), m5, entryTolerance); - + Array2DRowRealMatrix m = new Array2DRowRealMatrix(testData); Array2DRowRealMatrix mInv = new Array2DRowRealMatrix(testDataInv); Array2DRowRealMatrix identity = new Array2DRowRealMatrix(id); @@ -313,9 +313,9 @@ fail("Expecting illegalArgumentException"); } catch (IllegalArgumentException ex) { // ignored - } + } } - + public void testGetVectors() { RealMatrix m = new Array2DRowRealMatrix(testData); TestUtils.assertEquals("get row",m.getRow(0),testDataRow1,entryTolerance); @@ -333,7 +333,7 @@ // ignored } } - + public void testGetEntry() { RealMatrix m = new Array2DRowRealMatrix(testData); assertEquals("get entry",m.getEntry(0,1),2d,entryTolerance); @@ -344,7 +344,7 @@ // expected } } - + /** test examples in user guide */ public void testExamples() { // Create a real matrix with two rows and three columns @@ -358,10 +358,10 @@ assertEquals(2, p.getRowDimension()); assertEquals(2, p.getColumnDimension()); // Invert p - RealMatrix pInverse = new LUDecompositionImpl(p).getSolver().getInverse(); + 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 Array2DRowRealMatrix(coefficientsData); @@ -369,22 +369,22 @@ 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); - + assertEquals(4 * solution[0] - 3 * solution[1] -5 * solution[2], constants[2], 1E-12); + } - + // test submatrix accessors public void testGetSubMatrix() { RealMatrix m = new Array2DRowRealMatrix(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, 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); @@ -408,7 +408,7 @@ } } } - + private void checkGetSubMatrix(RealMatrix m, double[][] reference, int[] selectedRows, int[] selectedColumns, boolean mustFail) { @@ -429,14 +429,14 @@ RealMatrix m = new Array2DRowRealMatrix(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, 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); @@ -463,7 +463,7 @@ } } } - + private void checkCopy(RealMatrix m, double[][] reference, int[] selectedRows, int[] selectedColumns, boolean mustFail) { @@ -487,9 +487,9 @@ RealMatrix m = new Array2DRowRealMatrix(subTestData); RealMatrix mRow0 = new Array2DRowRealMatrix(subRow0); RealMatrix mRow3 = new Array2DRowRealMatrix(subRow3); - assertEquals("Row0", mRow0, + assertEquals("Row0", mRow0, m.getRowMatrix(0)); - assertEquals("Row3", mRow3, + assertEquals("Row3", mRow3, m.getRowMatrix(3)); try { m.getRowMatrix(-1); @@ -504,7 +504,7 @@ // expected } } - + public void testSetRowMatrix() { RealMatrix m = new Array2DRowRealMatrix(subTestData); RealMatrix mRow3 = new Array2DRowRealMatrix(subRow3); @@ -524,14 +524,14 @@ // expected } } - + public void testGetColumnMatrix() { RealMatrix m = new Array2DRowRealMatrix(subTestData); RealMatrix mColumn1 = new Array2DRowRealMatrix(subColumn1); RealMatrix mColumn3 = new Array2DRowRealMatrix(subColumn3); - assertEquals("Column1", mColumn1, + assertEquals("Column1", mColumn1, m.getColumnMatrix(1)); - assertEquals("Column3", mColumn3, + assertEquals("Column3", mColumn3, m.getColumnMatrix(3)); try { m.getColumnMatrix(-1); @@ -606,7 +606,7 @@ // expected } } - + public void testGetColumnVector() { RealMatrix m = new Array2DRowRealMatrix(subTestData); RealVector mColumn1 = columnToVector(subColumn1); @@ -691,7 +691,7 @@ // expected } } - + public void testGetColumn() { RealMatrix m = new Array2DRowRealMatrix(subTestData); double[] mColumn1 = columnToArray(subColumn1); @@ -743,10 +743,10 @@ 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]); + assertEquals(expected[i], actual[i]); } } - + public void testEqualsAndHashCode() { Array2DRowRealMatrix m = new Array2DRowRealMatrix(testData); Array2DRowRealMatrix m1 = (Array2DRowRealMatrix) m.copy(); @@ -757,9 +757,9 @@ assertEquals(m, m1); assertFalse(m.equals(null)); assertFalse(m.equals(mt)); - assertFalse(m.equals(new Array2DRowRealMatrix(bigSingular))); + assertFalse(m.equals(new Array2DRowRealMatrix(bigSingular))); } - + public void testToString() { Array2DRowRealMatrix m = new Array2DRowRealMatrix(testData); assertEquals("Array2DRowRealMatrix{{1.0,2.0,3.0},{2.0,5.0,3.0},{1.0,0.0,8.0}}", @@ -768,45 +768,45 @@ assertEquals("Array2DRowRealMatrix{}", m.toString()); } - + public void testSetSubMatrix() throws Exception { Array2DRowRealMatrix m = new Array2DRowRealMatrix(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); - + 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); + 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); - + assertEquals(expected, m); + // dimension overflow - try { + try { m.setSubMatrix(testData,1,1); fail("expecting MatrixIndexException"); } catch (MatrixIndexException e) { // expected } // dimension underflow - try { + try { m.setSubMatrix(testData,-1,1); fail("expecting MatrixIndexException"); } catch (MatrixIndexException e) { // expected } - try { + try { m.setSubMatrix(testData,1,-1); fail("expecting MatrixIndexException"); } catch (MatrixIndexException e) { // expected } - + // null try { m.setSubMatrix(null,1,1); @@ -827,7 +827,7 @@ } catch (IllegalStateException e) { // expected } - + // ragged try { m.setSubMatrix(new double[][] {{1}, {2, 3}}, 0, 0); @@ -835,7 +835,7 @@ } catch (IllegalArgumentException e) { // expected } - + // empty try { m.setSubMatrix(new double[][] {{}}, 0, 0); @@ -843,7 +843,7 @@ } catch (IllegalArgumentException e) { // expected } - + } public void testWalk() { @@ -862,11 +862,11 @@ 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, 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(0, j), 0); assertEquals(0.0, m.getEntry(rows - 1, j), 0); } @@ -882,11 +882,11 @@ 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, 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(0, j), 0); assertEquals(0.0, m.getEntry(rows - 1, j), 0); } @@ -902,11 +902,11 @@ 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, 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(0, j), 0); assertEquals(0.0, m.getEntry(rows - 1, j), 0); } @@ -922,11 +922,11 @@ 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, 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(0, j), 0); assertEquals(0.0, m.getEntry(rows - 1, j), 0); } @@ -936,8 +936,8 @@ Array2DRowRealMatrix m = new Array2DRowRealMatrix(testData); assertEquals(m,TestUtils.serializeAndRecover(m)); } - - + + private static class SetVisitor extends DefaultRealMatrixChangingVisitor { @Override public double visit(int i, int j, double value) { @@ -958,14 +958,14 @@ } //--------------- -----------------Protected methods - + /** extracts the l and u matrices from compact lu representation */ - protected void splitLU(RealMatrix lu, double[][] lowerData, double[][] upperData) throws InvalidMatrixException { + 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++) { @@ -978,11 +978,11 @@ } 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) { @@ -998,7 +998,7 @@ } return new Array2DRowRealMatrix(out); } - + // /** Useful for debugging */ // private void dumpMatrix(RealMatrix m) { // for (int i = 0; i < m.getRowDimension(); i++) { @@ -1009,6 +1009,6 @@ // System.out.println(os); // } // } - + } Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/ArrayFieldVectorTest.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/ArrayFieldVectorTest.java?rev=811685&r1=811684&r2=811685&view=diff ============================================================================== --- commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/ArrayFieldVectorTest.java (original) +++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/ArrayFieldVectorTest.java Sat Sep 5 17:36:48 2009 @@ -5,9 +5,9 @@ * 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. @@ -36,7 +36,7 @@ */ public class ArrayFieldVectorTest extends TestCase { - // + // protected Fraction[][] ma1 = { {new Fraction(1), new Fraction(2), new Fraction(3)}, {new Fraction(4), new Fraction(5), new Fraction(6)}, @@ -58,7 +58,7 @@ {new Fraction(7), new Fraction(8), new Fraction(9)} }; - // Testclass to test the FieldVector interface + // Testclass to test the FieldVector interface // only with enough content to support the test public static class FieldVectorTestImpl> implements FieldVector, Serializable { @@ -340,7 +340,7 @@ ArrayFieldVector v1 = new ArrayFieldVector(vec1); ArrayFieldVector v2 = new ArrayFieldVector(vec2); ArrayFieldVector v4 = new ArrayFieldVector(vec4); - FieldVectorTestImpl v2_t = new FieldVectorTestImpl(vec2); + FieldVectorTestImpl v2_t = new FieldVectorTestImpl(vec2); FieldVector v_append_1 = v1.append(v2); assertEquals(6, v_append_1.getDimension()); @@ -436,7 +436,7 @@ } - ArrayFieldVector vout10 = (ArrayFieldVector) v1.copy(); + ArrayFieldVector vout10 = (ArrayFieldVector) v1.copy(); ArrayFieldVector vout10_2 = (ArrayFieldVector) v1.copy(); assertEquals(vout10, vout10_2); vout10_2.setEntry(0, new Fraction(11, 10)); @@ -444,7 +444,7 @@ } - public void testMapFunctions() { + public void testMapFunctions() { ArrayFieldVector v1 = new ArrayFieldVector(vec1); //octave = v1 .+ 2.0 @@ -504,12 +504,12 @@ } - public void testBasicFunctions() { + public void testBasicFunctions() { ArrayFieldVector v1 = new ArrayFieldVector(vec1); ArrayFieldVector v2 = new ArrayFieldVector(vec2); new ArrayFieldVector(vec_null); - FieldVectorTestImpl v2_t = new FieldVectorTestImpl(vec2); + FieldVectorTestImpl v2_t = new FieldVectorTestImpl(vec2); //octave = v1 + v2 ArrayFieldVector v_add = v1.add(v2); @@ -570,46 +570,46 @@ Fraction[] result_projection_2 = {new Fraction(128, 77), new Fraction(160, 77), new Fraction(192, 77)}; checkArray("compare vect", v_projection_2.getData(), result_projection_2); - } + } - public void testMisc() { + public void testMisc() { ArrayFieldVector v1 = new ArrayFieldVector(vec1); ArrayFieldVector v4 = new ArrayFieldVector(vec4); FieldVector v4_2 = new ArrayFieldVector(vec4); String out1 = v1.toString(); assertTrue("some output ", out1.length()!=0); - /* + /* Fraction[] dout1 = v1.copyOut(); assertEquals(3, dout1.length); - assertNotSame("testData not same object ", v1.data, dout1); - */ + assertNotSame("testData not same object ", v1.data, dout1); + */ try { - v1.checkVectorDimensions(2); + v1.checkVectorDimensions(2); fail("IllegalArgumentException expected"); } catch (IllegalArgumentException ex) { // expected behavior } catch (Exception e) { fail("wrong exception caught"); - } + } try { - v1.checkVectorDimensions(v4); + v1.checkVectorDimensions(v4); fail("IllegalArgumentException expected"); } catch (IllegalArgumentException ex) { // expected behavior } catch (Exception e) { fail("wrong exception caught"); - } + } try { - v1.checkVectorDimensions(v4_2); + v1.checkVectorDimensions(v4_2); fail("IllegalArgumentException expected"); } catch (IllegalArgumentException ex) { // expected behavior } catch (Exception e) { fail("wrong exception caught"); - } + } } @@ -617,7 +617,7 @@ ArrayFieldVector v = new ArrayFieldVector(vec1); assertEquals(v,TestUtils.serializeAndRecover(v)); } - + /** verifies that two vectors are equals */ protected void checkArray(String msg, Fraction[] m, Fraction[] n) { if (m.length != n.length) { 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=811685&r1=811684&r2=811685&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 Sat Sep 5 17:36:48 2009 @@ -5,9 +5,9 @@ * 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. @@ -31,7 +31,7 @@ */ public class ArrayRealVectorTest extends TestCase { - // + // protected double[][] ma1 = {{1d, 2d, 3d}, {4d, 5d, 6d}, {7d, 8d, 9d}}; protected double[] vec1 = {1d, 2d, 3d}; protected double[] vec2 = {4d, 5d, 6d}; @@ -45,7 +45,7 @@ protected double entryTolerance = 10E-16; protected double normTolerance = 10E-14; - // Testclass to test the RealVector interface + // Testclass to test the RealVector interface // only with enough content to support the test public static class RealVectorTestImpl implements RealVector, Serializable { @@ -547,7 +547,7 @@ ArrayRealVector v1 = new ArrayRealVector(vec1); ArrayRealVector v2 = new ArrayRealVector(vec2); ArrayRealVector v4 = new ArrayRealVector(vec4); - RealVectorTestImpl v2_t = new RealVectorTestImpl(vec2); + RealVectorTestImpl v2_t = new RealVectorTestImpl(vec2); RealVector v_append_1 = v1.append(v2); assertEquals("testData len", 6, v_append_1.getDimension()); @@ -643,7 +643,7 @@ } - ArrayRealVector vout10 = (ArrayRealVector) v1.copy(); + ArrayRealVector vout10 = (ArrayRealVector) v1.copy(); ArrayRealVector vout10_2 = (ArrayRealVector) v1.copy(); assertEquals(vout10, vout10_2); vout10_2.setEntry(0, 1.1); @@ -651,7 +651,7 @@ } - public void testMapFunctions() { + public void testMapFunctions() { ArrayRealVector v1 = new ArrayRealVector(vec1); //octave = v1 .+ 2.0 @@ -852,7 +852,7 @@ //octave = asin(vat) RealVector v_mapAsinToSelf = vat.copy(); - v_mapAsinToSelf.mapAsinToSelf(); + v_mapAsinToSelf.mapAsinToSelf(); double[] result_mapAsinToSelf = {0.0d,5.235987755982989e-01d,1.570796326794897e+00d}; assertClose("compare vectors" ,result_mapAsinToSelf,v_mapAsinToSelf.getData(),normTolerance); @@ -979,12 +979,12 @@ } - public void testBasicFunctions() { + public void testBasicFunctions() { ArrayRealVector v1 = new ArrayRealVector(vec1); ArrayRealVector v2 = new ArrayRealVector(vec2); ArrayRealVector v_null = new ArrayRealVector(vec_null); - RealVectorTestImpl v2_t = new RealVectorTestImpl(vec2); + RealVectorTestImpl v2_t = new RealVectorTestImpl(vec2); //octave = sqrt(sumsq(v1)) double d_getNorm = v1.getNorm(); @@ -1070,7 +1070,7 @@ assertEquals("compare val ",4d, m_outerProduct_2.getEntry(0,0)); RealVector v_unitVector = v1.unitVector(); - RealVector v_unitVector_2 = v1.mapDivide(v1.getNorm()); + RealVector v_unitVector_2 = v1.mapDivide(v1.getNorm()); assertClose("compare vect" ,v_unitVector.getData(),v_unitVector_2.getData(),normTolerance); try { @@ -1102,46 +1102,46 @@ double[] result_projection_2 = {1.662337662337662, 2.0779220779220777, 2.493506493506493}; assertClose("compare vect", v_projection_2.getData(), result_projection_2, normTolerance); - } + } - public void testMisc() { + 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); - /* + /* double[] dout1 = v1.copyOut(); assertEquals("testData len", 3, dout1.length); - assertNotSame("testData not same object ", v1.data, dout1); - */ + assertNotSame("testData not same object ", v1.data, dout1); + */ try { - v1.checkVectorDimensions(2); + v1.checkVectorDimensions(2); fail("IllegalArgumentException expected"); } catch (IllegalArgumentException ex) { // expected behavior } catch (Exception e) { fail("wrong exception caught"); - } + } try { - v1.checkVectorDimensions(v4); + v1.checkVectorDimensions(v4); fail("IllegalArgumentException expected"); } catch (IllegalArgumentException ex) { // expected behavior } catch (Exception e) { fail("wrong exception caught"); - } + } try { - v1.checkVectorDimensions(v4_2); + v1.checkVectorDimensions(v4_2); fail("IllegalArgumentException expected"); } catch (IllegalArgumentException ex) { // expected behavior } catch (Exception e) { fail("wrong exception caught"); - } + } } @@ -1176,8 +1176,8 @@ ArrayRealVector v = new ArrayRealVector(new double[] { 0, 1, 2 }); assertEquals(v,TestUtils.serializeAndRecover(v)); } - - + + /** verifies that two vectors are close (sup norm) */ protected void assertClose(String msg, double[] m, double[] n, double tolerance) { Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/BiDiagonalTransformerTest.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/BiDiagonalTransformerTest.java?rev=811685&r1=811684&r2=811685&view=diff ============================================================================== --- commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/BiDiagonalTransformerTest.java (original) +++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/BiDiagonalTransformerTest.java Sat Sep 5 17:36:48 2009 @@ -92,7 +92,7 @@ private void checkOrthogonal(RealMatrix m) { RealMatrix mTm = m.transpose().multiply(m); RealMatrix id = MatrixUtils.createRealIdentityMatrix(mTm.getRowDimension()); - assertEquals(0, mTm.subtract(id).getNorm(), 1.0e-14); + assertEquals(0, mTm.subtract(id).getNorm(), 1.0e-14); } public void testBBiDiagonal() { @@ -109,7 +109,7 @@ if (rows < cols) { if ((i < j) || (i > j + 1)) { assertEquals(0, m.getEntry(i, j), 1.0e-16); - } + } } else { if ((i < j - 1) || (i > j)) { assertEquals(0, m.getEntry(i, j), 1.0e-16); @@ -148,7 +148,7 @@ assertTrue(u == transformer.getU()); assertTrue(b == transformer.getB()); assertTrue(v == transformer.getV()); - + } public void testUpperOrLower() { Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/BigMatrixImplTest.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/BigMatrixImplTest.java?rev=811685&r1=811684&r2=811685&view=diff ============================================================================== --- commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/BigMatrixImplTest.java (original) +++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/BigMatrixImplTest.java Sat Sep 5 17:36:48 2009 @@ -5,9 +5,9 @@ * 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. @@ -30,48 +30,48 @@ */ @Deprecated public final class BigMatrixImplTest extends TestCase { - + // Test data for String constructors protected String[][] testDataString = { {"1","2","3"}, {"2","5","3"}, {"1","0","8"} }; - + // 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}, + 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 = + 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 = + 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}}; + {2, 4, 6, 8}, {4, 5, 6, 7}}; // array selections protected double[][] subRows02Cols13 = { {2, 4}, {4, 8}}; protected double[][] subRows03Cols12 = { {2, 3}, {5, 6}}; @@ -89,15 +89,15 @@ // 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 BigMatrixImplTest(String name) { super(name); } - + public static Test suite() { TestSuite suite = new TestSuite(BigMatrixImplTest.class); suite.setName("BigMatrixImpl Tests"); @@ -149,8 +149,8 @@ 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() { BigMatrixImpl m1 = new BigMatrixImpl(testData); @@ -160,7 +160,7 @@ BigMatrixImpl m4 = new BigMatrixImpl(m3.getData(), false); assertEquals(m4,m3); } - + /** test constructors */ public void testConstructors() { BigMatrix m1 = new BigMatrixImpl(testData); @@ -211,7 +211,7 @@ // expected } } - + /** test add */ public void testAdd() { BigMatrixImpl m = new BigMatrixImpl(testData); @@ -224,9 +224,9 @@ testDataPlusInv[row][col],sumEntries[row][col], entryTolerance); } - } + } } - + /** test add failure */ public void testAddFail() { BigMatrixImpl m = new BigMatrixImpl(testData); @@ -238,7 +238,7 @@ // ignored } } - + /** test norm */ public void testNorm() { BigMatrixImpl m = new BigMatrixImpl(testData); @@ -246,7 +246,7 @@ assertEquals("testData norm",14d,m.getNorm().doubleValue(),entryTolerance); assertEquals("testData2 norm",7d,m2.getNorm().doubleValue(),entryTolerance); } - + /** test m-n = m + -n */ public void testPlusMinus() { BigMatrixImpl m = new BigMatrixImpl(testData); @@ -258,9 +258,9 @@ fail("Expecting illegalArgumentException"); } catch (IllegalArgumentException ex) { // ignored - } + } } - + /** test multiply */ public void testMultiply() { BigMatrixImpl m = new BigMatrixImpl(testData); @@ -276,28 +276,28 @@ assertClose("identity multiply",identity.multiply(mInv), mInv,entryTolerance); assertClose("identity multiply",m2.multiply(identity), - m2,entryTolerance); + m2,entryTolerance); try { m.multiply(new BigMatrixImpl(bigSingular)); fail("Expecting illegalArgumentException"); } catch (IllegalArgumentException ex) { // ignored - } - } - + } + } + //Additional Test for BigMatrixImplTest.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() { + + public void testMultiply2() { BigMatrix m3 = new BigMatrixImpl(d3); BigMatrix m4 = new BigMatrixImpl(d4); BigMatrix m5 = new BigMatrixImpl(d5); assertClose("m3*m4=m5", m3.multiply(m4), m5, entryTolerance); - } - + } + /** test isSingular */ public void testIsSingular() { BigMatrixImpl m = new BigMatrixImpl(singular); @@ -309,14 +309,14 @@ m = new BigMatrixImpl(testData); assertTrue("testData nonsingular",!m.isSingular()); } - + /** test inverse */ public void testInverse() { BigMatrixImpl m = new BigMatrixImpl(testData); BigMatrix mInv = new BigMatrixImpl(testDataInv); assertClose("inverse",mInv,m.inverse(),normTolerance); assertClose("inverse^2",m,m.inverse().inverse(),10E-12); - + // Not square m = new BigMatrixImpl(testData2); try { @@ -325,7 +325,7 @@ } catch (InvalidMatrixException ex) { // expected } - + // Singular m = new BigMatrixImpl(singular); try { @@ -335,7 +335,7 @@ // expected } } - + /** test solve */ public void testSolve() { BigMatrixImpl m = new BigMatrixImpl(testData); @@ -350,7 +350,7 @@ fail("expecting IllegalArgumentException"); } catch (IllegalArgumentException ex) { // ignored - } + } BigMatrix bs = new BigMatrixImpl(bigSingular); try { bs.solve(bs); @@ -369,22 +369,22 @@ fail("Expecting illegalArgumentException"); } catch (IllegalArgumentException ex) { // ignored - } + } try { (new BigMatrixImpl(testData2)).luDecompose(); fail("Expecting InvalidMatrixException"); } catch (InvalidMatrixException ex) { // ignored - } + } } - + /** test determinant */ - public void testDeterminant() { + public void testDeterminant() { BigMatrix m = new BigMatrixImpl(bigSingular); assertEquals("singular determinant",0,m.getDeterminant().doubleValue(),0); m = new BigMatrixImpl(detData); assertEquals("nonsingular test",-3d,m.getDeterminant().doubleValue(),normTolerance); - + // Examples verified against R (version 1.8.1, Red Hat Linux 9) m = new BigMatrixImpl(detData2); assertEquals("nonsingular R test 1",-2d,m.getDeterminant().doubleValue(),normTolerance); @@ -396,9 +396,9 @@ fail("Expecting InvalidMatrixException, got " + d); } catch (InvalidMatrixException ex) { // ignored - } + } } - + /** test trace */ public void testTrace() { BigMatrix m = new BigMatrixImpl(id); @@ -409,16 +409,16 @@ fail("Expecting NonSquareMatrixException, got " + t); } catch (NonSquareMatrixException ex) { // ignored - } + } } - + /** test sclarAdd */ public void testScalarAdd() { BigMatrix m = new BigMatrixImpl(testData); assertClose("scalar add",new BigMatrixImpl(testDataPlus2), m.scalarAdd(new BigDecimal(2d)),entryTolerance); } - + /** test operate */ public void testOperate() { BigMatrix m = new BigMatrixImpl(id); @@ -430,7 +430,7 @@ fail("Expecting illegalArgumentException"); } catch (IllegalArgumentException ex) { // ignored - } + } } /** test issue MATH-209 */ @@ -446,7 +446,7 @@ assertEquals( 7.0, b[1].doubleValue(), 1.0e-12); assertEquals(11.0, b[2].doubleValue(), 1.0e-12); } - + /** test transpose */ public void testTranspose() { BigMatrix m = new BigMatrixImpl(testData); @@ -456,7 +456,7 @@ BigMatrix mt = new BigMatrixImpl(testData2T); assertClose("transpose",mt,m.transpose(),normTolerance); } - + /** test preMultiply by vector */ public void testPremultiplyVector() { BigMatrix m = new BigMatrixImpl(testData); @@ -469,13 +469,13 @@ // ignored } } - + public void testPremultiply() { BigMatrix m3 = new BigMatrixImpl(d3); BigMatrix m4 = new BigMatrixImpl(d4); BigMatrix m5 = new BigMatrixImpl(d5); assertClose("m3*m4=m5", m4.preMultiply(m3), m5, entryTolerance); - + BigMatrixImpl m = new BigMatrixImpl(testData); BigMatrixImpl mInv = new BigMatrixImpl(testDataInv); BigMatrixImpl identity = new BigMatrixImpl(id); @@ -493,9 +493,9 @@ fail("Expecting illegalArgumentException"); } catch (IllegalArgumentException ex) { // ignored - } + } } - + public void testGetVectors() { BigMatrix m = new BigMatrixImpl(testData); assertClose("get row",m.getRowAsDoubleArray(0),testDataRow1,entryTolerance); @@ -513,7 +513,7 @@ // ignored } } - + public void testLUDecomposition() throws Exception { BigMatrixImpl m = new BigMatrixImpl(testData); BigMatrix lu = m.getLUMatrix(); @@ -544,7 +544,7 @@ // expected } } - + /** * test submatrix accessors */ @@ -558,25 +558,25 @@ BigMatrix mRows03Cols123 = new BigMatrixImpl(subRows03Cols123); BigMatrix mRows20Cols123 = new BigMatrixImpl(subRows20Cols123); BigMatrix mRows31Cols31 = new BigMatrixImpl(subRows31Cols31); - assertEquals("Rows23Cols00", mRows23Cols00, + assertEquals("Rows23Cols00", mRows23Cols00, m.getSubMatrix(2 , 3 , 0, 0)); - assertEquals("Rows00Cols33", mRows00Cols33, + assertEquals("Rows00Cols33", mRows00Cols33, m.getSubMatrix(0 , 0 , 3, 3)); assertEquals("Rows01Cols23", mRows01Cols23, - m.getSubMatrix(0 , 1 , 2, 3)); + m.getSubMatrix(0 , 1 , 2, 3)); assertEquals("Rows02Cols13", mRows02Cols13, - m.getSubMatrix(new int[] {0,2}, new int[] {1,3})); + m.getSubMatrix(new int[] {0,2}, new int[] {1,3})); assertEquals("Rows03Cols12", mRows03Cols12, - m.getSubMatrix(new int[] {0,3}, new int[] {1,2})); + m.getSubMatrix(new int[] {0,3}, new int[] {1,2})); assertEquals("Rows03Cols123", mRows03Cols123, - m.getSubMatrix(new int[] {0,3}, new int[] {1,2,3})); + m.getSubMatrix(new int[] {0,3}, new int[] {1,2,3})); assertEquals("Rows20Cols123", mRows20Cols123, - m.getSubMatrix(new int[] {2,0}, new int[] {1,2,3})); + m.getSubMatrix(new int[] {2,0}, new int[] {1,2,3})); assertEquals("Rows31Cols31", mRows31Cols31, - m.getSubMatrix(new int[] {3,1}, new int[] {3,1})); + m.getSubMatrix(new int[] {3,1}, new int[] {3,1})); assertEquals("Rows31Cols31", mRows31Cols31, - m.getSubMatrix(new int[] {3,1}, new int[] {3,1})); - + m.getSubMatrix(new int[] {3,1}, new int[] {3,1})); + try { m.getSubMatrix(1,0,2,4); fail("Expecting MatrixIndexException"); @@ -614,14 +614,14 @@ // expected } } - + public void testGetColumnMatrix() { BigMatrix m = new BigMatrixImpl(subTestData); BigMatrix mColumn1 = new BigMatrixImpl(subColumn1); BigMatrix mColumn3 = new BigMatrixImpl(subColumn3); - assertEquals("Column1", mColumn1, + assertEquals("Column1", mColumn1, m.getColumnMatrix(1)); - assertEquals("Column3", mColumn3, + assertEquals("Column3", mColumn3, m.getColumnMatrix(3)); try { m.getColumnMatrix(-1); @@ -636,14 +636,14 @@ // expected } } - + public void testGetRowMatrix() { BigMatrix m = new BigMatrixImpl(subTestData); BigMatrix mRow0 = new BigMatrixImpl(subRow0); BigMatrix mRow3 = new BigMatrixImpl(subRow3); - assertEquals("Row0", mRow0, + assertEquals("Row0", mRow0, m.getRowMatrix(0)); - assertEquals("Row3", mRow3, + assertEquals("Row3", mRow3, m.getRowMatrix(3)); try { m.getRowMatrix(-1); @@ -658,7 +658,7 @@ // expected } } - + public void testEqualsAndHashCode() { BigMatrixImpl m = new BigMatrixImpl(testData); BigMatrixImpl m1 = (BigMatrixImpl) m.copy(); @@ -676,7 +676,7 @@ assertTrue(m.hashCode() != m1.hashCode()); assertFalse(m.equals(m1)); } - + public void testToString() { BigMatrixImpl m = new BigMatrixImpl(testData); assertEquals("BigMatrixImpl{{1,2,3},{2,5,3},{1,0,8}}", @@ -685,28 +685,28 @@ assertEquals("BigMatrixImpl{}", m.toString()); } - + public void testSetSubMatrix() throws Exception { - BigDecimal[][] detData3 = + BigDecimal[][] detData3 = MatrixUtils.createBigMatrix(detData2).getData(); BigMatrixImpl m = new BigMatrixImpl(testData); m.setSubMatrix(detData3,1,1); BigMatrix expected = MatrixUtils.createBigMatrix (new double[][] {{1.0,2.0,3.0},{2.0,1.0,3.0},{1.0,2.0,4.0}}); - assertEquals(expected, m); - + assertEquals(expected, m); + m.setSubMatrix(detData3,0,0); expected = MatrixUtils.createBigMatrix (new double[][] {{1.0,3.0,3.0},{2.0,4.0,3.0},{1.0,2.0,4.0}}); - assertEquals(expected, m); - - BigDecimal[][] testDataPlus3 = + assertEquals(expected, m); + + BigDecimal[][] testDataPlus3 = MatrixUtils.createBigMatrix(testDataPlus2).getData(); - m.setSubMatrix(testDataPlus3,0,0); + m.setSubMatrix(testDataPlus3,0,0); expected = MatrixUtils.createBigMatrix (new double[][] {{3.0,4.0,5.0},{4.0,7.0,5.0},{3.0,2.0,10.0}}); - assertEquals(expected, m); - + assertEquals(expected, m); + // javadoc example BigMatrixImpl matrix = (BigMatrixImpl) MatrixUtils.createBigMatrix (new double[][] {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 0, 1 , 2}}); @@ -718,16 +718,16 @@ new BigDecimal(3), new BigDecimal(4), new BigDecimal(8)}, {new BigDecimal(9), new BigDecimal(5) , new BigDecimal(6), new BigDecimal(2)}}); - assertEquals(expected, matrix); - + assertEquals(expected, matrix); + // dimension overflow - try { + try { m.setSubMatrix(matrix.getData(),1,1); fail("expecting MatrixIndexException"); } catch (MatrixIndexException e) { // expected } - + // null try { m.setSubMatrix(null,1,1); @@ -735,7 +735,7 @@ } catch (NullPointerException e) { // expected } - + // ragged try { m.setSubMatrix(new BigDecimal[][] {{new BigDecimal(1)}, @@ -744,7 +744,7 @@ } catch (IllegalArgumentException e) { // expected } - + // empty try { m.setSubMatrix(new BigDecimal[][] {{}}, 0, 0); @@ -752,17 +752,17 @@ } catch (IllegalArgumentException e) { // expected } - + } - + //--------------- -----------------Protected methods - - /** verifies that two matrices are close (1-norm) */ + + /** verifies that two matrices are close (1-norm) */ protected void assertClose(String msg, BigMatrix m, BigMatrix n, double tolerance) { assertTrue(msg,m.subtract(n).getNorm().doubleValue() < tolerance); } - + /** verifies that two vectors are close (sup norm) */ protected void assertClose(String msg, double[] m, double[] n, double tolerance) { @@ -770,18 +770,18 @@ fail("vectors not same length"); } for (int i = 0; i < m.length; i++) { - assertEquals(msg + " " + i + " elements differ", + assertEquals(msg + " " + i + " elements differ", m[i],n[i],tolerance); } } - + /** extracts the l and u matrices from compact lu representation */ protected void splitLU(BigMatrix lu, BigDecimal[][] lowerData, BigDecimal[][] 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++) { @@ -794,11 +794,11 @@ } else { lowerData[i][j] = new BigDecimal(0); upperData[i][j] = lu.getEntry(i, j); - } + } } } } - + /** Returns the result of applying the given row permutation to the matrix */ protected BigMatrix permuteRows(BigMatrix matrix, int[] permutation) { if (!matrix.isSquare() || matrix.getRowDimension() != permutation.length) { @@ -814,7 +814,7 @@ } return new BigMatrixImpl(out); } - + /** Extracts l and u matrices from lu and verifies that matrix = l times u modulo permutation */ protected void verifyDecomposition(BigMatrix matrix, BigMatrix lu) throws Exception{ int n = matrix.getRowDimension(); @@ -828,7 +828,7 @@ assertClose("lu decomposition does not work", permuted, lower.multiply(upper), normTolerance); } - + // /** Useful for debugging */ // private void dumpMatrix(BigMatrix m) { // for (int i = 0; i < m.getRowDimension(); i++) { @@ -839,6 +839,6 @@ // System.out.println(os); // } // } - + } Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/BlockFieldMatrixTest.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/BlockFieldMatrixTest.java?rev=811685&r1=811684&r2=811685&view=diff ============================================================================== --- commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/BlockFieldMatrixTest.java (original) +++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/BlockFieldMatrixTest.java Sat Sep 5 17:36:48 2009 @@ -5,9 +5,9 @@ * 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. @@ -34,14 +34,14 @@ */ public final class BlockFieldMatrixTest extends TestCase { - + // 3 x 3 identity matrix protected Fraction[][] id = { {new Fraction(1),new Fraction(0),new Fraction(0)}, {new Fraction(0),new Fraction(1),new Fraction(0)}, {new Fraction(0),new Fraction(0),new Fraction(1)} }; - + // Test data for group operations protected Fraction[][] testData = { {new Fraction(1),new Fraction(2),new Fraction(3)}, @@ -60,7 +60,7 @@ }; protected Fraction[][] testDataMinus = { {new Fraction(-1),new Fraction(-2),new Fraction(-3)}, - {new Fraction(-2),new Fraction(-5),new Fraction(-3)}, + {new Fraction(-2),new Fraction(-5),new Fraction(-3)}, {new Fraction(-1),new Fraction(0),new Fraction(-8)} }; protected Fraction[] testDataRow1 = {new Fraction(1),new Fraction(2),new Fraction(3)}; @@ -85,7 +85,7 @@ {new Fraction(15),new Fraction(0),new Fraction(0)}, {new Fraction(6),new Fraction(-2),new Fraction(7)} }; - + // lu decomposition tests protected Fraction[][] luData = { {new Fraction(2),new Fraction(3),new Fraction(3)}, @@ -97,7 +97,7 @@ {new Fraction(0),new Fraction(5),new Fraction(7)}, {new Fraction(1, 3),new Fraction(0),new Fraction(1, 3)} }; - + // singular matrices protected Fraction[][] singular = { {new Fraction(2),new Fraction(3)}, {new Fraction(2),new Fraction(3)} }; protected Fraction[][] bigSingular = { @@ -112,18 +112,18 @@ {new Fraction(7),new Fraction(8),new Fraction(10)} }; protected Fraction[][] detData2 = { {new Fraction(1), new Fraction(3)}, {new Fraction(2), new Fraction(4)}}; - + // vectors protected Fraction[] testVector = {new Fraction(1),new Fraction(2),new Fraction(3)}; protected Fraction[] testVector2 = {new Fraction(1),new Fraction(2),new Fraction(3),new Fraction(4)}; - + // submatrix accessor tests protected Fraction[][] subTestData = { {new Fraction(1), new Fraction(2), new Fraction(3), new Fraction(4)}, {new Fraction(3, 2), new Fraction(5, 2), new Fraction(7, 2), new Fraction(9, 2)}, {new Fraction(2), new Fraction(4), new Fraction(6), new Fraction(8)}, {new Fraction(4), new Fraction(5), new Fraction(6), new Fraction(7)} - }; + }; // array selections protected Fraction[][] subRows02Cols13 = { {new Fraction(2), new Fraction(4)}, {new Fraction(4), new Fraction(8)}}; protected Fraction[][] subRows03Cols12 = { {new Fraction(2), new Fraction(3)}, {new Fraction(5), new Fraction(6)}}; @@ -147,21 +147,21 @@ // column matrices protected Fraction[][] subColumn1 = {{new Fraction(2)}, {new Fraction(5, 2)}, {new Fraction(4)}, {new Fraction(5)}}; protected Fraction[][] subColumn3 = {{new Fraction(4)}, {new Fraction(9, 2)}, {new Fraction(8)}, {new Fraction(7)}}; - + // tolerances protected double entryTolerance = 10E-16; protected double normTolerance = 10E-14; - + public BlockFieldMatrixTest(String name) { super(name); } - + public static Test suite() { TestSuite suite = new TestSuite(BlockFieldMatrixTest.class); suite.setName("BlockFieldMatrix Tests"); return suite; } - + /** test dimensions */ public void testDimensions() { BlockFieldMatrix m = new BlockFieldMatrix(testData); @@ -172,8 +172,8 @@ 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() { Random r = new Random(66636328996002l); @@ -183,8 +183,8 @@ BlockFieldMatrix m3 = new BlockFieldMatrix(testData); BlockFieldMatrix m4 = new BlockFieldMatrix(m3.getData()); assertEquals(m3, m4); - } - + } + /** test add */ public void testAdd() { BlockFieldMatrix m = new BlockFieldMatrix(testData); @@ -195,9 +195,9 @@ for (int col = 0; col < m.getColumnDimension(); col++) { assertEquals(testDataPlusInv[row][col],sumEntries[row][col]); } - } + } } - + /** test add failure */ public void testAddFail() { BlockFieldMatrix m = new BlockFieldMatrix(testData); @@ -209,20 +209,20 @@ // ignored } } - + /** test m-n = m + -n */ public void testPlusMinus() { BlockFieldMatrix m = new BlockFieldMatrix(testData); BlockFieldMatrix m2 = new BlockFieldMatrix(testDataInv); - TestUtils.assertEquals(m.subtract(m2), m2.scalarMultiply(new Fraction(-1)).add(m)); + TestUtils.assertEquals(m.subtract(m2), m2.scalarMultiply(new Fraction(-1)).add(m)); try { m.subtract(new BlockFieldMatrix(testData2)); fail("Expecting illegalArgumentException"); } catch (IllegalArgumentException ex) { // ignored - } + } } - + /** test multiply */ public void testMultiply() { BlockFieldMatrix m = new BlockFieldMatrix(testData); @@ -233,13 +233,13 @@ TestUtils.assertEquals(mInv.multiply(m), identity); TestUtils.assertEquals(m.multiply(identity), m); TestUtils.assertEquals(identity.multiply(mInv), mInv); - TestUtils.assertEquals(m2.multiply(identity), m2); + TestUtils.assertEquals(m2.multiply(identity), m2); try { m.multiply(new BlockFieldMatrix(bigSingular)); fail("Expecting illegalArgumentException"); } catch (IllegalArgumentException ex) { // expected - } + } } public void testSeveralBlocks() { @@ -340,14 +340,14 @@ {new Fraction(4)} }; private Fraction[][] d5 = new Fraction[][] {{new Fraction(30)},{new Fraction(70)}}; - - public void testMultiply2() { - FieldMatrix m3 = new BlockFieldMatrix(d3); + + public void testMultiply2() { + FieldMatrix m3 = new BlockFieldMatrix(d3); FieldMatrix m4 = new BlockFieldMatrix(d4); FieldMatrix m5 = new BlockFieldMatrix(d5); TestUtils.assertEquals(m3.multiply(m4), m5); - } - + } + /** test trace */ public void testTrace() { FieldMatrix m = new BlockFieldMatrix(id); @@ -358,16 +358,16 @@ fail("Expecting NonSquareMatrixException"); } catch (NonSquareMatrixException ex) { // ignored - } + } } - + /** test scalarAdd */ public void testScalarAdd() { FieldMatrix m = new BlockFieldMatrix(testData); TestUtils.assertEquals(new BlockFieldMatrix(testDataPlus2), m.scalarAdd(new Fraction(2))); } - + /** test operate */ public void testOperate() { FieldMatrix m = new BlockFieldMatrix(id); @@ -379,7 +379,7 @@ fail("Expecting illegalArgumentException"); } catch (IllegalArgumentException ex) { // ignored - } + } } public void testOperateLarge() { @@ -421,10 +421,10 @@ assertEquals( new Fraction(7), b[1]); assertEquals(new Fraction(11), b[2]); } - + /** test transpose */ public void testTranspose() { - FieldMatrix m = new BlockFieldMatrix(testData); + FieldMatrix m = new BlockFieldMatrix(testData); FieldMatrix mIT = new FieldLUDecompositionImpl(m).getSolver().getInverse().transpose(); FieldMatrix mTI = new FieldLUDecompositionImpl(m.transpose()).getSolver().getInverse(); TestUtils.assertEquals(mIT, mTI); @@ -432,7 +432,7 @@ FieldMatrix mt = new BlockFieldMatrix(testData2T); TestUtils.assertEquals(mt, m.transpose()); } - + /** test preMultiply by vector */ public void testPremultiplyVector() { FieldMatrix m = new BlockFieldMatrix(testData); @@ -447,13 +447,13 @@ // ignored } } - + public void testPremultiply() { - FieldMatrix m3 = new BlockFieldMatrix(d3); + FieldMatrix m3 = new BlockFieldMatrix(d3); FieldMatrix m4 = new BlockFieldMatrix(d4); FieldMatrix m5 = new BlockFieldMatrix(d5); TestUtils.assertEquals(m4.preMultiply(m3), m5); - + BlockFieldMatrix m = new BlockFieldMatrix(testData); BlockFieldMatrix mInv = new BlockFieldMatrix(testDataInv); BlockFieldMatrix identity = new BlockFieldMatrix(id); @@ -466,9 +466,9 @@ fail("Expecting illegalArgumentException"); } catch (IllegalArgumentException ex) { // ignored - } + } } - + public void testGetVectors() { FieldMatrix m = new BlockFieldMatrix(testData); TestUtils.assertEquals(m.getRow(0), testDataRow1); @@ -486,7 +486,7 @@ // ignored } } - + public void testGetEntry() { FieldMatrix m = new BlockFieldMatrix(testData); assertEquals(m.getEntry(0,1),new Fraction(2)); @@ -497,7 +497,7 @@ // expected } } - + /** test examples in user guide */ public void testExamples() { // Create a real matrix with two rows and three columns @@ -518,10 +518,10 @@ assertEquals(2, p.getRowDimension()); assertEquals(2, p.getColumnDimension()); // Invert p - FieldMatrix pInverse = new FieldLUDecompositionImpl(p).getSolver().getInverse(); + FieldMatrix pInverse = new FieldLUDecompositionImpl(p).getSolver().getInverse(); assertEquals(2, pInverse.getRowDimension()); assertEquals(2, pInverse.getColumnDimension()); - + // Solve example Fraction[][] coefficientsData = { {new Fraction(2), new Fraction(3), new Fraction(-2)}, @@ -542,22 +542,22 @@ assertEquals(new Fraction(4).multiply(solution[0]). subtract(new Fraction(3).multiply(solution[1])). subtract(new Fraction(5).multiply(solution[2])), - constants[2]); - + constants[2]); + } - + // test submatrix accessors public void testGetSubMatrix() { FieldMatrix m = new BlockFieldMatrix(subTestData); checkGetSubMatrix(m, subRows23Cols00, 2 , 3 , 0, 0); checkGetSubMatrix(m, subRows00Cols33, 0 , 0 , 3, 3); - checkGetSubMatrix(m, subRows01Cols23, 0 , 1 , 2, 3); - checkGetSubMatrix(m, subRows02Cols13, new int[] { 0, 2 }, new int[] { 1, 3 }); - checkGetSubMatrix(m, subRows03Cols12, new int[] { 0, 3 }, new int[] { 1, 2 }); - checkGetSubMatrix(m, subRows03Cols123, new int[] { 0, 3 }, new int[] { 1, 2, 3 }); - checkGetSubMatrix(m, subRows20Cols123, new int[] { 2, 0 }, new int[] { 1, 2, 3 }); - checkGetSubMatrix(m, subRows31Cols31, new int[] { 3, 1 }, new int[] { 3, 1 }); - checkGetSubMatrix(m, subRows31Cols31, new int[] { 3, 1 }, new int[] { 3, 1 }); + checkGetSubMatrix(m, subRows01Cols23, 0 , 1 , 2, 3); + checkGetSubMatrix(m, subRows02Cols13, new int[] { 0, 2 }, new int[] { 1, 3 }); + checkGetSubMatrix(m, subRows03Cols12, new int[] { 0, 3 }, new int[] { 1, 2 }); + checkGetSubMatrix(m, subRows03Cols123, new int[] { 0, 3 }, new int[] { 1, 2, 3 }); + checkGetSubMatrix(m, subRows20Cols123, new int[] { 2, 0 }, new int[] { 1, 2, 3 }); + checkGetSubMatrix(m, subRows31Cols31, new int[] { 3, 1 }, new int[] { 3, 1 }); + checkGetSubMatrix(m, subRows31Cols31, new int[] { 3, 1 }, new int[] { 3, 1 }); checkGetSubMatrix(m, null, 1, 0, 2, 4); checkGetSubMatrix(m, null, -1, 1, 2, 2); checkGetSubMatrix(m, null, 1, 0, 2, 2); @@ -581,7 +581,7 @@ } } } - + private void checkGetSubMatrix(FieldMatrix m, Fraction[][] reference, int[] selectedRows, int[] selectedColumns) { try { @@ -623,14 +623,14 @@ FieldMatrix m = new BlockFieldMatrix(subTestData); checkCopy(m, subRows23Cols00, 2 , 3 , 0, 0); checkCopy(m, subRows00Cols33, 0 , 0 , 3, 3); - checkCopy(m, subRows01Cols23, 0 , 1 , 2, 3); - checkCopy(m, subRows02Cols13, new int[] { 0, 2 }, new int[] { 1, 3 }); - checkCopy(m, subRows03Cols12, new int[] { 0, 3 }, new int[] { 1, 2 }); - checkCopy(m, subRows03Cols123, new int[] { 0, 3 }, new int[] { 1, 2, 3 }); - checkCopy(m, subRows20Cols123, new int[] { 2, 0 }, new int[] { 1, 2, 3 }); - checkCopy(m, subRows31Cols31, new int[] { 3, 1 }, new int[] { 3, 1 }); - checkCopy(m, subRows31Cols31, new int[] { 3, 1 }, new int[] { 3, 1 }); - + checkCopy(m, subRows01Cols23, 0 , 1 , 2, 3); + checkCopy(m, subRows02Cols13, new int[] { 0, 2 }, new int[] { 1, 3 }); + checkCopy(m, subRows03Cols12, new int[] { 0, 3 }, new int[] { 1, 2 }); + checkCopy(m, subRows03Cols123, new int[] { 0, 3 }, new int[] { 1, 2, 3 }); + checkCopy(m, subRows20Cols123, new int[] { 2, 0 }, new int[] { 1, 2, 3 }); + checkCopy(m, subRows31Cols31, new int[] { 3, 1 }, new int[] { 3, 1 }); + checkCopy(m, subRows31Cols31, new int[] { 3, 1 }, new int[] { 3, 1 }); + checkCopy(m, null, 1, 0, 2, 4); checkCopy(m, null, -1, 1, 2, 2); checkCopy(m, null, 1, 0, 2, 2); @@ -657,7 +657,7 @@ } } } - + private void checkCopy(FieldMatrix m, Fraction[][] reference, int[] selectedRows, int[] selectedColumns) { try { @@ -716,7 +716,7 @@ // expected } } - + public void testGetSetRowMatrixLarge() { int n = 3 * BlockFieldMatrix.BLOCK_SIZE; FieldMatrix m = @@ -737,7 +737,7 @@ assertEquals(sub, m.getRowMatrix(2)); } - + public void testGetColumnMatrix() { FieldMatrix m = new BlockFieldMatrix(subTestData); FieldMatrix mColumn1 = new BlockFieldMatrix(subColumn1); @@ -798,7 +798,7 @@ assertEquals(sub, m.getColumnMatrix(2)); } - + public void testGetRowVector() { FieldMatrix m = new BlockFieldMatrix(subTestData); FieldVector mRow0 = new ArrayFieldVector(subRow0[0]); @@ -857,7 +857,7 @@ assertEquals(sub, m.getRowVector(2)); } - + public void testGetColumnVector() { FieldMatrix m = new BlockFieldMatrix(subTestData); FieldVector mColumn1 = columnToVector(subColumn1); @@ -916,7 +916,7 @@ assertEquals(sub, m.getColumnVector(2)); } - + private FieldVector columnToVector(Fraction[][] column) { Fraction[] data = new Fraction[column.length]; for (int i = 0; i < data.length; ++i) { @@ -981,7 +981,7 @@ checkArrays(sub, m.getRow(2)); } - + public void testGetColumn() { FieldMatrix m = new BlockFieldMatrix(subTestData); Fraction[] mColumn1 = columnToArray(subColumn1); @@ -1041,7 +1041,7 @@ checkArrays(sub, m.getColumn(2)); } - + private Fraction[] columnToArray(Fraction[][] column) { Fraction[] data = new Fraction[column.length]; for (int i = 0; i < data.length; ++i) { @@ -1053,10 +1053,10 @@ private void checkArrays(Fraction[] expected, Fraction[] actual) { assertEquals(expected.length, actual.length); for (int i = 0; i < expected.length; ++i) { - assertEquals(expected[i], actual[i]); + assertEquals(expected[i], actual[i]); } } - + public void testEqualsAndHashCode() { BlockFieldMatrix m = new BlockFieldMatrix(testData); BlockFieldMatrix m1 = (BlockFieldMatrix) m.copy(); @@ -1067,31 +1067,31 @@ assertEquals(m, m1); assertFalse(m.equals(null)); assertFalse(m.equals(mt)); - assertFalse(m.equals(new BlockFieldMatrix(bigSingular))); + assertFalse(m.equals(new BlockFieldMatrix(bigSingular))); } - + public void testToString() { BlockFieldMatrix m = new BlockFieldMatrix(testData); assertEquals("BlockFieldMatrix{{1,2,3},{2,5,3},{1,0,8}}", m.toString()); } - + public void testSetSubMatrix() throws Exception { BlockFieldMatrix m = new BlockFieldMatrix(testData); m.setSubMatrix(detData2,1,1); FieldMatrix expected = new BlockFieldMatrix (new Fraction[][] {{new Fraction(1),new Fraction(2),new Fraction(3)},{new Fraction(2),new Fraction(1),new Fraction(3)},{new Fraction(1),new Fraction(2),new Fraction(4)}}); - assertEquals(expected, m); - + assertEquals(expected, m); + m.setSubMatrix(detData2,0,0); expected = new BlockFieldMatrix (new Fraction[][] {{new Fraction(1),new Fraction(3),new Fraction(3)},{new Fraction(2),new Fraction(4),new Fraction(3)},{new Fraction(1),new Fraction(2),new Fraction(4)}}); - assertEquals(expected, m); - - m.setSubMatrix(testDataPlus2,0,0); + assertEquals(expected, m); + + m.setSubMatrix(testDataPlus2,0,0); expected = new BlockFieldMatrix (new Fraction[][] {{new Fraction(3),new Fraction(4),new Fraction(5)},{new Fraction(4),new Fraction(7),new Fraction(5)},{new Fraction(3),new Fraction(2),new Fraction(10)}}); - assertEquals(expected, m); - + assertEquals(expected, m); + // javadoc example BlockFieldMatrix matrix = new BlockFieldMatrix(new Fraction[][] { @@ -1109,29 +1109,29 @@ {new Fraction(5), new Fraction(3), new Fraction(4), new Fraction(8)}, {new Fraction(9), new Fraction(5) ,new Fraction(6), new Fraction(2)} }); - assertEquals(expected, matrix); + assertEquals(expected, matrix); // dimension overflow - try { + try { m.setSubMatrix(testData,1,1); fail("expecting MatrixIndexException"); } catch (MatrixIndexException e) { // expected } // dimension underflow - try { + try { m.setSubMatrix(testData,-1,1); fail("expecting MatrixIndexException"); } catch (MatrixIndexException e) { // expected } - try { + try { m.setSubMatrix(testData,1,-1); fail("expecting MatrixIndexException"); } catch (MatrixIndexException e) { // expected } - + // null try { m.setSubMatrix(null,1,1); @@ -1139,7 +1139,7 @@ } catch (NullPointerException e) { // expected } - + // ragged try { m.setSubMatrix(new Fraction[][] {{new Fraction(1)}, {new Fraction(2), new Fraction(3)}}, 0, 0); @@ -1147,7 +1147,7 @@ } catch (IllegalArgumentException e) { // expected } - + // empty try { m.setSubMatrix(new Fraction[][] {{}}, 0, 0); @@ -1155,7 +1155,7 @@ } catch (IllegalArgumentException e) { // expected } - + } public void testWalk() { @@ -1174,11 +1174,11 @@ m.walkInOptimizedOrder(getVisitor, 1, rows - 2, 1, columns - 2); assertEquals((rows - 2) * (columns - 2), getVisitor.getCount()); for (int i = 0; i < rows; ++i) { - assertEquals(new Fraction(0), m.getEntry(i, 0)); + assertEquals(new Fraction(0), m.getEntry(i, 0)); assertEquals(new Fraction(0), m.getEntry(i, columns - 1)); } for (int j = 0; j < columns; ++j) { - assertEquals(new Fraction(0), m.getEntry(0, j)); + assertEquals(new Fraction(0), m.getEntry(0, j)); assertEquals(new Fraction(0), m.getEntry(rows - 1, j)); } @@ -1194,11 +1194,11 @@ m.walkInOptimizedOrder(getVisitor, 1, rows - 2, 1, columns - 2); assertEquals((rows - 2) * (columns - 2), getVisitor.getCount()); for (int i = 0; i < rows; ++i) { - assertEquals(new Fraction(0), m.getEntry(i, 0)); + assertEquals(new Fraction(0), m.getEntry(i, 0)); assertEquals(new Fraction(0), m.getEntry(i, columns - 1)); } for (int j = 0; j < columns; ++j) { - assertEquals(new Fraction(0), m.getEntry(0, j)); + assertEquals(new Fraction(0), m.getEntry(0, j)); assertEquals(new Fraction(0), m.getEntry(rows - 1, j)); } @@ -1214,11 +1214,11 @@ m.walkInRowOrder(getVisitor, 1, rows - 2, 1, columns - 2); assertEquals((rows - 2) * (columns - 2), getVisitor.getCount()); for (int i = 0; i < rows; ++i) { - assertEquals(new Fraction(0), m.getEntry(i, 0)); + assertEquals(new Fraction(0), m.getEntry(i, 0)); assertEquals(new Fraction(0), m.getEntry(i, columns - 1)); } for (int j = 0; j < columns; ++j) { - assertEquals(new Fraction(0), m.getEntry(0, j)); + assertEquals(new Fraction(0), m.getEntry(0, j)); assertEquals(new Fraction(0), m.getEntry(rows - 1, j)); } @@ -1234,11 +1234,11 @@ m.walkInColumnOrder(getVisitor, 1, rows - 2, 1, columns - 2); assertEquals((rows - 2) * (columns - 2), getVisitor.getCount()); for (int i = 0; i < rows; ++i) { - assertEquals(new Fraction(0), m.getEntry(i, 0)); + assertEquals(new Fraction(0), m.getEntry(i, 0)); assertEquals(new Fraction(0), m.getEntry(i, columns - 1)); } for (int j = 0; j < columns; ++j) { - assertEquals(new Fraction(0), m.getEntry(0, j)); + assertEquals(new Fraction(0), m.getEntry(0, j)); assertEquals(new Fraction(0), m.getEntry(rows - 1, j)); } @@ -1290,6 +1290,6 @@ } return m; } - + }