Examples of org.ejml.simple.SimpleMatrix

org.ejml.simple.SimpleMatrix
nist.gov/javanumerics/jama/
@author Peter Abeles


  /**
   * Applies tanh to each of the entries in the matrix.  Returns a new matrix.
   */
  public static SimpleMatrix elementwiseApplyTanh(SimpleMatrix input) {
    SimpleMatrix output = new SimpleMatrix(input);
    for (int i = 0; i < output.numRows(); ++i) {
      for (int j = 0; j < output.numCols(); ++j) {
        output.set(i, j, Math.tanh(output.get(i, j)));
      }
    }
    return output;
  }

View Full Code Here


  /**
   * Applies the derivative of tanh to each of the elements in the vector.  Returns a new matrix.
   */
  public static SimpleMatrix elementwiseApplyTanhDerivative(SimpleMatrix input) {
    SimpleMatrix output = new SimpleMatrix(input.numRows(), input.numCols());
    output.set(1.0);
    output = output.minus(input.elementMult(input));
    return output;
  }

View Full Code Here

      size += vector.numRows();
    }
    // one extra for the bias
    size++;


    SimpleMatrix result = new SimpleMatrix(size, 1);
    int index = 0;
    for (SimpleMatrix vector : vectors) {
      result.insertIntoThis(index, 0, vector);
      index += vector.numRows();
    }
    result.set(index, 0, 1.0);
    return result;
  }

View Full Code Here

    int size = 0;
    for (SimpleMatrix vector : vectors) {
      size += vector.numRows();
    }


    SimpleMatrix result = new SimpleMatrix(size, 1);
    int index = 0;
    for (SimpleMatrix vector : vectors) {
      result.insertIntoThis(index, 0, vector);
      index += vector.numRows();
    }
    return result;
  }

View Full Code Here


  /**
   * Returns a vector with random Gaussian values, mean 0, std 1
   */
  public static SimpleMatrix randomGaussian(int numRows, int numCols, Random rand) {
    SimpleMatrix result = new SimpleMatrix(numRows, numCols);
    for (int i = 0; i < numRows; ++i) {
      for (int j = 0; j < numCols; ++j) {
        result.set(i, j, rand.nextGaussian());
      }
    }
    return result;
  }

View Full Code Here

    /**
     * Creates a random SVD that is highly unlikely to be in the correct order.  Adjust its order
     * and see if it produces the same matrix.
     */
    private void testDescendingOrder(int numRows, int numCols, boolean compact, boolean testArray ) {
        SimpleMatrix U,W,V;


        int minLength = Math.min(numRows,numCols);
        double singularValues[] = new double[minLength];


        if( compact ) {
            U = SimpleMatrix.wrap(RandomMatrices.createOrthogonal(numRows,minLength,rand));
            W = SimpleMatrix.wrap(RandomMatrices.createDiagonal(minLength,minLength,0,1,rand));
            V = SimpleMatrix.wrap(RandomMatrices.createOrthogonal(numCols,minLength,rand));
        } else {
            U = SimpleMatrix.wrap(RandomMatrices.createOrthogonal(numRows,numRows,rand));
            W = SimpleMatrix.wrap(RandomMatrices.createDiagonal(numRows,numCols,0,1,rand));
            V = SimpleMatrix.wrap(RandomMatrices.createOrthogonal(numCols,numCols,rand));
        }


        // Compute A
        SimpleMatrix A=U.mult(W).mult(V.transpose());


        // extract array of singular values
        for( int i = 0; i < singularValues.length; i++ )
            singularValues[i] = W.get(i,i);
        
        // put into descending order
        if( testArray ) {
            SingularOps.descendingOrder(U.getMatrix(),false,singularValues,minLength,V.getMatrix(),false);
            // put back into W
            for( int i = 0; i < singularValues.length; i++ )
                W.set(i,i,singularValues[i]);
        } else {
            SingularOps.descendingOrder(U.getMatrix(),false,W.getMatrix(),V.getMatrix(),false);
        }


        // see if it changed the results
        SimpleMatrix A_found = U.mult(W).mult(V.transpose());


        assertTrue(A.isIdentical(A_found,1e-8));


        // make sure singular values are descending
        if( testArray ) {

View Full Code Here

    /**
     * Use the transpose flags and see what happens
     */
    private void testDescendingInputTransposed(int numRows, int numCols,
                                               boolean tranU , boolean tranV , boolean testArray ) {
        SimpleMatrix U,S,V;


        int minLength = Math.min(numRows,numCols);
        double singularValues[] = new double[minLength];


        U = SimpleMatrix.wrap(RandomMatrices.createOrthogonal(numRows,minLength,rand));
        S = SimpleMatrix.wrap(RandomMatrices.createDiagonal(minLength,minLength,0,1,rand));
        V = SimpleMatrix.wrap(RandomMatrices.createOrthogonal(numCols,minLength,rand));


        // Compute A
        SimpleMatrix A=U.mult(S).mult(V.transpose());


        // extract array of singular values
        for( int i = 0; i < singularValues.length; i++ )
            singularValues[i] = S.get(i,i);


        // put into ascending order
        if( tranU ) U = U.transpose();
        if( tranV ) V = V.transpose();


        // put into descending order
        if( testArray ) {
            SingularOps.descendingOrder(U.getMatrix(),tranU,singularValues,minLength,V.getMatrix(),tranV);
            // put back into S
            for( int i = 0; i < singularValues.length; i++ )
                S.set(i,i,singularValues[i]);
        } else {
            SingularOps.descendingOrder(U.getMatrix(),tranU,S.getMatrix(),V.getMatrix(),tranV);
        }


        // see if it changed the results
        if( tranU ) U = U.transpose();
        if( tranV ) V = V.transpose();
        SimpleMatrix A_found = U.mult(S).mult(V.transpose());


        assertTrue(A.isIdentical(A_found,1e-8));


        // make sure singular values are descending
        if( testArray ) {

View Full Code Here

    public void descendingOrder_NaN() {
        int numRows = 5;
        int numCols = 7;
        int minLength = Math.min(numRows,numCols);


        SimpleMatrix U,S,V;


        U = SimpleMatrix.wrap(RandomMatrices.createOrthogonal(numRows,minLength,rand));
        S = SimpleMatrix.wrap(RandomMatrices.createDiagonal(minLength,minLength,0,1,rand));
        V = SimpleMatrix.wrap(RandomMatrices.createOrthogonal(numCols,minLength,rand));


        // put in a NaN
        S.set(2,2,Double.NaN);


        SingularOps.descendingOrder(U.getMatrix(),false,S.getMatrix(),V.getMatrix(),false);


        assertTrue( Double.isNaN(S.get(minLength-1,minLength-1)));


        // put in an Inf
        S.set(2,2,Double.POSITIVE_INFINITY);


        SingularOps.descendingOrder(U.getMatrix(),false,S.getMatrix(),V.getMatrix(),false);


        assertTrue( Double.isInfinite(S.get(0,0)));
    }

View Full Code Here

    public void nullVector() {
        for( int numRows = 2; numRows < 10; numRows++ ) {
            for( int numCols = 2; numCols < 10; numCols++ ) {
                // construct a matrix with a null space by decomposition a random matrix
                // and setting one of its singular values to zero
                SimpleMatrix A = SimpleMatrix.wrap(RandomMatrices.createRandom(numRows,numCols,rand));


                SingularValueDecomposition<DenseMatrix64F> svd = DecompositionFactory.svd(A.numRows(), A.numCols(),true,true,false);
                assertTrue(svd.decompose(A.getMatrix()));


                SimpleMatrix U = SimpleMatrix.wrap(svd.getU(null,false));
                SimpleMatrix S = SimpleMatrix.wrap(svd.getW(null));
                SimpleMatrix Vt = SimpleMatrix.wrap(svd.getV(null,true));


                // pick an element inconveniently in the middle to be the null space
                S.set(1,1,0);
                svd.getSingularValues()[1] = 0;


                A=U.mult(S).mult(Vt);


                // Find the right null space
                SimpleMatrix v = SimpleMatrix.wrap(SingularOps.nullVector(svd, true , null));


                // see if the returned vector really is the null space
                SimpleMatrix ns = A.mult(v);


                for( int i = 0; i < ns.numRows(); i++ ) {
                    assertEquals(0,ns.get(i),1e-8);
                }


                // Find the left null space
                v = SimpleMatrix.wrap(SingularOps.nullVector(svd, false , null));


                // see if the returned vector really is the null space
                ns = v.transpose().mult(A);


                for( int i = 0; i < ns.numRows(); i++ ) {
                    assertEquals(0,ns.get(i),1e-8);
                }
            }
        }
    }

View Full Code Here

        for( int numRows = 2; numRows < 5; numRows++ ) {
            for( int numCols = 2; numCols < 5; numCols++ ) {


                // construct a matrix with a null space by decomposition a random matrix
                // and setting one of its singular values to zero
                SimpleMatrix A = SimpleMatrix.wrap(RandomMatrices.createRandom(numRows,numCols,rand));


                SingularValueDecomposition<DenseMatrix64F> svd = DecompositionFactory.svd(A.numRows(), A.numCols(),true,true,false);
                assertTrue(svd.decompose(A.getMatrix()));


                SimpleMatrix U = SimpleMatrix.wrap(svd.getU(null,false));
                SimpleMatrix S = SimpleMatrix.wrap(svd.getW(null));
                SimpleMatrix Vt = SimpleMatrix.wrap(svd.getV(null,true));


                // pick an element inconveniently in the middle to be the null space
                S.set(1,1,0);
                svd.getSingularValues()[1] = 0;


                A=U.mult(S).mult(Vt);


                // now find the null space
                SimpleMatrix ns = SimpleMatrix.wrap(SingularOps.nullSpace(svd,null,1e-15));


                // make sure the null space is not all zero
                assertTrue( Math.abs(CommonOps.elementMaxAbs(ns.getMatrix())) > 0 );


                // check the null space's size
                assertEquals(ns.numRows(),A.numCols());
                assertEquals(ns.numCols(),1+Math.max(numCols-numRows,0));


                // see if the results are null
                SimpleMatrix found = A.mult(ns);
                assertTrue( Math.abs(CommonOps.elementMaxAbs(found.getMatrix())) <= 1e-15 );
            }
        }
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.ejml.simple.SimpleMatrix

com.sketchingbits.mlearning.clustering.KMeans

edu.stanford.nlp.neural.Embedding

edu.stanford.nlp.neural.EmbeddingITest

edu.stanford.nlp.neural.NeuralUtils

edu.stanford.nlp.neural.NeuralUtilsTest

edu.stanford.nlp.neural.SimpleTensor

edu.stanford.nlp.parser.dvparser.AverageDVModels

edu.stanford.nlp.parser.dvparser.DumpMatrices

edu.stanford.nlp.parser.dvparser.DVModel

edu.stanford.nlp.parser.dvparser.DVParserCostAndGradient

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.