matrixtestabstract.java

另一个功能更强大的矩阵运算软件开源代码

        add(Ad, 1, Bd);
        assertEquals(Ad, A);
        assertEquals(Bd, B);
    }

    /**
     * Tests <code>A = A + 0*B</code>
     */
    public void testZeroMatrixAdd() {
        A = A.add(0, B);
        add(Ad, 0, Bd);
        assertEquals(Ad, A);
        assertEquals(Bd, B);
    }

    /**
     * Tests <code>A = alpha*B</code>
     */
    public void testRandomMatrixSet() {
        double alpha = Math.random();
        A = A.set(alpha, B);
        set(Ad, alpha, Bd);
        assertEquals(Ad, A);
        assertEquals(Bd, B);
    }

    /**
     * Tests <code>A = B</code>
     */
    public void testMatrixSet() {
        A = A.set(B);
        set(Ad, 1, Bd);
        assertEquals(Ad, A);
        assertEquals(Bd, B);
    }

    /**
     * Tests <code>A = 1*B</code>
     */
    public void testOneMatrixSet() {
        A = A.set(1, B);
        set(Ad, 1, Bd);
        assertEquals(Ad, A);
        assertEquals(Bd, B);
    }

    /**
     * Tests <code>A = 0*B</code>
     */
    public void testZeroMatrixSet() {
        A = A.set(0, B);
        set(Ad, 0, Bd);
        assertEquals(Ad, A);
        assertEquals(Bd, B);
    }

    /**
     * Checks transpose
     */
    public void testTranspose() {
        Matrix At = Matrices.random(A.numColumns(), A.numRows());
        assertEquals(transpose(), A.transpose(At));
    }

    protected void set(double[][] A, double alpha, double[][] B) {
        for (int i = 0; i < A.length; ++i)
            for (int j = 0; j < A[i].length; ++j)
                A[i][j] = alpha * B[i][j];
    }

    protected void add(double[][] A, double alpha, double[][] B) {
        for (int i = 0; i < A.length; ++i)
            for (int j = 0; j < A[i].length; ++j)
                A[i][j] += alpha * B[i][j];
    }

    protected double[][] transpose() {
        if (Ad.length == 0)
            return new double[0][0];

        double[][] Adt = new double[Ad[0].length][Ad.length];
        for (int i = 0; i < Ad.length; ++i)
            for (int j = 0; j < Ad[i].length; ++j)
                Adt[j][i] = Ad[i][j];
        return Adt;
    }

    /**
     * Test of direct matrix solver
     */
    public void testMatrixSolve() {
        while (true) {
            try {
                Matrix B = Matrices.random(A.numRows(), A.numColumns());
                Matrix X = Matrices.random(A.numRows(), A.numColumns());
                X = A.solve(B, X);

                Matrix Y = A.multAdd(X, X.copy().set(-1, B));
                assertEquals(0, Y.norm(Matrix.Norm.Frobenius), tol);
                assertEquals(Ad, A);
                return;
            } catch (MatrixSingularException e) {
                Utilities.addDiagonal(A, Ad, 1);
            } catch (MatrixNotSPDException e) {
                Utilities.addDiagonal(A, Ad, 1);
            }
        }
    }

    /**
     * Test of direct transpose matrix solver
     */
    public void testTransMatrixSolve() {
        while (true) {
            try {
                Matrix B = Matrices.random(A.numRows(), A.numColumns());
                Matrix X = Matrices.random(A.numRows(), A.numColumns());
                X = A.transSolve(B, X);

                Matrix Y = A.transAmultAdd(X, X.copy().set(-1, B));
                assertEquals(0, Y.norm(Matrix.Norm.Frobenius), tol);
                assertEquals(Ad, A);
                return;
            } catch (MatrixSingularException e) {
                Utilities.addDiagonal(A, Ad, 1);
            } catch (MatrixNotSPDException e) {
                Utilities.addDiagonal(A, Ad, 1);
            }
        }
    }

    /**
     * Test of direct vector solver
     */
    public void testVectorSolve() {
        while (true) {
            try {
                Vector b = Matrices.random(A.numRows());
                Vector x = Matrices.random(A.numRows());
                x = A.solve(b, x);

                Vector y = A.multAdd(-1, x, x.copy().set(b));
                assertEquals(0, y.norm(Vector.Norm.Two), tol);
                assertEquals(Ad, A);
                return;
            } catch (MatrixSingularException e) {
                Utilities.addDiagonal(A, Ad, 1);
            } catch (MatrixNotSPDException e) {
                Utilities.addDiagonal(A, Ad, 1);
            }
        }
    }

    /**
     * Test of direct transpose vector solver
     */
    public void testTransVectorSolve() {
        while (true) {
            try {
                Vector b = Matrices.random(A.numRows());
                Vector x = Matrices.random(A.numRows());
                x = A.transSolve(b, x);

                Vector y = A.transMultAdd(-1, x, x.copy().set(b));
                assertEquals(0, y.norm(Vector.Norm.Two), tol);
                assertEquals(Ad, A);
                return;
            } catch (MatrixSingularException e) {
                Utilities.addDiagonal(A, Ad, 1);
            } catch (MatrixNotSPDException e) {
                Utilities.addDiagonal(A, Ad, 1);
            }
        }
    }

    /**
     * Test additions using iterators
     */
    public void testAdd() {
        double alpha = Math.random();
        for (MatrixEntry e : A) {
            A.add(e.row(), e.column(), alpha);
            A.add(e.row(), e.column(), -alpha);
        }
        assertEquals(Ad, A);
    }

    /**
     * Checks that copy is deep, not reference
     */
    public void testCopy() {
        Matrix Ac = A.copy();
        A = A.zero();
        assertEquals(Ad, Ac);
    }

    /**
     * Test iterator get
     */
    public void testIterator() {
        double[][] Ac = new double[A.numRows()][A.numColumns()];
        for (MatrixEntry e : A)
            Ac[e.row()][e.column()] = e.get();
        assertEquals(Ad, Ac);
    }

    /**
     * Test iterator set
     */
    public void testIteratorSet() {
        double alpha = Math.random();
        for (MatrixEntry e : A)
            e.set(e.get() * alpha);
        assertEquals(scale(alpha), A);
    }

    /**
     * Test iterator read and write
     */
    public void testIteratorSetGet() {
        double alpha = Math.random();
        double[][] Ac = new double[A.numRows()][A.numColumns()];
        for (MatrixEntry e : A) {
            Ac[e.row()][e.column()] = e.get();
            e.set(alpha * e.get());
            e.set(e.get() / alpha);
        }
        assertEquals(Ad, Ac);
        assertEquals(Ad, A);
    }

    /**
     * Checks zero()
     */
    public void testZero() {
        assertEquals(zero(), A.zero());
    }

    protected double[][] zero() {
        for (int i = 0; i < Ad.length; ++i)
            for (int j = 0; j < Ad[i].length; ++j)
                Ad[i][j] = 0;
        return Ad;
    }

    /**
     * Cardinality computation
     */
    public void testCardinality() {
        assertEquals(Matrices.cardinality(A), cardinality());
    }

    protected int cardinality() {
        int nz = 0;
        for (int i = 0; i < Ad.length; ++i)
            for (int j = 0; j < Ad[i].length; ++j)
                if (Ad[i][j] != 0.)
                    nz++;
        return nz;
    }

    /**
     * Checks in-place transpose for square matrices
     */
    public void testTransposeInplace() {
        if (A.isSquare())
            assertEquals(transpose(), A.copy().transpose());
    }

    /**
     * Scaling with an arbitrary scalar
     */
    public void testScale() {
        double alpha = Math.random();
        A = A.scale(alpha);
        scale(alpha);
        assertEquals(Ad, A);
    }

    /**
     * Scaling by zero
     */
    public void testZeroScale() {
        A = A.scale(0);
        scale(0);
        assertEquals(Ad, A);
    }

    /**
     * Scaling by one
     */
    public void testOneScale() {
        A = A.scale(1);
        scale(1);
        assertEquals(Ad, A);
    }

    protected double[][] scale(double alpha) {
        for (int i = 0; i < Ad.length; ++i)
            for (int j = 0; j < Ad[i].length; ++j)
                Ad[i][j] *= alpha;
        return Ad;
    }

    /**
     * Checks the 1 norm
     */
    public void testOneNorm() {
        assertEquals(norm1(Ad), A.norm(Matrix.Norm.One), tol);
        assertEquals(Ad, A);
    }

    /**
     * Checks the Frobenius norm
     */
    public void testFrobeniusNorm() {
        assertEquals(normF(Ad), A.norm(Matrix.Norm.Frobenius), tol);
        assertEquals(Ad, A);
    }

    /**
     * Checks the infinity norm
     */
    public void testInfinityNorm() {
        assertEquals(normInf(Ad), A.norm(Matrix.Norm.Infinity), tol);
        assertEquals(Ad, A);
    }

    protected double norm1(double[][] A) {
        double max = 0;
        for (int i = 0; i < A.length; ++i) {
            double rowsum = 0;
            for (int j = 0; j < A[i].length; ++j)
                rowsum += Math.abs(A[i][j]);
            max = Math.max(rowsum, max);
        }
        return max;
    }

    protected double normF(double[][] A) {
        double norm = 0;
        for (int i = 0; i < A.length; ++i)
            for (int j = 0; j < A[i].length; ++j)
                norm += A[i][j] * A[i][j];
        return Math.sqrt(norm);
    }

    protected double normInf(double[][] A) {
        if (A.length == 0)
            return 0;

        double[] columnSum = new double[A[0].length];
        for (int i = 0; i < A.length; ++i)
            for (int j = 0; j < A[i].length; ++j)
                columnSum[j] += Math.abs(A[i][j]);

        double max = 0;
        for (double d : columnSum)
            max = Math.max(max, d);
        return max;
    }

    /**
     * Checks for equality between the matrix and the array
     */
    protected void assertEquals(double[][] Ad, Matrix A) {
        assertTrue(A != null);
        assertTrue(Ad != null);
        assertTrue(A.numRows() == Ad.length);
        for (int i = 0; i < A.numRows(); ++i) {
            assertTrue(A.numColumns() == Ad[i].length);
            for (int j = 0; j < A.numColumns(); ++j)
                assertEquals(Ad[i][j], A.get(i, j), 1e-12);
        }
    }

    /**
     * Checks for equality between two arrays
     */
    protected void assertEquals(double[][] Ad, double[][] Ac) {
        assertTrue(Ac.length == Ad.length);
        for (int i = 0; i < A.numRows(); ++i) {
            assertTrue(Ac[i].length == Ad[i].length);
            for (int j = 0; j < A.numColumns(); ++j)
                assertEquals(Ad[i][j], Ac[i][j], 1e-12);
        }
    }

    protected void assertEquals(double[] xd, Vector x) {
        assertEquals(xd.length, x.size());
        for (int i = 0; i < xd.length; ++i)
            assertEquals(xd[i], x.get(i), tol);
    }

    protected void assertEquals(double[] xd, double[] yd) {
        for (int i = 0; i < xd.length; ++i)
            assertEquals(xd[i], yd[i], tol);
    }

}