Example usage for org.apache.commons.math.linear BlockRealMatrix getRowDimension

Introduction

In this page you can find the example usage for org.apache.commons.math.linear BlockRealMatrix getRowDimension.

Prototype

@Override
public int getRowDimension() 

Source Link

Usage

From source file:org.mitre.math.linear.RandomMatrixExample.java

public int run(String args[]) throws Exception {

    int m = 100;/*from  ww w .ja  va2s .c  o m*/
    int n = 60;
    boolean generate = false;

    ArrayList<String> other_args = new ArrayList<String>();
    for (int i = 0; i < args.length; ++i) {
        try {
            if ("-r".equals(args[i])) {
                m = Integer.parseInt(args[++i]);
            } else if ("-c".equals(args[i])) {
                n = Integer.parseInt(args[++i]);
            } else if ("-g".equals(args[i])) {
                generate = true;
            } else {
                other_args.add(args[i]);
            }
        } catch (NumberFormatException ex) {
            System.out.println("ERROR: Integer expected instead of " + args[i]);
            return -1;
        } catch (ArrayIndexOutOfBoundsException except) {
            System.out.println("ERROR: Required parameter missing from " + args[i - 1]);
            return -1;
        }

    }

    if (generate) {
        LOG.info(String.format("Generating random %dx%d matrix '%s'", m, n, other_args.get(0)));
        return this.generateRandomMatrix(other_args.get(1), m, n);
    }

    LOG.info(String.format("Making random matrix %d}x%d", m, n));
    double[][] M = this.randomMatrixVariables(m, n);

    LOG.info(String.format("Creating Array2DRowRealMatrix from random matrix %dx%d", m, n));
    Array2DRowRealMatrix arm = new Array2DRowRealMatrix(M);

    LOG.info(String.format("Creating BlockRealMatrix from random matrix %dx%d", m, n));
    BlockRealMatrix brm = new BlockRealMatrix(M);

    LOG.info(String.format("Checking Array2DRow and BlockRealMatrix"));
    if (!this.compareMatrices(arm, brm)) {
        LOG.fatal("One of these are not like the other!");
    }

    LOG.info(String.format("Creating BufferRealMatrix %dx%d", m, n));
    BufferRealMatrix mbrm = new BufferRealMatrix(m, n, null);

    LOG.info(String.format("Populating BufferRealMatrix %dx%d from random matrix", m, n));
    //mbrm.walkInOptimizedOrder(new PopulateMatrixChangingVisitor(brm));
    /**/
    // not the speedest use walkInOptimizedOrder!
    for (int i = 0; i < brm.getRowDimension(); i++) {
        for (int j = 0; j < brm.getColumnDimension(); j++) {
            mbrm.setEntry(i, j, brm.getEntry(i, j));
        }
    }
    //  System.err.println(this.matrix2String(mbrm, n, 8));

    LOG.info("Checking block matrix verse buffer matrix...");
    mbrm.walkInOptimizedOrder(new ComparingPreservingVisitor(brm));

    LOG.info("Checking matrix addition...");
    BlockRealMatrix brm2 = brm.add(new BlockRealMatrix(M));
    BufferRealMatrix mbrm_tmp = new BufferRealMatrix(m, n, null);
    mbrm_tmp.walkInOptimizedOrder(new PopulateMatrixChangingVisitor(brm));
    BufferRealMatrix mbrm2 = mbrm.add(mbrm_tmp);
    mbrm2.walkInOptimizedOrder(new ComparingPreservingVisitor(brm2));

    LOG.info("Checking matrix multiplication (none are numerically stable to the final decimal places)...");
    BlockRealMatrix brm_tmp = new BlockRealMatrix(n, m);
    brm_tmp.walkInOptimizedOrder(new RandomRealMatrixChangingVisitor());
    LOG.info("Starting BlockRealMatrix Multiplication");
    brm2 = brm.multiply(brm_tmp);
    LOG.info("Finished BlockRealMatrix Multiplication");

    mbrm_tmp = new BufferRealMatrix(n, m, null);
    mbrm_tmp.walkInOptimizedOrder(new PopulateMatrixChangingVisitor(brm_tmp));
    LOG.info("Starting BufferRealMatrix Multiplication");
    mbrm2 = mbrm.multiply(mbrm_tmp);
    LOG.info("Finished BufferRealMatrix Multiplication");
    LOG.info("Checking BlockRealMatrix to BufferRealMatrix");
    mbrm2.walkInOptimizedOrder(new ComparingPreservingVisitor(brm2));

    final int bufferBlockLength = BufferRealMatrix.BLOCK_SIZE;
    int startRow = m / 2;
    int endRow = m - 1;
    int startColumn = n / 2;
    int endColumn = n - 1;
    LOG.debug(String.format("Checking getting buffer submatrix (%d,%d) to (%d,%d)", startRow, startColumn,
            endRow, endColumn));
    double[][] sub = mbrm.getSubMatrixData(startRow, endRow, startColumn, endColumn);
    LOG.info(String.format("Found %f at submatrix 0,0 and %f for %d,%d", sub[0][0],
            mbrm.getEntry(startRow, startColumn), startRow, startColumn));

    LOG.info("Allocation testing, doubling size each iteration");
    int am = m;
    int an = n;
    LOG.info("Starting allocating BlockRealMatrices....");
    try {
        while (true) {
            am *= 2;
            an *= 2;
            BlockRealMatrix t = new BlockRealMatrix(am, an);
        }
    } catch (OutOfMemoryError e) {
        LOG.info(String.format("Ran out of memory generating %dx%d matrix", am, an));
    }

    LOG.info("Creating BufferRealMatrix at last attempted in size...");
    File file = new File(this.localTmpFile());
    BufferRealMatrix t = new BufferRealMatrix(am, an, file);

    // slow way need to optimize for blocks
    t.walkInOptimizedOrder(new RandomRealMatrixChangingVisitor());

    LOG.info(String.format("(0,2) = %f", t.getEntry(0, 2)));

    t = null;
    LOG.info("Attempting to reload matrix");
    BufferRealMatrix rt = BufferRealMatrix.loadMatrix(file);
    LOG.info(String.format("reloaded (0,2) = %f", rt.getEntry(0, 2)));

    return 0;
}

---