Example usage for org.apache.commons.math3.stat.descriptive.rank Max Max

List of usage examples for org.apache.commons.math3.stat.descriptive.rank Max Max

Introduction

In this page you can find the example usage for org.apache.commons.math3.stat.descriptive.rank Max Max.

Prototype

public Max() 

Source Link

Document

Create a Max instance

Usage

From source file:br.unicamp.ic.recod.gpsi.measures.gpsiDualScore.java

@Override
public double score(double[][][] input) {

    int least;//from  www  .  ja va2s  .com

    Min min = new Min();
    Max max = new Max();

    double dist[][] = new double[2][];
    double limits[][] = new double[2][2];

    for (int i = 0; i <= 1; i++) {
        dist[i] = MatrixUtils.createRealMatrix(input[i]).getColumn(0);
        limits[i] = new double[] { min.evaluate(dist[i]), max.evaluate(dist[i]) };
    }

    least = limits[0][0] <= limits[1][0] ? 0 : 1;
    double sep = limits[1 - least][0] - limits[least][1];

    if (sep >= 0)
        return sep / (max.evaluate(new double[] { limits[0][1], limits[1][1] })
                - min.evaluate(new double[] { limits[0][0], limits[1][0] }));

    double n = 0;

    for (int j = 0; j <= 1; j++)
        for (int i = 0; i < dist[j].length; i++) {
            if (dist[j][i] >= limits[1 - least][0] && dist[j][i] <= limits[least][1])
                n++;
        }

    return -n / (dist[0].length + dist[1].length);

}

From source file:br.unicamp.ic.recod.gpsi.measures.gpsiHellingerDistanceScore.java

@Override
public double score(double[][][] input) {

    double dist[][] = new double[2][];

    int bins = 1000;

    dist[0] = MatrixUtils.createRealMatrix(input[0]).getColumn(0);
    dist[1] = MatrixUtils.createRealMatrix(input[1]).getColumn(0);

    gpsiHistogram hist = new gpsiHistogram();
    double globalMin = (new Min()).evaluate(ArrayUtils.addAll(dist[0], dist[1]));
    double globalMax = (new Max()).evaluate(ArrayUtils.addAll(dist[0], dist[1]));

    double[] h0 = hist.distribution(dist[0], bins, globalMin, globalMax);
    double[] h1 = hist.distribution(dist[1], bins, globalMin, globalMax);

    double BC = 0.0;

    for (int i = 0; i < bins; i++)
        BC += Math.sqrt(h0[i] * h1[i]);

    return Math.sqrt(1 - BC);

}

From source file:com.cloudera.oryx.common.stats.RunningStatistics.java

public RunningStatistics() {
    this.mean = new Mean();
    this.min = new Min();
    this.max = new Max();
}

From source file:com.itemanalysis.psychometrics.histogram.AbstractBinCalculation.java

/**
 * Creates the object and instantiates the min and max objects.
 */
public AbstractBinCalculation() {
    min = new Min();
    max = new Max();
}

From source file:com.itemanalysis.psychometrics.kernel.LeastSquaresCrossValidation.java

private void computeBounds() throws Exception {
    StandardDeviation stdev = new StandardDeviation();
    this.sd = stdev.evaluate(x);
    Min min = new Min();
    double from = min.evaluate(x);
    Max max = new Max();
    double to = max.evaluate(x);

}

From source file:com.itemanalysis.jmetrik.stats.irt.linking.DbThetaDistribution.java

public DistributionApproximation getDistribution(Connection conn, DataTableName tableName,
        VariableName thetaName, VariableName weightName, boolean hasWeight) throws SQLException {

    points = new ArrayList<Double>();
    Min min = new Min();
    Max max = new Max();

    Table sqlTable = new Table(tableName.getNameForDatabase());
    SelectQuery query = new SelectQuery();
    query.addColumn(sqlTable, thetaName.nameForDatabase());
    if (hasWeight) {
        query.addColumn(sqlTable, weightName.nameForDatabase());
        weights = new ArrayList<Double>();
    }/*from w  w  w  .  j a  va 2  s. co  m*/

    Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
    ResultSet rs = stmt.executeQuery(query.toString());
    double value = 0.0;
    double w = 1.0;

    while (rs.next()) {
        value = rs.getDouble(thetaName.nameForDatabase());
        if (!rs.wasNull()) {
            if (hasWeight) {
                w = rs.getDouble(weightName.nameForDatabase());
                if (rs.wasNull()) {
                    w = 0.0;
                }
                points.add(value);
                weights.add(w);
                min.increment(value);
                max.increment(value);
            } else {
                points.add(value);
                min.increment(value);
                max.increment(value);
            }
        }
    }
    rs.close();
    stmt.close();

    ContinuousDistributionApproximation dist = new ContinuousDistributionApproximation(points.size(),
            min.getResult(), max.getResult());

    if (hasWeight) {
        for (int i = 0; i < points.size(); i++) {
            dist.setPointAt(i, points.get(i));
            dist.setDensityAt(i, weights.get(i));
        }
    } else {
        for (int i = 0; i < points.size(); i++) {
            dist.setPointAt(i, points.get(i));
        }
    }

    return dist;

}

From source file:com.itemanalysis.psychometrics.measurement.DefaultItemScoring.java

public DefaultItemScoring(boolean isContinuous) {
    this.isContinuous = isContinuous;
    categoryMap = new TreeMap<Object, Category>(new ItemResponseComparator());
    maximumPossibleScore = new Max();
    minimumPossibleScore = new Min();
    specialDataCodes = new SpecialDataCodes();
    scoreLevels = new TreeSet<Double>();
}

From source file:gedi.util.math.stat.counting.RollingStatistics.java

public double getCovariateRange() {
    return cov.evaluate(new Max()) - cov.evaluate(new Min());
}

From source file:com.itemanalysis.psychometrics.rasch.ScoreTable.java

public void updateScoreTable(int globalMaxIter, double globalConvergence, double adjust) {
    double DELTA = globalConvergence + 1.0; //LCONV
    Max maxDelta = new Max();
    int iter = 0;

    //initialize raw score and extreme score arrays
    double maxRaw = validMRS();
    int n = (int) maxRaw;
    int np1 = n + 1;
    scoreTable = new double[np1][2];
    extremeScore = new boolean[np1];
    stdError = new double[np1];
    for (int i = 0; i < np1; i++) {
        scoreTable[i][0] = i;// ww w  .  j a va2 s.  co m
        scoreTable[i][1] = scoreTableProx(scoreTable[i][0], maxRaw, adjust);
        stdError[i] = 0.0;
        if (i == 0 || i == n) {
            extremeScore[i] = true;
        } else {
            extremeScore[i] = false;
        }
    }

    double previousTheta = 0.0;
    //update nonextreme persons
    while (DELTA >= globalConvergence && iter < globalMaxIter) {
        //Change in person parameter is not counted toward delta.
        for (int i = 0; i < np1; i++) {
            if (!extremeScore[i]) {
                previousTheta = scoreTable[i][1];
                scoreTable[i][1] = personUpdate(scoreTable[i][1], scoreTable[i][0], maxRaw, 0.0, DELTA);
                maxDelta.increment(Math.abs(previousTheta - scoreTable[i][1]));
            }
        }
        DELTA = maxDelta.getResult();
        maxDelta.clear();
        iter++;
    }

    int iter2 = 0;
    double DELTA2 = 1.0;
    double adjustedRaw = 0.0;
    int index = 0;
    //update lowest and highest (extreme) scores - convergence = 0.01 and maximum of 25 iterations
    while (DELTA2 >= 0.01 && iter2 < 25) {
        index = 0;
        previousTheta = scoreTable[index][1];
        adjustedRaw = adjust;
        scoreTable[index][1] = personUpdate(scoreTable[index][1], adjustedRaw, maxRaw, 0.0, DELTA);
        maxDelta.increment(Math.abs(previousTheta - scoreTable[index][1]));
        index = n;
        previousTheta = scoreTable[index][1];
        adjustedRaw = scoreTable[index][0] - adjust;
        scoreTable[index][1] = personUpdate(scoreTable[index][1], adjustedRaw, maxRaw, 0.0, DELTA);

        maxDelta.increment(Math.abs(previousTheta - scoreTable[index][1]));

        DELTA2 = maxDelta.getResult();
        maxDelta.clear();
        iter2++;
    }
}

From source file:com.sciaps.utils.Util.java

public static Spectrum createAverage(Collection<? extends Spectrum> shots, double sampleRate) {

    Min minWL = new Min();
    Max maxWL = new Max();
    for (Spectrum shot : shots) {
        minWL.increment(shot.getValidRange().getMinimumDouble());
        maxWL.increment(shot.getValidRange().getMaximumDouble());
    }/*from   ww w.j  a  v  a2 s  . c  o  m*/

    double range = maxWL.getResult() - minWL.getResult();
    int numSamples = (int) Math.floor(range * sampleRate);
    double[][] data = new double[2][numSamples];
    Mean avgy = new Mean();
    for (int i = 0; i < numSamples; i++) {
        double x = minWL.getResult() + i * (1 / sampleRate);
        avgy.clear();
        for (Spectrum shot : shots) {
            if (shot.getValidRange().containsDouble(x)) {
                UnivariateFunction iv = shot.getIntensityFunction();
                double y = iv.value(x);
                avgy.increment(y);
            }
        }

        data[0][i] = x;
        data[1][i] = avgy.getResult();
    }

    RawDataSpectrum newSpectrum = new RawDataSpectrum(data);

    return newSpectrum;
}