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

Introduction

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

Prototype

public double getGeometricMean() 

Source Link

Document

Returns the <a href="http://www.xycoon.com/geometric_mean.htm"> geometric mean </a> of the available values

Usage

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

/**
 * Tests the aggregated plate statistics method using the values between the indices.
 *///w  w  w .j a  v  a 2 s .c  om
@Test
public void testAggregatedPlateIndices() {

    for (Plate plate : arrayIndices) {

        int begin = random.nextInt(plate.first().size() - 4);
        int end = begin + random.nextInt(3) + 3;

        List<BigDecimal> resultList = new ArrayList<BigDecimal>();
        double aggregatedReturned = Precision
                .round(mean.platesAggregated(plate, weightsIndices, begin, end - begin), precision);

        for (Well well : plate) {

            List<BigDecimal> input = well.toBigDecimal().subList(begin, end);

            for (int i = 0; i < input.size(); i++) {
                resultList.add(input.get(i).multiply(new BigDecimal(weightsIndices[i])));
            }

        }

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

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

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

        assertTrue(resultAggregated == aggregatedReturned);
    }
}

---

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

/**
 * Tests the aggregated plate statistics method using the values between the indices.
 *//*from w  w  w  .j  av  a2s .  co m*/
@Test
public void testAggregatedSetIndices() {

    for (Plate plate : arrayIndices) {

        int begin = random.nextInt(plate.first().size() - 4);
        int end = begin + random.nextInt(3) + 3;

        List<BigDecimal> resultList = new ArrayList<BigDecimal>();
        double aggregatedReturned = Precision
                .round(mean.setsAggregated(plate.dataSet(), weightsIndices, begin, end - begin), precision);

        for (Well well : plate) {

            List<BigDecimal> input = well.toBigDecimal().subList(begin, end);

            for (int i = 0; i < input.size(); i++) {
                resultList.add(input.get(i).multiply(new BigDecimal(weightsIndices[i])));
            }

        }

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

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

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

        assertTrue(resultAggregated == aggregatedReturned);
    }
}

---

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

/**
 * Tests the aggregated plate statistics method using the values between the indices of
 * the collection./* w w  w .j a v a2s  .co  m*/
 */
@Test
public void testAggregatedSetCollectionIndices() {

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

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

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

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

    for (WellSet set : collection) {

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

        for (Well well : set) {

            List<BigDecimal> input = well.toBigDecimal().subList(begin, end);

            for (int i = 0; i < input.size(); i++) {
                resultList.add(input.get(i).multiply(new BigDecimal(weightsIndices[i])));
            }

        }

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

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

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

        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.microflexdouble.stat.GeometricMeanWeightsTest.java

/**
 * Tests the aggregated plate statistics method using the values between the indices of
 * the array./*w w  w  .j  a va 2 s .c om*/
 */
@Test
public void testAggregatedSetArrayIndices() {

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

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

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

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

    for (WellSet set : setArrayIndices) {

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

        for (Well well : set) {

            List<BigDecimal> input = well.toBigDecimal().subList(begin, end);

            for (int i = 0; i < input.size(); i++) {
                resultList.add(input.get(i).multiply(new BigDecimal(weightsIndices[i])));
            }

        }

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

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

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

        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.GeometricMeanDoubleWeightsTest.java

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

    for (PlateDouble plate : arrayIndices) {

        int begin = random.nextInt(plate.first().size() - 4);
        int end = begin + random.nextInt(3) + 3;

        List<BigDecimal> resultList = new ArrayList<BigDecimal>();
        double aggregatedReturned = Precision
                .round(mean.platesAggregated(plate, weightsIndices, begin, end - begin), precision);

        for (WellDouble well : plate) {

            List<BigDecimal> input = well.toBigDecimal().subList(begin, end);

            for (int i = 0; i < input.size(); i++) {
                resultList.add(input.get(i).multiply(new BigDecimal(weightsIndices[i])));
            }

        }

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

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

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

        assertTrue(resultAggregated == aggregatedReturned);
    }
}

---

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

/**
 * Tests the aggregated plate statistics method using the values between the indices.
 */// w  ww  . j  ava2  s  . c  o  m
@Test
public void testAggregatedSetIndices() {

    for (PlateDouble plate : arrayIndices) {

        int begin = random.nextInt(plate.first().size() - 4);
        int end = begin + random.nextInt(3) + 3;

        List<BigDecimal> resultList = new ArrayList<BigDecimal>();
        double aggregatedReturned = Precision
                .round(mean.setsAggregated(plate.dataSet(), weightsIndices, begin, end - begin), precision);

        for (WellDouble well : plate) {

            List<BigDecimal> input = well.toBigDecimal().subList(begin, end);

            for (int i = 0; i < input.size(); i++) {
                resultList.add(input.get(i).multiply(new BigDecimal(weightsIndices[i])));
            }

        }

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

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

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

        assertTrue(resultAggregated == aggregatedReturned);
    }
}

---

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

/**
 * Tests the aggregated plate statistics method using the values between the indices of
 * the collection./*w  ww. jav  a  2 s . c o m*/
 */
@Test
public void testAggregatedSetCollectionIndices() {

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

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

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

    Map<WellSetDouble, Double> aggregatedReturnedMap = mean.setsAggregated(collection, weightsIndices, begin,
            end - begin);
    Map<WellSetDouble, Double> aggregatedResultMap = new TreeMap<WellSetDouble, Double>();

    for (WellSetDouble set : collection) {

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

        for (WellDouble well : set) {

            List<BigDecimal> input = well.toBigDecimal().subList(begin, end);

            for (int i = 0; i < input.size(); i++) {
                resultList.add(input.get(i).multiply(new BigDecimal(weightsIndices[i])));
            }

        }

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

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

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

        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.statdouble.GeometricMeanDoubleWeightsTest.java

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

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

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

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

    Map<WellSetDouble, Double> aggregatedReturnedMap = mean.setsAggregated(setArrayIndices, weightsIndices,
            begin, end - begin);
    Map<WellSetDouble, Double> aggregatedResultMap = new TreeMap<WellSetDouble, Double>();

    for (WellSetDouble set : setArrayIndices) {

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

        for (WellDouble well : set) {

            List<BigDecimal> input = well.toBigDecimal().subList(begin, end);

            for (int i = 0; i < input.size(); i++) {
                resultList.add(input.get(i).multiply(new BigDecimal(weightsIndices[i])));
            }

        }

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

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

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

        aggregatedResultMap.put(set, aggregatedResult);
    }

    for (WellSetDouble 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.statinteger.GeometricMeanIntegerWeightsTest.java

/**
 * Tests well calculation using indices.
 *//*from   w w  w  . ja  v a  2s  . c  om*/
@Test
public void testWellIndices() {

    for (PlateInteger plate : arrayIndices) {

        for (WellInteger well : plate) {

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

            for (double db : well) {
                input[index] = db * weightsIndices[index];
                index++;
            }

            int begin = random.nextInt(well.size() - 4);
            int end = begin + random.nextInt(3) + 3;

            DescriptiveStatistics stat = new DescriptiveStatistics(ArrayUtils.subarray(input, begin, end));
            double result = Precision.round(stat.getGeometricMean(), precision);
            double returned = Precision.round(
                    mean.well(well, ArrayUtils.subarray(weightsIndices, begin, end), begin, end - begin),
                    precision);

            assertTrue(result == returned);
        }
    }
}

---

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

/**
 * Tests well calculation using indices.
 *//*from w  w  w  .  j  av  a 2s.c  o m*/
@Test
public void testWellIndices() {

    for (Plate plate : arrayIndices) {

        for (Well well : plate) {

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

            for (double db : well) {
                input[index] = db * weightsIndices[index];
                index++;
            }

            int begin = random.nextInt(well.size() - 4);
            int end = begin + random.nextInt(3) + 3;

            DescriptiveStatistics stat = new DescriptiveStatistics(ArrayUtils.subarray(input, begin, end));
            double result = Precision.round(stat.getGeometricMean(), precision);
            double returned = Precision.round(
                    mean.well(well, ArrayUtils.subarray(weightsIndices, begin, end), begin, end - begin),
                    precision);

            assertTrue(result == returned);
        }
    }
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• »