Example usage for org.apache.commons.math3.stat.descriptive DescriptiveStatistics getPopulationVariance

Introduction

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

Prototype

public double getPopulationVariance() 

Source Link

Document

Returns the <a href="http://en.wikibooks.org/wiki/Statistics/Summary/Variance"> population variance</a> of the available values.

Usage

From source file:com.github.jessemull.microflex.stat.statdouble.PopulationVarianceDoubleTest.java

/**
 * Tests the aggregated plate statistics method.
 *///from   ww w . ja  v a2  s. c  o  m
@Test
public void testAggregatedPlate() {

    for (PlateDouble plate : array) {

        List<Double> resultList = new ArrayList<Double>();
        double aggregatedReturned = Precision.round(variance.platesAggregated(plate), precision);

        for (WellDouble well : plate) {
            resultList.addAll(well.data());
        }

        double[] inputAggregated = new double[resultList.size()];

        for (int i = 0; i < resultList.size(); i++) {
            inputAggregated[i] = resultList.get(i);
        }

        DescriptiveStatistics statAggregated = new DescriptiveStatistics(inputAggregated);
        double resultAggregated = Precision.round(statAggregated.getPopulationVariance(), precision);

        assertTrue(resultAggregated == aggregatedReturned);
    }
}

---

From source file:com.github.jessemull.microflex.stat.statdouble.PopulationVarianceDoubleTest.java

/**
 * Tests the aggregated plate statistics method using the values between the indices of
 * the collection./*from  www.  j  a va2  s  . com*/
 */
@Test
public void testAggregatedPlateCollectionIndices() {

    int size = arrayIndices[0].first().size();
    int begin = random.nextInt(size - 5);
    int end = (begin + 4) + random.nextInt(size - (begin + 4) + 1);

    List<PlateDouble> collection = Arrays.asList(arrayIndices);
    Map<PlateDouble, Double> aggregatedReturnedMap = variance.platesAggregated(collection, begin, end - begin);

    Map<PlateDouble, Double> aggregatedResultMap = new TreeMap<PlateDouble, Double>();

    for (PlateDouble plate : collection) {

        List<Double> resultList = new ArrayList<Double>();

        for (WellDouble well : plate) {
            resultList.addAll(well.data().subList(begin, end));
        }

        double[] inputAggregated = new double[resultList.size()];

        for (int i = 0; i < resultList.size(); i++) {
            inputAggregated[i] = resultList.get(i);
        }

        DescriptiveStatistics statAggregated = new DescriptiveStatistics(inputAggregated);
        double resultAggregated = statAggregated.getPopulationVariance();

        aggregatedResultMap.put(plate, resultAggregated);
    }

    for (PlateDouble plate : collection) {

        double result = Precision.round(aggregatedResultMap.get(plate), precision);
        double returned = Precision.round(aggregatedReturnedMap.get(plate), precision);

        assertTrue(result == returned);
    }
}

---

From source file:com.github.jessemull.microflex.stat.statdouble.PopulationVarianceDoubleTest.java

/**
 * Tests the aggregated plate statistics method.
 *///from  www .  ja v a 2 s .  c o  m
@Test
public void testAggregatedSet() {

    for (PlateDouble plate : array) {

        List<Double> resultList = new ArrayList<Double>();
        double aggregatedReturned = Precision.round(variance.setsAggregated(plate.dataSet()), precision);

        for (WellDouble well : plate) {
            resultList.addAll(well.data());
        }

        double[] inputAggregated = new double[resultList.size()];

        for (int i = 0; i < resultList.size(); i++) {
            inputAggregated[i] = resultList.get(i);
        }

        DescriptiveStatistics statAggregated = new DescriptiveStatistics(inputAggregated);
        double resultAggregated = Precision.round(statAggregated.getPopulationVariance(), precision);

        assertTrue(resultAggregated == aggregatedReturned);
    }
}

---

From source file:com.github.jessemull.microflex.stat.statdouble.PopulationVarianceDoubleTest.java

/**
 * Tests the aggregated plate statistics method using a collection.
 *///from   w  w w  .j  a  v a  2 s.  c om
@Test
public void testAggregatedSetCollection() {

    List<WellSetDouble> collection = new ArrayList<WellSetDouble>();

    for (PlateDouble plate : array) {
        collection.add(plate.dataSet());
    }

    Map<WellSetDouble, Double> aggregatedReturnedMap = variance.setsAggregated(collection);
    Map<WellSetDouble, Double> aggregatedResultMap = new TreeMap<WellSetDouble, Double>();

    for (WellSetDouble set : collection) {

        List<Double> resultList = new ArrayList<Double>();

        for (WellDouble well : set) {
            resultList.addAll(well.data());
        }

        double[] inputAggregated = new double[resultList.size()];

        for (int i = 0; i < resultList.size(); i++) {
            inputAggregated[i] = resultList.get(i);
        }

        DescriptiveStatistics statAggregated = new DescriptiveStatistics(inputAggregated);
        double aggregatedResult = statAggregated.getPopulationVariance();

        aggregatedResultMap.put(set, aggregatedResult);
    }

    for (WellSetDouble set : collection) {

        double result = Precision.round(aggregatedResultMap.get(set), precision);
        double returned = Precision.round(aggregatedReturnedMap.get(set), precision);

        assertTrue(result == returned);
    }
}

---

From source file:com.github.jessemull.microflex.stat.statinteger.PopulationVarianceIntegerTest.java

/**
 * Tests the aggregated plate statistics method using an array.
 *//*  w ww  .jav a  2 s. c  o  m*/
@Test
public void testAggregatedSetArray() {

    WellSetInteger[] setArray = new WellSetInteger[array.length];

    for (int i = 0; i < setArray.length; i++) {
        setArray[i] = array[i].dataSet();
    }

    Map<WellSetInteger, Double> aggregatedReturnedMap = variance.setsAggregated(setArray);
    Map<WellSetInteger, Double> aggregatedResultMap = new TreeMap<WellSetInteger, Double>();

    for (WellSetInteger set : setArray) {

        List<Double> resultList = new ArrayList<Double>();

        for (WellInteger well : set) {
            resultList.addAll(well.toDouble());
        }

        double[] inputAggregated = new double[resultList.size()];

        for (int i = 0; i < resultList.size(); i++) {
            inputAggregated[i] = resultList.get(i);
        }

        DescriptiveStatistics statAggregated = new DescriptiveStatistics(inputAggregated);
        double aggregatedResult = statAggregated.getPopulationVariance();

        aggregatedResultMap.put(set, aggregatedResult);
    }

    for (WellSetInteger set : setArray) {

        double result = Precision.round(aggregatedResultMap.get(set), precision);
        double returned = Precision.round(aggregatedReturnedMap.get(set), precision);

        assertTrue(result == returned);
    }

}

---

From source file:com.github.jessemull.microflexinteger.stat.PopulationVarianceTest.java

/**
 * Tests the aggregated plate statistics method using the values between the indices of
 * the collection.// w  ww . j  a v a2  s .c  om
 */
@Test
public void testAggregatedSetCollectionIndices() {

    int size = arrayIndices[0].first().size();
    int begin = random.nextInt(size - 5);
    int end = (begin + 4) + random.nextInt(size - (begin + 4) + 1);

    List<WellSet> collection = new ArrayList<WellSet>();

    for (Plate plate : arrayIndices) {
        collection.add(plate.dataSet());
    }

    Map<WellSet, Double> aggregatedReturnedMap = variance.setsAggregated(collection, begin, end - begin);
    Map<WellSet, Double> aggregatedResultMap = new TreeMap<WellSet, Double>();

    for (WellSet set : collection) {

        List<Double> resultList = new ArrayList<Double>();

        for (Well well : set) {
            resultList.addAll(well.toDouble().subList(begin, end));
        }

        double[] inputAggregated = new double[resultList.size()];

        for (int i = 0; i < resultList.size(); i++) {
            inputAggregated[i] = resultList.get(i);
        }

        DescriptiveStatistics statAggregated = new DescriptiveStatistics(inputAggregated);
        double aggregatedResult = statAggregated.getPopulationVariance();

        aggregatedResultMap.put(set, aggregatedResult);
    }

    for (WellSet set : collection) {

        double result = Precision.round(aggregatedResultMap.get(set), precision);
        double returned = Precision.round(aggregatedReturnedMap.get(set), precision);

        assertTrue(result == returned);
    }
}

---

From source file:com.github.jessemull.microflexinteger.stat.PopulationVarianceTest.java

/**
 * Tests the aggregated plate statistics method using the values between the indices of
 * the array.//from www.  jav  a 2s .  co  m
 */
@Test
public void testAggregatedSetArrayIndices() {

    int size = arrayIndices[0].first().size();
    int begin = random.nextInt(size - 5);
    int end = (begin + 4) + random.nextInt(size - (begin + 4) + 1);

    WellSet[] setArrayIndices = new WellSet[arrayIndices.length];

    for (int i = 0; i < setArrayIndices.length; i++) {
        setArrayIndices[i] = arrayIndices[i].dataSet();
    }

    Map<WellSet, Double> aggregatedReturnedMap = variance.setsAggregated(setArrayIndices, begin, end - begin);
    Map<WellSet, Double> aggregatedResultMap = new TreeMap<WellSet, Double>();

    for (WellSet set : setArrayIndices) {

        List<Double> resultList = new ArrayList<Double>();

        for (Well well : set) {
            resultList.addAll(well.toDouble().subList(begin, end));
        }

        double[] inputAggregated = new double[resultList.size()];

        for (int i = 0; i < resultList.size(); i++) {
            inputAggregated[i] = resultList.get(i);
        }

        DescriptiveStatistics statAggregated = new DescriptiveStatistics(inputAggregated);
        double aggregatedResult = statAggregated.getPopulationVariance();

        aggregatedResultMap.put(set, aggregatedResult);
    }

    for (WellSet plate : setArrayIndices) {

        double result = Precision.round(aggregatedResultMap.get(plate), precision);
        double returned = Precision.round(aggregatedReturnedMap.get(plate), precision);

        assertTrue(result == returned);
    }
}

---

From source file:com.github.jessemull.microflex.stat.statdouble.PopulationVarianceDoubleTest.java

/**
 * Tests the aggregated plate statistics method using an array.
 *///from ww w . j  a v a  2 s  .c o m
@Test
public void testAggregatedSetArray() {

    WellSetDouble[] setArray = new WellSetDouble[array.length];

    for (int i = 0; i < setArray.length; i++) {
        setArray[i] = array[i].dataSet();
    }

    Map<WellSetDouble, Double> aggregatedReturnedMap = variance.setsAggregated(setArray);
    Map<WellSetDouble, Double> aggregatedResultMap = new TreeMap<WellSetDouble, Double>();

    for (WellSetDouble set : setArray) {

        List<Double> resultList = new ArrayList<Double>();

        for (WellDouble well : set) {
            resultList.addAll(well.data());
        }

        double[] inputAggregated = new double[resultList.size()];

        for (int i = 0; i < resultList.size(); i++) {
            inputAggregated[i] = resultList.get(i);
        }

        DescriptiveStatistics statAggregated = new DescriptiveStatistics(inputAggregated);
        double aggregatedResult = statAggregated.getPopulationVariance();

        aggregatedResultMap.put(set, aggregatedResult);
    }

    for (WellSetDouble set : setArray) {

        double result = Precision.round(aggregatedResultMap.get(set), precision);
        double returned = Precision.round(aggregatedReturnedMap.get(set), precision);

        assertTrue(result == returned);
    }

}

---

From source file:com.github.jessemull.microflexdouble.stat.PopulationVarianceTest.java

/**
 * Tests the plate statistics method using the values between the indices.
 *///from   w w  w.j a v  a 2  s. c o m
@Test
public void testPlateIndices() {

    for (Plate plate : arrayIndices) {

        int size = arrayIndices[0].first().size();
        int begin = random.nextInt(size - 5);
        int end = (begin + 4) + random.nextInt(size - (begin + 4) + 1);

        Map<Well, Double> resultMap = new TreeMap<Well, Double>();
        Map<Well, Double> returnedMap = variance.plate(plate, begin, end - begin);

        for (Well well : plate) {

            double[] input = new double[well.size()];
            int index = 0;

            for (double bd : well) {
                input[index++] = bd;
                ;
            }

            DescriptiveStatistics stat = new DescriptiveStatistics(ArrayUtils.subarray(input, begin, end));
            double result = stat.getPopulationVariance();

            resultMap.put(well, result);
        }

        for (Well well : plate) {

            double result = Precision.round(resultMap.get(well), precision);
            double returned = Precision.round(returnedMap.get(well), precision);

            assertTrue(result == returned);
        }
    }
}

---

From source file:com.github.jessemull.microflexdouble.stat.PopulationVarianceTest.java

/**
 * Tests set calculation using indices./*from w w  w. jav a2 s.co m*/
 */
@Test
public void testSetIndices() {

    for (Plate plate : arrayIndices) {

        int size = arrayIndices[0].first().size();
        int begin = random.nextInt(size - 5);
        int end = (begin + 4) + random.nextInt(size - (begin + 4) + 1);

        Map<Well, Double> resultMap = new TreeMap<Well, Double>();
        Map<Well, Double> returnedMap = variance.set(plate.dataSet(), begin, end - begin);

        for (Well well : plate) {

            double[] input = new double[well.size()];
            int index = 0;

            for (double bd : well) {
                input[index++] = bd;
                ;
            }

            DescriptiveStatistics stat = new DescriptiveStatistics(ArrayUtils.subarray(input, begin, end));
            double result = stat.getPopulationVariance();

            resultMap.put(well, result);
        }

        for (Well well : plate) {

            double result = Precision.round(resultMap.get(well), precision);
            double returned = Precision.round(returnedMap.get(well), precision);

            assertTrue(result == returned);
        }
    }
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• »