Example usage for org.apache.commons.math.stat Frequency getCumFreq

Introduction

In this page you can find the example usage for org.apache.commons.math.stat Frequency getCumFreq.

Prototype

public long getCumFreq(char v) 

Source Link

Document

Returns the cumulative frequency of values less than or equal to v.

Usage

From source file:geogebra.kernel.AlgoFrequency.java

protected final void compute() {

    // Validate input arguments
    //=======================================================

    if (!dataList.isDefined() || dataList.size() == 0) {
        frequency.setUndefined();//  ww  w  . j  a va  2s. com
        return;
    }

    if (!(dataList.getElementType() == GeoElement.GEO_CLASS_TEXT
            || dataList.getElementType() == GeoElement.GEO_CLASS_NUMERIC)) {
        frequency.setUndefined();
        return;
    }

    if (classList != null) {
        if (classList.getElementType() != GeoElement.GEO_CLASS_NUMERIC || classList.size() < 2) {
            frequency.setUndefined();
            return;
        }
    }

    if (density != null) {
        if (density.getDouble() <= 0) {
            frequency.setUndefined();
            return;
        }
    }

    frequency.setDefined(true);
    frequency.clear();
    if (value != null)
        value.clear();

    double numMax = 0, numMin = 0;
    boolean doCumulative = isCumulative != null && isCumulative.getBoolean();

    // Load the data into f, an instance of Frequency class 
    //=======================================================

    Frequency f = new Frequency();
    for (int i = 0; i < dataList.size(); i++) {
        if (dataList.getElementType() == GeoElement.GEO_CLASS_TEXT)
            f.addValue(((GeoText) dataList.get(i)).toValueString());
        if (dataList.getElementType() == GeoElement.GEO_CLASS_NUMERIC)
            f.addValue(((GeoNumeric) dataList.get(i)).getDouble());
    }

    // If classList does not exist, 
    // get the unique value list and compute frequencies for this list  
    //=======================================================

    // handle string data
    if (dataList.getElementType() == GeoElement.GEO_CLASS_TEXT) {

        Iterator itr = f.valuesIterator();
        String strMax = (String) itr.next();
        String strMin = strMax;
        itr = f.valuesIterator();

        while (itr.hasNext()) {
            String s = (String) itr.next();
            if (s.compareTo(strMax) > 0)
                strMax = s;
            if (s.compareTo(strMin) < 0)
                strMin = s;
            GeoText text = new GeoText(cons);
            text.setTextString(s);
            value.add(text);
            if (classList == null)
                if (doCumulative)
                    frequency.add(new GeoNumeric(cons, f.getCumFreq((Comparable) s)));
                else
                    frequency.add(new GeoNumeric(cons, f.getCount((Comparable) s)));
        }
    }

    // handle numeric data
    else {
        Iterator itr = f.valuesIterator();
        numMax = (Double) itr.next();
        numMin = numMax;
        itr = f.valuesIterator();

        while (itr.hasNext()) {
            Double n = (Double) itr.next();
            if (n > numMax)
                numMax = n.doubleValue();
            if (n < numMin)
                numMin = n.doubleValue();
            value.add(new GeoNumeric(cons, n));

            if (classList == null)
                if (doCumulative)
                    frequency.add(new GeoNumeric(cons, f.getCumFreq((Comparable) n)));
                else
                    frequency.add(new GeoNumeric(cons, f.getCount((Comparable) n)));
        }
    }

    // If classList exists, compute frequencies using the classList
    //=======================================================

    if (classList != null) {

        double lowerClassBound = 0;
        double upperClassBound = 0;
        double classFreq = 0;

        //set density conditions
        boolean hasDensity = false;
        if (useDensity != null)
            hasDensity = useDensity.getBoolean();

        double densityValue = 1; // default density
        if (density != null) {
            densityValue = density.getDouble();
        }

        double cumulativeClassFreq = 0;
        double swap;
        int length = classList.size();
        for (int i = 1; i < length; i++) {

            lowerClassBound = ((GeoNumeric) classList.get(i - 1)).getDouble();
            upperClassBound = ((GeoNumeric) classList.get(i)).getDouble();
            boolean increasing = true;
            if (lowerClassBound > upperClassBound) {
                swap = upperClassBound;
                upperClassBound = lowerClassBound;
                lowerClassBound = swap;
                increasing = false;
            }
            classFreq = f.getCumFreq((Comparable) upperClassBound) - f.getCumFreq((Comparable) lowerClassBound)
                    + f.getCount((Comparable) lowerClassBound);
            if ((i != length - 1 && increasing) || (i != 1 && !increasing))
                classFreq -= f.getCount((Comparable) upperClassBound);

            //   System.out.println(" =================================");
            //   System.out.println("class freq: " + classFreq + "   " + density);
            if (hasDensity) {
                classFreq = densityValue * classFreq / (upperClassBound - lowerClassBound);
            }
            if (doCumulative)
                cumulativeClassFreq += classFreq;
            //   System.out.println("class freq: " + classFreq);

            // add the frequency to the output GeoList
            frequency.add(new GeoNumeric(cons, doCumulative ? cumulativeClassFreq : classFreq));

        }

        // handle the last (highest) class frequency specially
        // it must also count values equal to the highest class bound  

    }
}

---

From source file:geogebra.common.kernel.statistics.AlgoFrequency.java

@Override
public final void compute() {

    if (isContingencyTable) {
        computeContingencyTable();//w w  w . j  ava  2 s.  c  om
        return;
    }

    // Validate input arguments
    // =======================================================

    if (!dataList.isDefined() || dataList.size() == 0) {
        frequency.setUndefined();
        return;
    }

    if (!(dataList.getElementType().equals(GeoClass.TEXT)
            || dataList.getElementType().equals(GeoClass.NUMERIC))) {
        frequency.setUndefined();
        return;
    }

    if (classList != null) {
        if (!classList.getElementType().equals(GeoClass.NUMERIC) || classList.size() < 2) {
            frequency.setUndefined();
            return;
        }
    }

    if (density != null) {
        if (density.getDouble() <= 0) {
            frequency.setUndefined();
            return;
        }
    }

    if (scale != null) {
        if (!scale.isDefined()) {
            frequency.setUndefined();
            return;
        }
        scaleFactor = scale.getValue();
    }

    frequency.setDefined(true);
    frequency.clear();
    if (value != null)
        value.clear();

    double numMax = 0, numMin = 0;
    boolean doCumulative = isCumulative != null && isCumulative.getBoolean();

    // Load the data into f, an instance of Frequency class
    // =======================================================

    Frequency f = new FrequencyGgb();
    for (int i = 0; i < dataList.size(); i++) {
        if (dataList.getElementType().equals(GeoClass.TEXT))
            f.addValue(((GeoText) dataList.get(i)).toValueString(StringTemplate.defaultTemplate));
        if (dataList.getElementType().equals(GeoClass.NUMERIC))
            f.addValue(((GeoNumeric) dataList.get(i)).getDouble());
    }

    // If classList does not exist,
    // get the unique value list and compute frequencies for this list
    // =======================================================

    // handle string data
    if (dataList.getElementType().equals(GeoClass.TEXT)) {

        Iterator<Comparable<?>> itr = f.valuesIterator();
        String strMax = (String) itr.next();
        String strMin = strMax;
        itr = f.valuesIterator();

        while (itr.hasNext()) {
            String s = (String) itr.next();
            if (s.compareTo(strMax) > 0)
                strMax = s;
            if (s.compareTo(strMin) < 0)
                strMin = s;
            GeoText text = new GeoText(cons);
            text.setTextString(s);
            value.add(text);
            if (classList == null) {
                if (doCumulative) {
                    addValue(f.getCumFreq(s));
                } else {
                    addValue(f.getCount(s));
                }
            }
        }
    }

    // handle numeric data
    else {
        Iterator<Comparable<?>> itr = f.valuesIterator();
        numMax = (Double) itr.next();
        numMin = numMax;
        itr = f.valuesIterator();

        while (itr.hasNext()) {
            Double n = (Double) itr.next();
            if (n > numMax)
                numMax = n.doubleValue();
            if (n < numMin)
                numMin = n.doubleValue();
            value.add(new GeoNumeric(cons, n));

            if (classList == null)
                if (doCumulative)
                    addValue(f.getCumFreq(n));
                else
                    addValue(f.getCount(n));
        }
    }

    // If classList exists, compute frequencies using the classList
    // =======================================================

    if (classList != null) {

        double lowerClassBound = 0;
        double upperClassBound = 0;
        double classFreq = 0;

        // set density conditions
        boolean hasDensity = false;
        if (useDensity != null)
            hasDensity = useDensity.getBoolean();

        double densityValue = 1; // default density
        if (density != null) {
            densityValue = density.getDouble();
        }

        double cumulativeClassFreq = 0;
        double swap;
        int length = classList.size();
        for (int i = 1; i < length; i++) {

            lowerClassBound = ((GeoNumeric) classList.get(i - 1)).getDouble();
            upperClassBound = ((GeoNumeric) classList.get(i)).getDouble();

            // handle roundoff errror in class list values (this is possible
            // if auto-generated by another cmd)
            lowerClassBound = Kernel.checkDecimalFraction(lowerClassBound);
            upperClassBound = Kernel.checkDecimalFraction(upperClassBound);

            boolean increasing = true;
            if (lowerClassBound > upperClassBound) {
                swap = upperClassBound;
                upperClassBound = lowerClassBound;
                lowerClassBound = swap;
                increasing = false;
            }
            classFreq = f.getCumFreq(upperClassBound) - f.getCumFreq(lowerClassBound)
                    + f.getCount(lowerClassBound);
            if ((i != length - 1 && increasing) || (i != 1 && !increasing))
                classFreq -= f.getCount(upperClassBound);

            // System.out.println(" =================================");
            // System.out.println("class freq: " + classFreq + "   " +
            // density);

            if (doCumulative)
                cumulativeClassFreq += classFreq;

            // adjust the frequency and add to the output GeoList
            double v = doCumulative ? cumulativeClassFreq : classFreq;
            if (hasDensity) {
                v = densityValue * v / (upperClassBound - lowerClassBound);
            }
            addValue(v);
        }

        // handle the last (highest) class frequency specially
        // it must also count values equal to the highest class bound

    }
}

---