Example usage for org.apache.commons.math3.linear ArrayRealVector getMaxValue

Introduction

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

Prototype

public double getMaxValue() 

Source Link

Document

Get the value of the maximum entry.

Usage

From source file:gamlss.smoothing.PB.java

/**
* Constructs the base matrix./*w w  w .  j a v  a2  s . com*/
* @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)));
    }
}

---