commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From l..@apache.org
Subject svn commit: r731308 - in /commons/proper/math/trunk/src/test/org/apache/commons/math/linear: QRDecompositionImplTest.java QRSolverTest.java
Date Sun, 04 Jan 2009 18:08:50 GMT
Author: luc
Date: Sun Jan  4 10:08:50 2009
New Revision: 731308

URL: http://svn.apache.org/viewvc?rev=731308&view=rev
Log:
simplified tests
added new tests

Modified:
    commons/proper/math/trunk/src/test/org/apache/commons/math/linear/QRDecompositionImplTest.java
    commons/proper/math/trunk/src/test/org/apache/commons/math/linear/QRSolverTest.java

Modified: commons/proper/math/trunk/src/test/org/apache/commons/math/linear/QRDecompositionImplTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/org/apache/commons/math/linear/QRDecompositionImplTest.java?rev=731308&r1=731307&r2=731308&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/org/apache/commons/math/linear/QRDecompositionImplTest.java
(original)
+++ commons/proper/math/trunk/src/test/org/apache/commons/math/linear/QRDecompositionImplTest.java
Sun Jan  4 10:08:50 2009
@@ -17,6 +17,8 @@
 
 package org.apache.commons.math.linear;
 
+import java.util.Random;
+
 import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
@@ -59,143 +61,152 @@
 
     /** test dimensions */
     public void testDimensions() {
-        RealMatrix matrix = MatrixUtils.createRealMatrix(testData3x3NonSingular);
-        QRDecomposition qr = new QRDecompositionImpl(matrix);
-        assertEquals("3x3 Q size", qr.getQ().getRowDimension(), 3);
-        assertEquals("3x3 Q size", qr.getQ().getColumnDimension(), 3);
-        assertEquals("3x3 R size", qr.getR().getRowDimension(), 3);
-        assertEquals("3x3 R size", qr.getR().getColumnDimension(), 3);
+        checkDimension(MatrixUtils.createRealMatrix(testData3x3NonSingular));
 
-        matrix = MatrixUtils.createRealMatrix(testData4x3);
-        qr = new QRDecompositionImpl(matrix);
-        assertEquals("4x3 Q size", qr.getQ().getRowDimension(), 4);
-        assertEquals("4x3 Q size", qr.getQ().getColumnDimension(), 4);
-        assertEquals("4x3 R size", qr.getR().getRowDimension(), 4);
-        assertEquals("4x3 R size", qr.getR().getColumnDimension(), 3);
+        checkDimension(MatrixUtils.createRealMatrix(testData4x3));
 
-        matrix = MatrixUtils.createRealMatrix(testData3x4);
-        qr = new QRDecompositionImpl(matrix);
-        assertEquals("3x4 Q size", qr.getQ().getRowDimension(), 3);
-        assertEquals("3x4 Q size", qr.getQ().getColumnDimension(), 3);
-        assertEquals("3x4 R size", qr.getR().getRowDimension(), 3);
-        assertEquals("3x4 R size", qr.getR().getColumnDimension(), 4);
+        checkDimension(MatrixUtils.createRealMatrix(testData3x4));
+
+        Random r = new Random(643895747384642l);
+        int    p = (5 * DenseRealMatrix.BLOCK_SIZE) / 4;
+        int    q = (7 * DenseRealMatrix.BLOCK_SIZE) / 4;
+        checkDimension(createTestMatrix(r, p, q));
+        checkDimension(createTestMatrix(r, q, p));
+
+    }
+
+    private void checkDimension(RealMatrix m) {
+        int rows = m.getRowDimension();
+        int columns = m.getColumnDimension();
+        QRDecomposition qr = new QRDecompositionImpl(m);
+        assertEquals(rows,    qr.getQ().getRowDimension());
+        assertEquals(rows,    qr.getQ().getColumnDimension());
+        assertEquals(rows,    qr.getR().getRowDimension());
+        assertEquals(columns, qr.getR().getColumnDimension());        
     }
 
     /** test A = QR */
     public void testAEqualQR() {
-        RealMatrix A = MatrixUtils.createRealMatrix(testData3x3NonSingular);
-        QRDecomposition qr = new QRDecompositionImpl(A);
-        RealMatrix Q = qr.getQ();
-        RealMatrix R = qr.getR();
-        double norm = Q.multiply(R).subtract(A).getNorm();
-        assertEquals("3x3 nonsingular A = QR", 0, norm, normTolerance);
-
-        RealMatrix matrix = MatrixUtils.createRealMatrix(testData3x3Singular);
-        qr = new QRDecompositionImpl(matrix);
-        norm = qr.getQ().multiply(qr.getR()).subtract(matrix).getNorm();
-        assertEquals("3x3 singular A = QR", 0, norm, normTolerance);
+        checkAEqualQR(MatrixUtils.createRealMatrix(testData3x3NonSingular));
 
-        matrix = MatrixUtils.createRealMatrix(testData3x4);
-        qr = new QRDecompositionImpl(matrix);
-        norm = qr.getQ().multiply(qr.getR()).subtract(matrix).getNorm();
-        assertEquals("3x4 A = QR", 0, norm, normTolerance);
+        checkAEqualQR(MatrixUtils.createRealMatrix(testData3x3Singular));
+
+        checkAEqualQR(MatrixUtils.createRealMatrix(testData3x4));
+
+        checkAEqualQR(MatrixUtils.createRealMatrix(testData4x3));
+
+        Random r = new Random(643895747384642l);
+        int    p = (5 * DenseRealMatrix.BLOCK_SIZE) / 4;
+        int    q = (7 * DenseRealMatrix.BLOCK_SIZE) / 4;
+        checkAEqualQR(createTestMatrix(r, p, q));
+
+        checkAEqualQR(createTestMatrix(r, q, p));
 
-        matrix = MatrixUtils.createRealMatrix(testData4x3);
-        qr = new QRDecompositionImpl(matrix);
-        norm = qr.getQ().multiply(qr.getR()).subtract(matrix).getNorm();
-        assertEquals("4x3 A = QR", 0, norm, normTolerance);
+    }
+
+    private void checkAEqualQR(RealMatrix m) {
+        QRDecomposition qr = new QRDecompositionImpl(m);
+        double norm = qr.getQ().multiply(qr.getR()).subtract(m).getNorm();
+        assertEquals(0, norm, normTolerance);
     }
 
     /** test the orthogonality of Q */
     public void testQOrthogonal() {
-        RealMatrix matrix = MatrixUtils.createRealMatrix(testData3x3NonSingular);
-        RealMatrix q  = new QRDecompositionImpl(matrix).getQ();
-        RealMatrix qT = new QRDecompositionImpl(matrix).getQT();
-        RealMatrix eye = MatrixUtils.createRealIdentityMatrix(3);
-        double norm = qT.multiply(q).subtract(eye).getNorm();
-        assertEquals("3x3 nonsingular Q'Q = I", 0, norm, normTolerance);
+        checkQOrthogonal(MatrixUtils.createRealMatrix(testData3x3NonSingular));
 
-        matrix = MatrixUtils.createRealMatrix(testData3x3Singular);
-        q  = new QRDecompositionImpl(matrix).getQ();
-        qT = new QRDecompositionImpl(matrix).getQT();
-        eye = MatrixUtils.createRealIdentityMatrix(3);
-        norm = qT.multiply(q).subtract(eye).getNorm();
-        assertEquals("3x3 singular Q'Q = I", 0, norm, normTolerance);
+        checkQOrthogonal(MatrixUtils.createRealMatrix(testData3x3Singular));
 
-        matrix = MatrixUtils.createRealMatrix(testData3x4);
-        q  = new QRDecompositionImpl(matrix).getQ();
-        qT = new QRDecompositionImpl(matrix).getQT();
-        eye = MatrixUtils.createRealIdentityMatrix(3);
-        norm = qT.multiply(q).subtract(eye).getNorm();
-        assertEquals("3x4 Q'Q = I", 0, norm, normTolerance);
+        checkQOrthogonal(MatrixUtils.createRealMatrix(testData3x4));
+
+        checkQOrthogonal(MatrixUtils.createRealMatrix(testData4x3));
+
+        Random r = new Random(643895747384642l);
+        int    p = (5 * DenseRealMatrix.BLOCK_SIZE) / 4;
+        int    q = (7 * DenseRealMatrix.BLOCK_SIZE) / 4;
+        checkQOrthogonal(createTestMatrix(r, p, q));
+
+        checkQOrthogonal(createTestMatrix(r, q, p));
 
-        matrix = MatrixUtils.createRealMatrix(testData4x3);
-        q  = new QRDecompositionImpl(matrix).getQ();
-        qT = new QRDecompositionImpl(matrix).getQT();
-        eye = MatrixUtils.createRealIdentityMatrix(4);
-        norm = qT.multiply(q).subtract(eye).getNorm();
-        assertEquals("4x3 Q'Q = I", 0, norm, normTolerance);
+    }
+
+    private void checkQOrthogonal(RealMatrix m) {
+        QRDecomposition qr = new QRDecompositionImpl(m);
+        RealMatrix eye = MatrixUtils.createRealIdentityMatrix(m.getRowDimension());
+        double norm = qr.getQT().multiply(qr.getQ()).subtract(eye).getNorm();
+        assertEquals(0, norm, normTolerance);
     }
 
     /** test that R is upper triangular */
     public void testRUpperTriangular() {
         RealMatrix matrix = MatrixUtils.createRealMatrix(testData3x3NonSingular);
-        RealMatrix R = new QRDecompositionImpl(matrix).getR();
-        for (int i = 0; i < R.getRowDimension(); i++)
-            for (int j = 0; j < i; j++)
-                assertEquals("R lower triangle", R.getEntry(i, j), 0,
-                        entryTolerance);
+        checkUpperTriangular(new QRDecompositionImpl(matrix).getR());
 
         matrix = MatrixUtils.createRealMatrix(testData3x3Singular);
-        R = new QRDecompositionImpl(matrix).getR();
-        for (int i = 0; i < R.getRowDimension(); i++)
-            for (int j = 0; j < i; j++)
-                assertEquals("R lower triangle", R.getEntry(i, j), 0,
-                        entryTolerance);
+        checkUpperTriangular(new QRDecompositionImpl(matrix).getR());
 
         matrix = MatrixUtils.createRealMatrix(testData3x4);
-        R = new QRDecompositionImpl(matrix).getR();
-        for (int i = 0; i < R.getRowDimension(); i++)
-            for (int j = 0; j < i; j++)
-                assertEquals("R lower triangle", R.getEntry(i, j), 0,
-                        entryTolerance);
+        checkUpperTriangular(new QRDecompositionImpl(matrix).getR());
 
         matrix = MatrixUtils.createRealMatrix(testData4x3);
-        R = new QRDecompositionImpl(matrix).getR();
-        for (int i = 0; i < R.getRowDimension(); i++)
-            for (int j = 0; j < i; j++)
-                assertEquals("R lower triangle", R.getEntry(i, j), 0,
-                        entryTolerance);
+        checkUpperTriangular(new QRDecompositionImpl(matrix).getR());
+
+        Random r = new Random(643895747384642l);
+        int    p = (5 * DenseRealMatrix.BLOCK_SIZE) / 4;
+        int    q = (7 * DenseRealMatrix.BLOCK_SIZE) / 4;
+        matrix = createTestMatrix(r, p, q);
+        checkUpperTriangular(new QRDecompositionImpl(matrix).getR());
+
+        matrix = createTestMatrix(r, p, q);
+        checkUpperTriangular(new QRDecompositionImpl(matrix).getR());
+
+    }
+
+    private void checkUpperTriangular(RealMatrix m) {
+        m.walkInOptimizedOrder(new DefaultRealMatrixPreservingVisitor() {
+            private static final long serialVersionUID = -7685630069569815930L;
+            public void visit(int row, int column, double value) {
+                if (column < row) {
+                    assertEquals(0.0, value, entryTolerance);
+                }
+            }
+        });
     }
 
     /** test that H is trapezoidal */
     public void testHTrapezoidal() {
         RealMatrix matrix = MatrixUtils.createRealMatrix(testData3x3NonSingular);
-        RealMatrix H = new QRDecompositionImpl(matrix).getH();
-        for (int i = 0; i < H.getRowDimension(); i++)
-            for (int j = i + 1; j < H.getColumnDimension(); j++)
-                assertEquals(H.getEntry(i, j), 0, entryTolerance);
+        checkTrapezoidal(new QRDecompositionImpl(matrix).getH());
 
         matrix = MatrixUtils.createRealMatrix(testData3x3Singular);
-        H = new QRDecompositionImpl(matrix).getH();
-        for (int i = 0; i < H.getRowDimension(); i++)
-            for (int j = i + 1; j < H.getColumnDimension(); j++)
-                assertEquals(H.getEntry(i, j), 0, entryTolerance);
+        checkTrapezoidal(new QRDecompositionImpl(matrix).getH());
 
         matrix = MatrixUtils.createRealMatrix(testData3x4);
-        H = new QRDecompositionImpl(matrix).getH();
-        for (int i = 0; i < H.getRowDimension(); i++)
-            for (int j = i + 1; j < H.getColumnDimension(); j++)
-                assertEquals(H.getEntry(i, j), 0, entryTolerance);
+        checkTrapezoidal(new QRDecompositionImpl(matrix).getH());
 
         matrix = MatrixUtils.createRealMatrix(testData4x3);
-        H = new QRDecompositionImpl(matrix).getH();
-        for (int i = 0; i < H.getRowDimension(); i++)
-            for (int j = i + 1; j < H.getColumnDimension(); j++)
-                assertEquals(H.getEntry(i, j), 0, entryTolerance);
+        checkTrapezoidal(new QRDecompositionImpl(matrix).getH());
+
+        Random r = new Random(643895747384642l);
+        int    p = (5 * DenseRealMatrix.BLOCK_SIZE) / 4;
+        int    q = (7 * DenseRealMatrix.BLOCK_SIZE) / 4;
+        matrix = createTestMatrix(r, p, q);
+        checkTrapezoidal(new QRDecompositionImpl(matrix).getH());
+
+        matrix = createTestMatrix(r, p, q);
+        checkTrapezoidal(new QRDecompositionImpl(matrix).getH());
 
     }
 
+    private void checkTrapezoidal(RealMatrix m) {
+        m.walkInOptimizedOrder(new DefaultRealMatrixPreservingVisitor() {
+            private static final long serialVersionUID = -43649044361860701L;
+            public void visit(int row, int column, double value) {
+                if (column > row) {
+                    assertEquals(0.0, value, entryTolerance);
+                }
+            }
+        });
+    }
     /** test matrices values */
     public void testMatricesValues() {
         QRDecomposition qr =
@@ -233,4 +244,16 @@
         
     }
 
+    private RealMatrix createTestMatrix(final Random r, final int rows, final int columns)
{
+        RealMatrix m = MatrixUtils.createRealMatrix(rows, columns);
+        m.walkInOptimizedOrder(new DefaultRealMatrixChangingVisitor(){
+            private static final long serialVersionUID = -556118291433400034L;
+            public double visit(int row, int column, double value)
+                throws MatrixVisitorException {
+                return 2.0 * r.nextDouble() - 1.0;
+            }
+        });
+        return m;
+    }
+
 }

Modified: commons/proper/math/trunk/src/test/org/apache/commons/math/linear/QRSolverTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/org/apache/commons/math/linear/QRSolverTest.java?rev=731308&r1=731307&r2=731308&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/org/apache/commons/math/linear/QRSolverTest.java (original)
+++ commons/proper/math/trunk/src/test/org/apache/commons/math/linear/QRSolverTest.java Sun
Jan  4 10:08:50 2009
@@ -17,31 +17,37 @@
 
 package org.apache.commons.math.linear;
 
+import java.util.Random;
+
 import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
 
 public class QRSolverTest extends TestCase {
     double[][] testData3x3NonSingular = { 
-            { 12, -51, 4 }, 
-            { 6, 167, -68 },
-            { -4, 24, -41 }, };
+            { 12, -51,   4 }, 
+            {  6, 167, -68 },
+            { -4,  24, -41 }
+    };
 
     double[][] testData3x3Singular = { 
-            { 1, 4, 7, }, 
-            { 2, 5, 8, },
-            { 3, 6, 9, }, };
+            { 1, 2,  2 }, 
+            { 2, 4,  6 },
+            { 4, 8, 12 }
+    };
 
     double[][] testData3x4 = { 
-            { 12, -51, 4, 1 }, 
-            { 6, 167, -68, 2 },
-            { -4, 24, -41, 3 }, };
+            { 12, -51,   4, 1 }, 
+            {  6, 167, -68, 2 },
+            { -4,  24, -41, 3 }
+    };
 
     double[][] testData4x3 = { 
-            { 12, -51, 4, }, 
-            { 6, 167, -68, },
-            { -4, 24, -41, }, 
-            { -5, 34, 7, }, };
+            { 12, -51,   4 }, 
+            {  6, 167, -68 },
+            { -4,  24, -41 }, 
+            { -5,  34,   7 }
+    };
 
     public QRSolverTest(String name) {
         super(name);
@@ -55,25 +61,25 @@
 
     /** test rank */
     public void testRank() {
-        QRSolver solver =
-            new QRSolver(new QRDecompositionImpl(MatrixUtils.createRealMatrix(testData3x3NonSingular)));
+        DecompositionSolver solver =
+            new QRDecompositionImpl(MatrixUtils.createRealMatrix(testData3x3NonSingular)).getSolver();
         assertTrue(solver.isNonSingular());
 
-        solver = new QRSolver(new QRDecompositionImpl(MatrixUtils.createRealMatrix(testData3x3Singular)));
+        solver = new QRDecompositionImpl(MatrixUtils.createRealMatrix(testData3x3Singular)).getSolver();
         assertFalse(solver.isNonSingular());
 
-        solver = new QRSolver(new QRDecompositionImpl(MatrixUtils.createRealMatrix(testData3x4)));
-        assertFalse(solver.isNonSingular());
+        solver = new QRDecompositionImpl(MatrixUtils.createRealMatrix(testData3x4)).getSolver();
+        assertTrue(solver.isNonSingular());
 
-        solver = new QRSolver(new QRDecompositionImpl(MatrixUtils.createRealMatrix(testData4x3)));
+        solver = new QRDecompositionImpl(MatrixUtils.createRealMatrix(testData4x3)).getSolver();
         assertTrue(solver.isNonSingular());
 
     }
 
     /** test solve dimension errors */
     public void testSolveDimensionErrors() {
-        QRSolver solver =
-            new QRSolver(new QRDecompositionImpl(MatrixUtils.createRealMatrix(testData3x3NonSingular)));
+        DecompositionSolver solver =
+            new QRDecompositionImpl(MatrixUtils.createRealMatrix(testData3x3NonSingular)).getSolver();
         RealMatrix b = MatrixUtils.createRealMatrix(new double[2][2]);
         try {
             solver.solve(b);
@@ -103,8 +109,8 @@
 
     /** test solve rank errors */
     public void testSolveRankErrors() {
-        QRSolver solver =
-            new QRSolver(new QRDecompositionImpl(MatrixUtils.createRealMatrix(testData3x3Singular)));
+        DecompositionSolver solver =
+            new QRDecompositionImpl(MatrixUtils.createRealMatrix(testData3x3Singular)).getSolver();
         RealMatrix b = MatrixUtils.createRealMatrix(new double[3][2]);
         try {
             solver.solve(b);
@@ -134,8 +140,9 @@
 
     /** test solve */
     public void testSolve() {
-        QRSolver solver =
-            new QRSolver(new QRDecompositionImpl(MatrixUtils.createRealMatrix(testData3x3NonSingular)));
+        QRDecomposition decomposition =
+            new QRDecompositionImpl(MatrixUtils.createRealMatrix(testData3x3NonSingular));
+        DecompositionSolver solver = decomposition.getSolver();
         RealMatrix b = MatrixUtils.createRealMatrix(new double[][] {
                 { -102, 12250 }, { 544, 24500 }, { 167, -36750 }
         });
@@ -144,31 +151,82 @@
         });
 
         // using RealMatrix
-        assertEquals(0, solver.solve(b).subtract(xRef).getNorm(), 1.0e-13);
+        assertEquals(0, solver.solve(b).subtract(xRef).getNorm(), 2.0e-16 * xRef.getNorm());
 
         // using double[]
         for (int i = 0; i < b.getColumnDimension(); ++i) {
-            assertEquals(0,
-                         new RealVectorImpl(solver.solve(b.getColumn(i))).subtract(xRef.getColumnVector(i)).getNorm(),
-                         1.0e-13);
+            final double[] x = solver.solve(b.getColumn(i));
+            final double error = new RealVectorImpl(x).subtract(xRef.getColumnVector(i)).getNorm();
+            assertEquals(0, error, 3.0e-16 * xRef.getColumnVector(i).getNorm());
         }
 
         // using RealVectorImpl
         for (int i = 0; i < b.getColumnDimension(); ++i) {
-            assertEquals(0,
-                         solver.solve(b.getColumnVector(i)).subtract(xRef.getColumnVector(i)).getNorm(),
-                         1.0e-13);
+            final RealVector x = solver.solve(b.getColumnVector(i));
+            final double error = x.subtract(xRef.getColumnVector(i)).getNorm();
+            assertEquals(0, error, 3.0e-16 * xRef.getColumnVector(i).getNorm());
         }
 
         // using RealVector with an alternate implementation
         for (int i = 0; i < b.getColumnDimension(); ++i) {
             RealVectorImplTest.RealVectorTestImpl v =
                 new RealVectorImplTest.RealVectorTestImpl(b.getColumn(i));
-            assertEquals(0,
-                         solver.solve(v).subtract(xRef.getColumnVector(i)).getNorm(),
-                         1.0e-13);
+            final RealVector x = solver.solve(v);
+            final double error = x.subtract(xRef.getColumnVector(i)).getNorm();
+            assertEquals(0, error, 3.0e-16 * xRef.getColumnVector(i).getNorm());
         }
 
     }
 
+    public void testOverdetermined() {
+        final Random r    = new Random(5559252868205245l);
+        int          p    = (7 * DenseRealMatrix.BLOCK_SIZE) / 4;
+        int          q    = (5 * DenseRealMatrix.BLOCK_SIZE) / 4;
+        RealMatrix   a    = createTestMatrix(r, p, q);
+        RealMatrix   xRef = createTestMatrix(r, q, DenseRealMatrix.BLOCK_SIZE + 3);
+
+        // build a perturbed system: A.X + noise = B
+        RealMatrix b = a.multiply(xRef);
+        final double noise = 0.001;
+        b.walkInOptimizedOrder(new DefaultRealMatrixChangingVisitor() {
+            private static final long serialVersionUID = 3533849820776962636L;
+            public double visit(int row, int column, double value) {
+                return value * (1.0 + noise * (2 * r.nextDouble() - 1));
+            }
+        });
+
+        // despite perturbation, the least square solution should be pretty good
+        RealMatrix x = new QRDecompositionImpl(a).getSolver().solve(b);
+        assertEquals(0, x.subtract(xRef).getNorm(), 0.01 * noise * p * q);
+
+    }
+
+    public void testUnderdetermined() {
+        final Random r    = new Random(42185006424567123l);
+        int          p    = (5 * DenseRealMatrix.BLOCK_SIZE) / 4;
+        int          q    = (7 * DenseRealMatrix.BLOCK_SIZE) / 4;
+        RealMatrix   a    = createTestMatrix(r, p, q);
+        RealMatrix   xRef = createTestMatrix(r, q, DenseRealMatrix.BLOCK_SIZE + 3);
+        RealMatrix   b    = a.multiply(xRef);
+        RealMatrix   x = new QRDecompositionImpl(a).getSolver().solve(b);
+
+        // too many equations, the system cannot be solved at all
+        assertTrue(x.subtract(xRef).getNorm() / (p * q) > 0.01);
+
+        // the last unknown should have been set to 0
+        assertEquals(0.0, x.getSubMatrix(p, q - 1, 0, x.getColumnDimension() - 1).getNorm());
+
+    }
+
+    private RealMatrix createTestMatrix(final Random r, final int rows, final int columns)
{
+        RealMatrix m = MatrixUtils.createRealMatrix(rows, columns);
+        m.walkInOptimizedOrder(new DefaultRealMatrixChangingVisitor(){
+            private static final long serialVersionUID = -556118291433400034L;
+            public double visit(int row, int column, double value)
+                throws MatrixVisitorException {
+                return 2.0 * r.nextDouble() - 1.0;
+            }
+        });
+        return m;
+    }
 }



Mime
View raw message