Examples of org.ejml.data.DenseMatrix64F

org.ejml.data.DenseMatrix64F

DenseMatrix64F is a dense matrix with elements that are 64-bit floats (doubles). A matrix is the fundamental data structure in linear algebra. Unlike a sparse matrix, there is no compression in a dense matrix and every element is stored in memory. This allows for fast reads and writes to the matrix.

To keep the code manageable and the library easier to use only basic functions for accessing and editing elements are provided in this class. The numerous operations which can be performed on DenseMatrix64F are contained in various other classes, where the most common operations can be found in the {@link org.ejml.ops.CommonOps} and {@link org.ejml.ops.SpecializedOps} classes.

The matrix is stored internally in a row-major 1D array format:

data[ y*numCols + x ] = data[y][x]

For example:
data =

a₁₁ a₁₂ a₁₃ a₁₄ a₂₁ a₂₂ a₂₃ a₂₄ a₃₁ a₃₂ a₃₃ a₃₄ a₄₁ a₄₂ a₄₃ a₄₄

An alternative to working directly with DenseMatrix64 is {@link org.ejml.simple.SimpleMatrix}. SimpleMatrix is a wrapper around DenseMatrix64F that provides an easier to use object oriented way of manipulating matrices, at the cost of efficiency.
@see org.ejml.ops.CommonOps @see org.ejml.ops.SpecializedOps @see org.ejml.simple.SimpleMatrix @author Peter Abeles

        if( !prefComputeV )
            throw new IllegalArgumentException("As requested V was not computed.");
        if( transpose )
            return Vt;


        V = new DenseMatrix64F(Vt.numCols,Vt.numRows);
        CommonOps.transpose(Vt,V);


        return V;
    }

View Full Code Here

    @Test
    public void computeMediumSized() {
        Random rand = new Random(0xfff);


        for( int width = 5; width < 12; width++ ) {
            DenseMatrix64F A = RandomMatrices.createRandom(width,width,rand);


            LUDecompositionAlt lu = new LUDecompositionAlt();
            lu.decompose(A);


            double luVal = lu.computeDeterminant();


            DeterminantFromMinor minor = new DeterminantFromMinor(width);
            double minorVal = minor.compute(new DenseMatrix64F(width,width, true, A.data));


            assertEquals(luVal,minorVal,1e-6);
        }
    }

View Full Code Here

        assertTrue(MatrixFeatures.isIdentical(expected,found,1e-8));
    }


    @Test
    public void solveTranL() {
        DenseMatrix64F L = createRandomLowerTriangular();


        DenseMatrix64F B = RandomMatrices.createRandom(3,1,rand);
        DenseMatrix64F expected = RandomMatrices.createRandom(3,1,rand);
        DenseMatrix64F found = B.copy();


        TriangularSolver.solveTranL(L.data,found.data,3);


        CommonOps.transpose(L);
        DenseMatrix64F L_inv = L.copy();
        UnrolledInverseFromMinor.inv(L_inv,L_inv);
        CommonOps.mult(L_inv,B,expected);


        assertTrue(MatrixFeatures.isIdentical(expected,found,1e-8));
    }

View Full Code Here

    public void testMultipleCalls() {
        Random rand = new Random(0xfff);


        int width = 6;


        DenseMatrix64F A = RandomMatrices.createRandom(width,width,rand);


        DeterminantFromMinor minor = new DeterminantFromMinor(width);
        double first = minor.compute(A);
        double second = minor.compute(A);


        assertEquals(first,second,1e-10);


        // does it produce the same results for a different matrix?
        DenseMatrix64F B = RandomMatrices.createRandom(width,width,rand);
        double third = minor.compute(B);


        assertFalse(first==third);


        // make sure it has a valid result the third time

View Full Code Here

    /**
     * See if it can invert a matrix that is known to be invertable.
     */
    @Test
    public void invert() {
        DenseMatrix64F A = new DenseMatrix64F(3,3, true, 0, 1, 2, -2, 4, 9, 0.5, 0, 5);
        DenseMatrix64F A_inv = RandomMatrices.createRandom(3,3,rand);


        LUDecompositionAlt decomp = new LUDecompositionAlt();
        LinearSolver solver = new LinearSolverLu(decomp);


        solver.setA(A);
        InvertUsingSolve.invert(solver,A,A_inv);


        DenseMatrix64F I = RandomMatrices.createRandom(3,3,rand);


        CommonOps.mult(A,A_inv,I);


        for( int i = 0; i < I.numRows; i++ ) {
            for( int j = 0; j < I.numCols; j++ ) {
                if( i == j )
                    assertEquals(1,I.get(i,j),tol);
                else
                    assertEquals(0,I.get(i,j),tol);
            }
        }
    }

View Full Code Here

    public DenseMatrix64F getW( DenseMatrix64F W ) {
        int m = compact ? numSingular : numRows;
        int n = compact ? numSingular : numCols;


        if( W == null )
            W = new DenseMatrix64F(m,n);
        else {
            W.reshape(m,n, false);
            W.zero();
        }

View Full Code Here

        assertTrue(MatrixFeatures.isIdentical(expected,found,1e-8));
    }


    @Test
    public void solveU() {
        DenseMatrix64F U = RandomMatrices.createRandom(3,3,rand);
        for( int i = 0; i < U.numRows; i++ ) {
            for( int j = 0; j < i; j++ ) {
                U.set(i,j,0);
            }
        }


        DenseMatrix64F U_inv = U.copy();
        UnrolledInverseFromMinor.inv(U_inv,U_inv);


        DenseMatrix64F B = RandomMatrices.createRandom(3,1,rand);
        DenseMatrix64F expected = RandomMatrices.createRandom(3,1,rand);
        DenseMatrix64F found = B.copy();


        TriangularSolver.solveU(U.data,found.data,3);
        CommonOps.mult(U_inv,B,expected);


        assertTrue(MatrixFeatures.isIdentical(expected,found,1e-8));

View Full Code Here

        long pointC = System.currentTimeMillis();


        System.out.println("  bidiag UV "+(pointB-pointA)+" qr UV "+(pointC-pointB));


        if( transposed ) {
            DenseMatrix64F temp = Vt;
            Vt = Ut;
            Ut = temp;
        }
        return false;
    }

View Full Code Here


    @Test
    public void solveU_submatrix() {


        // create U and B.  Insert into a larger matrix
        DenseMatrix64F U_orig = RandomMatrices.createRandom(3,3,rand);
        for( int i = 0; i < U_orig.numRows; i++ ) {
            for( int j = 0; j < i; j++ ) {
                U_orig.set(i,j,0);
            }
        }
        DenseMatrix64F U = new DenseMatrix64F(6,7);
        CommonOps.insert(U_orig,U,2,3);
        
        
        DenseMatrix64F B_orig = RandomMatrices.createRandom(3,2,rand);


        DenseMatrix64F B = new DenseMatrix64F(4,5);
        CommonOps.insert(B_orig,B,1,2);
        
        // compute expected solution
        DenseMatrix64F U_inv = U_orig.copy();
        UnrolledInverseFromMinor.inv(U_inv,U_inv);


        DenseMatrix64F expected = RandomMatrices.createRandom(3,2,rand);


        int startU = 2*U.numCols+3;
        int strideU = U.numCols;
        int widthU = U_orig.numCols;
        int startB = 1*B.numCols+2;
        int strideB = B.numCols;
        int widthB = B_orig.numCols;
        TriangularSolver.solveU(U.data,startU,strideU,widthU,B.data,startB,strideB,widthB);


        DenseMatrix64F found = CommonOps.extract(B,1,4,2,4);
        CommonOps.mult(U_inv,B_orig,expected);


        assertTrue(MatrixFeatures.isIdentical(expected,found,1e-8));
    }

View Full Code Here

     * Uses the decomposition returned from octave, which uses LAPACK
     */
    @Test
    public void testDecomposition()
    {
        DenseMatrix64F A = new DenseMatrix64F(3,3, true, 5, 2, 3, 1.5, -2, 8, -3, 4.7, -0.5);


        DenseMatrix64F octLower = new DenseMatrix64F(3,3, true, 1, 0, 0, -0.6, 1, 0, 0.3, -0.44068, 1);
        DenseMatrix64F octUpper = new DenseMatrix64F(3,3, true, 5, 2, 3, 0, 5.9, 1.3, 0, 0, 7.67288);


        LUDecomposition<DenseMatrix64F> alg = create(3,3);
        assertTrue(alg.decompose(A));


        assertFalse(alg.isSingular());


        SimpleMatrix L = SimpleMatrix.wrap(alg.getLower(null));
        SimpleMatrix U = SimpleMatrix.wrap(alg.getUpper(null));
        SimpleMatrix P = SimpleMatrix.wrap(alg.getPivot(null));


        EjmlUnitTests.assertEquals(octLower,L.getMatrix(),1e-5);
        EjmlUnitTests.assertEquals(octUpper,U.getMatrix(),1e-5);


        DenseMatrix64F A_found = P.mult(L).mult(U).getMatrix();
        assertTrue(MatrixFeatures.isIdentical(A_found,A,1e-8));
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.ejml.data.DenseMatrix64F

fr.lip6.jkernelmachines.util.algebra.ejml.EJMLMatrixOperations

org.ejml.alg.block.BenchmarkBlockTranspose

org.ejml.alg.block.BlockMatrixOps

org.ejml.alg.block.decomposition.chol.TestBlockCholeskyOuterForm

org.ejml.alg.block.decomposition.chol.TestBlockInnerCholesky

org.ejml.alg.block.decomposition.hessenberg.TestTridiagonalBlockHelper

org.ejml.alg.block.decomposition.qr.TestBlockHouseHolder

org.ejml.alg.block.linsol.chol.TestBlockCholeskyOuterSolver

org.ejml.alg.block.TestBlockInnerTriangularSolver

org.ejml.alg.block.TestBlockMatrixOps

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.