import org.apache.commons.math.stat.descriptive.moment.Variance; //导入依赖的package包/类
/**
 * Add a value to the data
 * 
 * @param value  the value to add
 */
public void addValue(double value) {
    sumImpl.increment(value);
    sumsqImpl.increment(value);
    minImpl.increment(value);
    maxImpl.increment(value);
    sumLogImpl.increment(value);
    secondMoment.increment(value);
    // If mean, variance or geomean have been overridden,
    // need to increment these
    if (!(meanImpl instanceof Mean)) {
            meanImpl.increment(value);
    }
    if (!(varianceImpl instanceof Variance)) {
        varianceImpl.increment(value);
    }
    if (!(geoMeanImpl instanceof GeometricMean)) {
        geoMeanImpl.increment(value);
    }
    n++;
}
 

import org.apache.commons.math.stat.descriptive.moment.Variance; //导入依赖的package包/类
public void testInteraction() {
    
    FourthMoment m4 = new FourthMoment();
    Mean m = new Mean(m4);
    Variance v = new Variance(m4);
    Skewness s= new Skewness(m4);
    Kurtosis k = new Kurtosis(m4);

    for (int i = 0; i < testArray.length; i++){
        m4.increment(testArray[i]);
    }
    
    assertEquals(mean,m.getResult(),tolerance);
    assertEquals(var,v.getResult(),tolerance);
    assertEquals(skew ,s.getResult(),tolerance);
    assertEquals(kurt,k.getResult(),tolerance);

}
 

import org.apache.commons.math.stat.descriptive.moment.Variance; //导入依赖的package包/类
/**
 * Add a value to the data
 * @param value the value to add
 */
public void addValue(double value) {
    sumImpl.increment(value);
    sumsqImpl.increment(value);
    minImpl.increment(value);
    maxImpl.increment(value);
    sumLogImpl.increment(value);
    secondMoment.increment(value);
    // If mean, variance or geomean have been overridden,
    // need to increment these
    if (!(meanImpl instanceof Mean)) {
        meanImpl.increment(value);
    }
    if (!(varianceImpl instanceof Variance)) {
        varianceImpl.increment(value);
    }
    if (!(geoMeanImpl instanceof GeometricMean)) {
        geoMeanImpl.increment(value);
    }
    n++;
}
 

import org.apache.commons.math.stat.descriptive.moment.Variance; //导入依赖的package包/类
public void testInteraction() {

        FourthMoment m4 = new FourthMoment();
        Mean m = new Mean(m4);
        Variance v = new Variance(m4);
        Skewness s= new Skewness(m4);
        Kurtosis k = new Kurtosis(m4);

        for (int i = 0; i < testArray.length; i++){
            m4.increment(testArray[i]);
        }

        assertEquals(mean,m.getResult(),tolerance);
        assertEquals(var,v.getResult(),tolerance);
        assertEquals(skew ,s.getResult(),tolerance);
        assertEquals(kurt,k.getResult(),tolerance);

    }
 

import org.apache.commons.math.stat.descriptive.moment.Variance; //导入依赖的package包/类
@Test
public void testInteraction() {

    FourthMoment m4 = new FourthMoment();
    Mean m = new Mean(m4);
    Variance v = new Variance(m4);
    Skewness s= new Skewness(m4);
    Kurtosis k = new Kurtosis(m4);

    for (int i = 0; i < testArray.length; i++){
        m4.increment(testArray[i]);
    }

    Assert.assertEquals(mean,m.getResult(),tolerance);
    Assert.assertEquals(var,v.getResult(),tolerance);
    Assert.assertEquals(skew ,s.getResult(),tolerance);
    Assert.assertEquals(kurt,k.getResult(),tolerance);

}
 

import org.apache.commons.math.stat.descriptive.moment.Variance; //导入依赖的package包/类
private double computeAggregateVariance (CapacityProfile profile,
                                         double[] otherCapacities)
{
  double[] aggCapacities = new double[CapacityProfile.NUM_TIMESLOTS];
  for (int i = 0; i < CapacityProfile.NUM_TIMESLOTS; ++i) {
    aggCapacities[i] = profile.getCapacity(i) + otherCapacities[i];
  }
  return new Variance().evaluate(aggCapacities);
}
 

import org.apache.commons.math.stat.descriptive.moment.Variance; //导入依赖的package包/类
/**
 * Returns the variance of the values that have been added.
 * <p>
 *  Double.NaN is returned if no values have been added.</p>
 *
 * @return the variance 
 */
public double getVariance() {
    if (varianceImpl == variance) {
        return new Variance(secondMoment).getResult();
    } else {
        return varianceImpl.getResult();
    }
}
 

import org.apache.commons.math.stat.descriptive.moment.Variance; //导入依赖的package包/类
public static Double[] getSummaryStatistics(Double[] variable){

        double[] primitiveVariable = new double[variable.length];
        for(int i=0; i<variable.length; i++){
            primitiveVariable[i] = variable[i];
        }

        Double[] out = new Double[4];
        out[0] = (new Mean()).evaluate(primitiveVariable);
        out[1] = (new Median()).evaluate(primitiveVariable);
        out[2] = (new Variance()).evaluate(primitiveVariable);
        out[3] = Math.sqrt(out[2]);
        return out;
    }
 

import org.apache.commons.math.stat.descriptive.moment.Variance; //导入依赖的package包/类
private void prepareVariance() {
	this.var = new double[this.feats[0].length];
	Matrix m = new DenseMatrix(feats);
	double[] colArr = new double[this.feats.length];
	Variance v = new Variance();
	for (int i = 0; i < this.var.length; i++) {
		m.column(i).storeOn(colArr, 0);
		this.var[i] = v.evaluate(colArr);
	}
}
 

import org.apache.commons.math.stat.descriptive.moment.Variance; //导入依赖的package包/类
/**
 * Returns the variance of the values that have been added.
 * <p>
 * Double.NaN is returned if no values have been added.
 * </p>
 * @return the variance
 */
public double getVariance() {
    if (varianceImpl == variance) {
        return new Variance(secondMoment).getResult();
    } else {
        return varianceImpl.getResult();
    }
}
 

import org.apache.commons.math.stat.descriptive.moment.Variance; //导入依赖的package包/类
/**
 * Compute a covariance matrix from a matrix whose columns represent
 * covariates.
 * @param matrix input matrix (must have at least two columns and two rows)
 * @param biasCorrected determines whether or not covariance estimates are bias-corrected
 * @return covariance matrix
 */
protected RealMatrix computeCovarianceMatrix(RealMatrix matrix, boolean biasCorrected) {
    int dimension = matrix.getColumnDimension();
    Variance variance = new Variance(biasCorrected);
    RealMatrix outMatrix = new BlockRealMatrix(dimension, dimension);
    for (int i = 0; i < dimension; i++) {
        for (int j = 0; j < i; j++) {
          double cov = covariance(matrix.getColumn(i), matrix.getColumn(j), biasCorrected);
          outMatrix.setEntry(i, j, cov);
          outMatrix.setEntry(j, i, cov);
        }
        outMatrix.setEntry(i, i, variance.evaluate(matrix.getColumn(i)));
    }
    return outMatrix;
}
 

import org.apache.commons.math.stat.descriptive.moment.Variance; //导入依赖的package包/类
/**
 * Get a random point from the {@link Cluster} with the largest distance variance.
 *
 * @param clusters the {@link Cluster}s to search
 * @return a random point from the selected cluster
 */
private T getPointFromLargestVarianceCluster(final Collection<Cluster<T>> clusters) {

    double maxVariance = Double.NEGATIVE_INFINITY;
    Cluster<T> selected = null;
    for (final Cluster<T> cluster : clusters) {
        if (!cluster.getPoints().isEmpty()) {

            // compute the distance variance of the current cluster
            final T center = cluster.getCenter();
            final Variance stat = new Variance();
            for (final T point : cluster.getPoints()) {
                stat.increment(point.distanceFrom(center));
            }
            final double variance = stat.getResult();

            // select the cluster with the largest variance
            if (variance > maxVariance) {
                maxVariance = variance;
                selected = cluster;
            }

        }
    }

    // did we find at least one non-empty cluster ?
    if (selected == null) {
        throw new ConvergenceException(LocalizedFormats.EMPTY_CLUSTER_IN_K_MEANS);
    }

    // extract a random point from the cluster
    final List<T> selectedPoints = selected.getPoints();
    return selectedPoints.remove(random.nextInt(selectedPoints.size()));

}