Example usage for org.apache.commons.math3.linear BlockRealMatrix getEntry

Introduction

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

Prototype

@Override
public double getEntry(final int row, final int column) throws OutOfRangeException 

Source Link

Usage

From source file:jmbench.PackageMatrixConversion.java

public static void convertToEjml(final BlockRealMatrix src, final DenseMatrix64F dst) {
    if ((src.getRowDimension() != dst.getNumRows()) || (src.getColumnDimension() != dst.getNumCols())) {
        throw new IllegalArgumentException("Matrices are not the same shape");
    }/*  w w w . j a v a  2s.com*/

    for (int y = 0; y < src.getRowDimension(); y++) {
        for (int x = 0; x < src.getColumnDimension(); x++) {
            dst.set(y, x, src.getEntry(y, x));
        }
    }
}

---

From source file:gamlss.utilities.MatrixFunctions.java

/**
 * Prints matrix values in the console.//from   w w  w.j  a v  a  2 s  .c om
 * @param m - matrix to print
 */
public static void matrixPrint(final BlockRealMatrix m) {
    for (int i = 0; i < m.getRowDimension(); i++) {
        for (int j = 0; j < m.getColumnDimension(); j++) {
            System.out.print(m.getEntry(i, j));
            System.out.print(" ");
        }
        System.out.println();
    }
    System.out.println(" ");
}

---

From source file:gamlss.utilities.MatrixFunctions.java

/**
 * if the length of the return matrix is zero,
 *  then the diff was not completed properly.
 *  @param data - matrix/*from   w ww .ja  va2 s .co m*/
 *  @return - matrix
 */
private static BlockRealMatrix getDiff(final BlockRealMatrix data) {
    double[][] newdata = new double[data.getRowDimension() - 1][data.getColumnDimension()];
    for (int i = 0; i < newdata.length; i++) {
        for (int j = 0; j < newdata[i].length; j++) {
            newdata[i][j] = data.getEntry(i + 1, j) - data.getEntry(i, j);
        }
    }
    return new BlockRealMatrix(newdata);
}

---

From source file:gamlss.utilities.MatrixFunctions.java

/**
 * Get main diagonal of the matrix.//  w  w w .  j  a  va2 s . c om
 * @param m - matrix
 * @return main diagonal as vector
 */
public static ArrayRealVector getMainDiagonal(final BlockRealMatrix m) {
    double[] tempArr = new double[m.getRowDimension()];
    for (int i = 0; i < m.getColumnDimension(); i++) {
        for (int j = 0; j < m.getColumnDimension(); j++) {
            if (i == j) {
                tempArr[i] = m.getEntry(i, j);
            }
        }
    }
    return new ArrayRealVector(tempArr, false);
}

---

From source file:gamlss.utilities.MatrixFunctions.java

/**
 * Write matrix values to CSV file.//ww  w.j a va  2s .c o  m
 * @param cmd - path to the file
 * @param m - matrix to write
 */
public static void matrixWriteCSV(final String cmd, final BlockRealMatrix m) {
    try {
        // Create file 
        FileWriter fstream = new FileWriter(cmd, false);
        BufferedWriter out = new BufferedWriter(fstream);

        for (int i = 0; i < m.getRowDimension(); i++) {
            for (int j = 0; j < m.getColumnDimension(); j++) {
                out.write(Double.toString(m.getEntry(i, j)));
                if (j < m.getColumnDimension() - 1) {
                    out.append(',');
                }
            }
            out.newLine();
        }
        out.close();
    } catch (Exception e) { //Catch exception if any
        System.err.println("Error: " + e.getMessage());
    }
}

---

From source file:gamlss.smoothing.PB.java

/**
* Constructs the base matrix.//from   ww  w  . j  a v a2 s.co m
* @param colValues - values of the certain column of
*  the smooth matrix which corresponds to the 
*  currently fitting distribution parameter
* @return - base matrix
*/
//bbase <- function(x, xl, xr, ndx, deg, quantiles=FALSE)
private static BlockRealMatrix formX(final ArrayRealVector colValues) {

    //control$inter <- if (lx<99) 10 else control$inter # 
    //this is to prevent singularities when length(x) is small
    if (colValues.getDimension() < 99) {
        Controls.INTER = 10;
    }

    //xl <- min(x)
    double xl = colValues.getMinValue();

    //xr <- max(x)
    double xr = colValues.getMaxValue();

    //xmax <- xr + 0.01 * (xr - xl)
    double xmax = xr + 0.01 * (xr - xl);

    //xmin <- xl - 0.01 * (xr - xl)
    double xmin = xl - 0.01 * (xr - xl);

    //dx <- (xr - xl) / ndx
    double dx = (xmax - xmin) / Controls.INTER;

    //if (quantiles) # if true use splineDesign
    if (Controls.QUANTILES) {
        //knots <-  sort(c(seq(xl-deg*dx, xl, dx),quantile(x, 
        //prob=seq(0, 1, length=ndx)), seq(xr, xr+deg*dx, dx))) 
        ArrayRealVector kts = null;

        //B <- splineDesign(knots, x = x, outer.ok = TRUE, ord=deg+1)
        //return(B)  
        return null;
    } else {

        //kts <-   seq(xl - deg * dx, xr + deg * dx, by = dx)
        //ArrayRealVector kts = new ArrayRealVector(
        //ArithmeticSeries.getSeries(xl-deg*dx, xr+deg*dx, dx),false);

        rConnection.assingVar("min", new double[] { xmin - Controls.DEGREE * dx });
        rConnection.assingVar("max", new double[] { xmax + Controls.DEGREE * dx });
        rConnection.assingVar("step", new double[] { dx });

        ArrayRealVector kts = new ArrayRealVector(
                rConnection.runEvalDoubles("knots <- seq(min, max, by = step)"));

        //P <- outer(x, kts, FUN = tpower, deg)
        BlockRealMatrix pM = MatrixFunctions.outertpowerPB(colValues, kts, Controls.DEGREE);

        //D <- diff(diag(dim(P)[2]), 
        //diff = deg + 1) / (gamma(deg + 1) * dx ^ deg)
        BlockRealMatrix tempM = MatrixFunctions
                .diff(MatrixFunctions.buildIdentityMatrix(pM.getColumnDimension()), Controls.DEGREE + 1);

        double[][] tempArrArr = new double[tempM.getRowDimension()][tempM.getColumnDimension()];
        for (int i = 0; i < tempArrArr.length; i++) {
            for (int j = 0; j < tempArrArr[i].length; j++) {
                tempArrArr[i][j] = tempM.getEntry(i, j) / ((FastMath.exp(Gamma.logGamma(Controls.DEGREE + 1)))
                        * FastMath.pow(dx, Controls.DEGREE));
            }
        }
        tempM = new BlockRealMatrix(tempArrArr);

        //B <- (-1) ^ (deg + 1) * P %*% t(D)
        return (BlockRealMatrix) pM.multiply(tempM.transpose())
                .scalarMultiply(FastMath.pow(-1, (Controls.DEGREE + 1)));
    }
}

---