matrixtestabstract.java

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

        double[][] Bd = Matrices.getArray(B), Cd = Matrices.getArray(C);
        double alpha = Math.random();

        C = A.multAdd(alpha, B, C);
        Cd = multAdd(Ad, alpha, Bd, Cd);

        assertEquals(Ad, A);
        assertEquals(Bd, B);
        assertEquals(Cd, C);
    }

    public void testMatrixTransAmultAddDense() {
        int m = A.numColumns(), k = A.numRows(), n = Utilities.getInt(1, max);
        Matrix B = Matrices.random(k, n), C = Matrices.random(m, n);
        double[][] Bd = Matrices.getArray(B), Cd = Matrices.getArray(C);
        double alpha = Math.random();

        C = A.transAmultAdd(alpha, B, C);
        Cd = transAmultAdd(Ad, alpha, Bd, Cd);

        assertEquals(Ad, A);
        assertEquals(Bd, B);
        assertEquals(Cd, C);
    }

    public void testMatrixTransAmultAdd() {
        int m = A.numColumns(), k = A.numRows(), n = Utilities.getInt(1, max);
        Matrix B = Matrices.synchronizedMatrix(Matrices.random(k, n)), C = Matrices
                .synchronizedMatrix(Matrices.random(m, n));
        double[][] Bd = Matrices.getArray(B), Cd = Matrices.getArray(C);
        double alpha = Math.random();

        C = A.transAmultAdd(alpha, B, C);
        Cd = transAmultAdd(Ad, alpha, Bd, Cd);

        assertEquals(Ad, A);
        assertEquals(Bd, B);
        assertEquals(Cd, C);
    }

    public void testMatrixTransABmultAddDense() {
        int m = A.numColumns(), k = A.numRows(), n = Utilities.getInt(1, max);
        Matrix B = Matrices.random(n, k), C = Matrices.random(m, n);
        double[][] Bd = Matrices.getArray(B), Cd = Matrices.getArray(C);
        double alpha = Math.random();

        C = A.transABmultAdd(alpha, B, C);
        Cd = transABmultAdd(Ad, alpha, Bd, Cd);

        assertEquals(Ad, A);
        assertEquals(Bd, B);
        assertEquals(Cd, C);
    }

    public void testMatrixTransABmultAdd() {
        int m = A.numColumns(), k = A.numRows(), n = Utilities.getInt(1, max);
        Matrix B = Matrices.synchronizedMatrix(Matrices.random(n, k)), C = Matrices
                .synchronizedMatrix(Matrices.random(m, n));
        double[][] Bd = Matrices.getArray(B), Cd = Matrices.getArray(C);
        double alpha = Math.random();

        C = A.transABmultAdd(alpha, B, C);
        Cd = transABmultAdd(Ad, alpha, Bd, Cd);

        assertEquals(Ad, A);
        assertEquals(Bd, B);
        assertEquals(Cd, C);
    }

    public void testMatrixTransBmultAddDense() {
        int m = A.numRows(), k = A.numColumns(), n = Utilities.getInt(1, max);
        Matrix B = Matrices.random(n, k), C = Matrices.random(m, n);
        double[][] Bd = Matrices.getArray(B), Cd = Matrices.getArray(C);
        double alpha = Math.random();

        C = A.transBmultAdd(alpha, B, C);
        Cd = transBmultAdd(Ad, alpha, Bd, Cd);

        assertEquals(Ad, A);
        assertEquals(Bd, B);
        assertEquals(Cd, C);
    }

    public void testMatrixTransBmultAdd() {
        int m = A.numRows(), k = A.numColumns(), n = Utilities.getInt(1, max);
        Matrix B = Matrices.synchronizedMatrix(Matrices.random(n, k)), C = Matrices
                .synchronizedMatrix(Matrices.random(m, n));
        double[][] Bd = Matrices.getArray(B), Cd = Matrices.getArray(C);
        double alpha = Math.random();

        C = A.transBmultAdd(alpha, B, C);
        Cd = transBmultAdd(Ad, alpha, Bd, Cd);

        assertEquals(Ad, A);
        assertEquals(Bd, B);
        assertEquals(Cd, C);
    }

    protected double[][] rank2(double[][] Ad, double alpha, double[][] Bd,
            double[][] Cd) {
        return transBmultAdd(Bd, alpha, Cd, transBmultAdd(Cd, alpha, Bd, Ad));
    }

    protected double[][] transRank2(double[][] Ad, double alpha, double[][] Bd,
            double[][] Cd) {
        return transAmultAdd(Bd, alpha, Cd, transAmultAdd(Cd, alpha, Bd, Ad));
    }

    protected double[][] rank1(double[][] Ad, double alpha, double[][] Cd) {
        return transBmultAdd(Cd, alpha, Cd, Ad);
    }

    protected double[][] transRank1(double[][] Ad, double alpha, double[][] Cd) {
        return transAmultAdd(Cd, alpha, Cd, Ad);
    }

    public void testVectorRank2Dense() {
        if (A.isSquare()) {
            double alpha = Math.random();
            assertEquals(rank2(alpha, xdR, ydR), A.rank2(alpha, xDenseR,
                    yDenseR));
        }
    }

    public void testVectorRank2() {
        if (A.isSquare()) {
            double alpha = Math.random();
            assertEquals(rank2(alpha, xdR, ydR), A.rank2(alpha, xR, yR));
        }
    }

    public void testVectorRank1Dense() {
        if (A.isSquare()) {
            double alpha = Math.random();
            assertEquals(rank1(alpha, xdR, ydR), A.rank1(alpha, xDenseR,
                    yDenseR));
        }
    }

    public void testVectorRank1() {
        if (A.isSquare()) {
            double alpha = Math.random();
            assertEquals(rank1(alpha, xdR, ydR), A.rank1(alpha, xR, yR));
        }
    }

    protected double[][] rank2(double alpha, double[] xd, double[] yd) {
        rank1(alpha, xd, yd);
        rank1(alpha, yd, xd);
        return Ad;
    }

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

    public void testVectorTransMultAddDense() {
        double alpha = Math.random();
        assertEquals(transMultAdd(alpha, xdR, ydC), A.transMultAdd(alpha,
                xDenseR, yDenseC));
        assertEquals(Ad, A);
        assertEquals(xdR, xDenseR);
        assertEquals(ydC, yDenseC);
    }

    public void testVectorTransMultAdd() {
        double alpha = Math.random();
        assertEquals(transMultAdd(alpha, xdR, ydC), A.transMultAdd(alpha, xR,
                yC));
        assertEquals(Ad, A);
        assertEquals(xdR, xR);
        assertEquals(ydC, yC);
    }

    protected double[] transMultAdd(double alpha, double[] xd, double[] yd) {
        int rows = Ad.length, cols = 0;
        if (rows > 0)
            cols = Ad[0].length;

        for (int j = 0; j < cols; ++j) {
            double dot = 0;
            for (int i = 0; i < rows; ++i)
                dot += Ad[i][j] * xd[i];
            yd[j] += alpha * dot;
        }

        return yd;
    }

    public void testVectorMultDense() {
        double alpha = Math.random();
        assertEquals(mult(alpha, xdC, ydR), A.mult(alpha, xDenseC, yDenseR));
        assertEquals(Ad, A);
        assertEquals(xdC, xDenseC);
        assertEquals(ydR, yDenseR);
    }

    public void testVectorMult() {
        double alpha = Math.random();
        assertEquals(mult(alpha, xdC, ydR), A.mult(alpha, xC, yR));
        assertEquals(Ad, A);
        assertEquals(xdC, xC);
        assertEquals(ydR, yR);
    }

    protected double[] mult(double alpha, double[] xd, double[] yd) {
        for (int i = 0; i < Ad.length; ++i) {
            double dot = 0;
            for (int j = 0; j < Ad[i].length; ++j)
                dot += Ad[i][j] * xd[j];
            yd[i] = alpha * dot;
        }
        return yd;
    }

    public void testVectorMultAddDense() {
        double alpha = Math.random();
        assertEquals(multAdd(Ad, alpha, xdC, ydR), A.multAdd(alpha, xDenseC,
                yDenseR));
        assertEquals(Ad, A);
        assertEquals(xdC, xDenseC);
        assertEquals(ydR, yDenseR);
    }

    public void testVectorMultAdd() {
        double alpha = Math.random();
        assertEquals(multAdd(Ad, alpha, xdC, ydR), A.multAdd(alpha, xC, yR));
        assertEquals(Ad, A);
        assertEquals(xdC, xC);
        assertEquals(ydR, yR);
    }

    protected double[] multAdd(double[][] Ad, double alpha, double[] xd,
            double[] yd) {
        for (int i = 0; i < Ad.length; ++i) {
            double dot = 0;
            for (int j = 0; j < Ad[i].length; ++j)
                dot += Ad[i][j] * xd[j];
            yd[i] += alpha * dot;
        }

        return yd;
    }

    protected double[][] mult(double[][] Ad, double alpha, double[][] Bd,
            double[][] Cd) {
        int m = Cd.length, n = 0, k = Bd.length;
        if (k > 0)
            n = Bd[0].length;

        Utilities.zero(Cd);

        for (int j = 0; j < n; ++j)
            for (int l = 0; l < k; ++l)
                for (int i = 0; i < m; ++i)
                    Cd[i][j] += alpha * Ad[i][l] * Bd[l][j];

        return Cd;
    }

    protected double[][] transAmult(double[][] Ad, double alpha, double[][] Bd,
            double[][] Cd) {
        int m = Cd.length, n = 0, k = Bd.length;
        if (k > 0)
            n = Bd[0].length;

        for (int j = 0; j < n; ++j)
            for (int i = 0; i < m; ++i) {
                double temp = 0;
                for (int l = 0; l < k; ++l)
                    temp += Ad[l][i] * Bd[l][j];
                Cd[i][j] = alpha * temp;
            }

        return Cd;
    }

    protected double[][] transBmult(double[][] Ad, double alpha, double[][] Bd,
            double[][] Cd) {
        int m = Cd.length, n = Bd.length, k = 0;
        if (n > 0)
            k = Bd[0].length;

        Utilities.zero(Cd);

        for (int j = 0; j < n; ++j) {
            for (int l = 0; l < k; ++l)
                for (int i = 0; i < m; ++i)
                    Cd[i][j] += alpha * Ad[i][l] * Bd[j][l];
        }

        return Cd;
    }

    protected double[][] transABmult(double[][] Ad, double alpha,
            double[][] Bd, double[][] Cd) {
        int m = Cd.length, n = Bd.length, k = 0;
        if (n > 0)
            k = Bd[0].length;

        for (int j = 0; j < n; ++j)
            for (int i = 0; i < m; ++i) {
                double temp = 0;
                for (int l = 0; l < k; ++l)
                    temp += Ad[l][i] * Bd[j][l];
                Cd[i][j] = alpha * temp;
            }

        return Cd;
    }

    protected double[][] multAdd(double[][] Ad, double alpha, double[][] Bd,
            double[][] Cd) {
        int m = Cd.length, n = 0, k = Bd.length;
        if (k > 0)
            n = Bd[0].length;

        for (int j = 0; j < n; ++j)
            for (int l = 0; l < k; ++l)
                for (int i = 0; i < m; ++i)
                    Cd[i][j] += alpha * Ad[i][l] * Bd[l][j];

        return Cd;
    }

    protected double[][] transAmultAdd(double[][] Ad, double alpha,
            double[][] Bd, double[][] Cd) {
        int m = Cd.length, n = 0, k = Bd.length;
        if (k > 0)
            n = Bd[0].length;

        for (int j = 0; j < n; ++j)
            for (int i = 0; i < m; ++i) {
                double temp = 0;
                for (int l = 0; l < k; ++l)
                    temp += Ad[l][i] * Bd[l][j];
                Cd[i][j] += alpha * temp;
            }

        return Cd;
    }

    protected double[][] transBmultAdd(double[][] Ad, double alpha,
            double[][] Bd, double[][] Cd) {
        int m = Cd.length, n = Bd.length, k = 0;
        if (n > 0)
            k = Bd[0].length;

        for (int j = 0; j < n; ++j)
            for (int l = 0; l < k; ++l)
                for (int i = 0; i < m; ++i)
                    Cd[i][j] += alpha * Ad[i][l] * Bd[j][l];

        return Cd;
    }

    protected double[][] transABmultAdd(double[][] Ad, double alpha,
            double[][] Bd, double[][] Cd) {
        int m = Cd.length, n = Bd.length, k = 0;
        if (n > 0)
            k = Bd[0].length;

        for (int j = 0; j < n; ++j)
            for (int i = 0; i < m; ++i) {
                double temp = 0;
                for (int l = 0; l < k; ++l)
                    temp += Ad[l][i] * Bd[j][l];
                Cd[i][j] += alpha * temp;
            }

        return Cd;
    }

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

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

    /**
     * Tests <code>A = A + 1*B</code>
     */
    public void testOneMatrixAdd() {
        A = A.add(1, B);