org.apache.commons.math3.stat
public class Frequency extends Object implements Serializable
Accepts int, long, char or Comparable values. New values added must be comparable to those that have been added, otherwise the add method will throw an IllegalArgumentException.
Integer values (int, long, Integer, Long) are not distinguished by type 
i.e. addValue(Long.valueOf(2)), addValue(2), addValue(2l)
all have
the same effect (similarly for arguments to getCount,
etc.).
NOTE: byte and short values will be implicitly converted to int values by the compiler, thus there are no explicit overloaded methods for these primitive types.
char values are converted by addValue
to Character instances.
As such, these values are not comparable to integral values, so attempts
to combine integral types with chars in a frequency distribution will fail.
Float is not coerced to Double. Since they are not Comparable with each other the user must do any necessary coercion. Float.NaN and Double.NaN are not treated specially; they may occur in input and will occur in output if appropriate.
The values are ordered using the default (natural order), unless a
Comparator
is supplied in the constructor.
Constructor and Description 

Frequency()
Default constructor.

Frequency(Comparator<?> comparator)
Constructor allowing values Comparator to be specified.

Modifier and Type  Method and Description 

void 
addValue(char v)
Adds 1 to the frequency count for v.

void 
addValue(Comparable<?> v)
Adds 1 to the frequency count for v.

void 
addValue(int v)
Adds 1 to the frequency count for v.

void 
addValue(long v)
Adds 1 to the frequency count for v.

void 
clear()
Clears the frequency table

Iterator<Map.Entry<Comparable<?>,Long>> 
entrySetIterator()
Return an Iterator over the set of keys and values that have been added.

boolean 
equals(Object obj) 
long 
getCount(char v)
Returns the number of values equal to v.

long 
getCount(Comparable<?> v)
Returns the number of values equal to v.

long 
getCount(int v)
Returns the number of values equal to v.

long 
getCount(long v)
Returns the number of values equal to v.

long 
getCumFreq(char v)
Returns the cumulative frequency of values less than or equal to v.

long 
getCumFreq(Comparable<?> v)
Returns the cumulative frequency of values less than or equal to v.

long 
getCumFreq(int v)
Returns the cumulative frequency of values less than or equal to v.

long 
getCumFreq(long v)
Returns the cumulative frequency of values less than or equal to v.

double 
getCumPct(char v)
Returns the cumulative percentage of values less than or equal to v
(as a proportion between 0 and 1).

double 
getCumPct(Comparable<?> v)
Returns the cumulative percentage of values less than or equal to v
(as a proportion between 0 and 1).

double 
getCumPct(int v)
Returns the cumulative percentage of values less than or equal to v
(as a proportion between 0 and 1).

double 
getCumPct(long v)
Returns the cumulative percentage of values less than or equal to v
(as a proportion between 0 and 1).

List<Comparable<?>> 
getMode()
Returns the mode value(s) in comparator order.

double 
getPct(char v)
Returns the percentage of values that are equal to v
(as a proportion between 0 and 1).

double 
getPct(Comparable<?> v)
Returns the percentage of values that are equal to v
(as a proportion between 0 and 1).

double 
getPct(int v)
Returns the percentage of values that are equal to v
(as a proportion between 0 and 1).

double 
getPct(long v)
Returns the percentage of values that are equal to v
(as a proportion between 0 and 1).

long 
getSumFreq()
Returns the sum of all frequencies.

int 
getUniqueCount()
Returns the number of values in the frequency table.

int 
hashCode() 
void 
incrementValue(char v,
long increment)
Increments the frequency count for v.

void 
incrementValue(Comparable<?> v,
long increment)
Increments the frequency count for v.

void 
incrementValue(int v,
long increment)
Increments the frequency count for v.

void 
incrementValue(long v,
long increment)
Increments the frequency count for v.

void 
merge(Collection<Frequency> others)
Merge a
Collection of Frequency objects into this instance. 
void 
merge(Frequency other)
Merge another Frequency object's counts into this instance.

String 
toString()
Return a string representation of this frequency distribution.

Iterator<Comparable<?>> 
valuesIterator()
Returns an Iterator over the set of values that have been added.

public Frequency()
public Frequency(Comparator<?> comparator)
comparator
 Comparator used to order valuespublic void addValue(Comparable<?> v) throws MathIllegalArgumentException
If other objects have already been added to this Frequency, v must be comparable to those that have already been added.
v
 the value to add.MathIllegalArgumentException
 if v
is not comparable with previous entriespublic void addValue(int v) throws MathIllegalArgumentException
v
 the value to add.MathIllegalArgumentException
 if the table contains entries not
comparable to Longpublic void addValue(long v) throws MathIllegalArgumentException
v
 the value to add.MathIllegalArgumentException
 if the table contains entries not
comparable to Longpublic void addValue(char v) throws MathIllegalArgumentException
v
 the value to add.MathIllegalArgumentException
 if the table contains entries not
comparable to Charpublic void incrementValue(Comparable<?> v, long increment) throws MathIllegalArgumentException
If other objects have already been added to this Frequency, v must be comparable to those that have already been added.
v
 the value to add.increment
 the amount by which the value should be incrementedMathIllegalArgumentException
 if v
is not comparable with previous entriespublic void incrementValue(int v, long increment) throws MathIllegalArgumentException
If other objects have already been added to this Frequency, v must be comparable to those that have already been added.
v
 the value to add.increment
 the amount by which the value should be incrementedMathIllegalArgumentException
 if the table contains entries not
comparable to Longpublic void incrementValue(long v, long increment) throws MathIllegalArgumentException
If other objects have already been added to this Frequency, v must be comparable to those that have already been added.
v
 the value to add.increment
 the amount by which the value should be incrementedMathIllegalArgumentException
 if the table contains entries not
comparable to Longpublic void incrementValue(char v, long increment) throws MathIllegalArgumentException
If other objects have already been added to this Frequency, v must be comparable to those that have already been added.
v
 the value to add.increment
 the amount by which the value should be incrementedMathIllegalArgumentException
 if the table contains entries not
comparable to Charpublic void clear()
public Iterator<Comparable<?>> valuesIterator()
If added values are integral (i.e., integers, longs, Integers, or Longs), they are converted to Longs when they are added, so the objects returned by the Iterator will in this case be Longs.
public Iterator<Map.Entry<Comparable<?>,Long>> entrySetIterator()
If added values are integral (i.e., integers, longs, Integers, or Longs), they are converted to Longs when they are added, so the values of the map entries returned by the Iterator will in this case be Longs.
public long getSumFreq()
public long getCount(Comparable<?> v)
v
 the value to lookup.public long getCount(int v)
v
 the value to lookup.public long getCount(long v)
v
 the value to lookup.public long getCount(char v)
v
 the value to lookup.public int getUniqueCount()
valuesIterator()
public double getPct(Comparable<?> v)
Returns Double.NaN
if no values have been added.
Returns 0 if at least one value has been added, but v is not comparable
to the values set.
v
 the value to lookuppublic double getPct(int v)
v
 the value to lookuppublic double getPct(long v)
v
 the value to lookuppublic double getPct(char v)
v
 the value to lookuppublic long getCumFreq(Comparable<?> v)
Returns 0 if v is not comparable to the values set.
v
 the value to lookup.public long getCumFreq(int v)
Returns 0 if v is not comparable to the values set.
v
 the value to lookuppublic long getCumFreq(long v)
Returns 0 if v is not comparable to the values set.
v
 the value to lookuppublic long getCumFreq(char v)
Returns 0 if v is not comparable to the values set.
v
 the value to lookuppublic double getCumPct(Comparable<?> v)
Returns Double.NaN
if no values have been added.
Returns 0 if at least one value has been added, but v is not comparable
to the values set.
v
 the value to lookuppublic double getCumPct(int v)
Returns 0 if v is not comparable to the values set.
v
 the value to lookuppublic double getCumPct(long v)
Returns 0 if v is not comparable to the values set.
v
 the value to lookuppublic double getCumPct(char v)
Returns 0 if v is not comparable to the values set.
v
 the value to lookuppublic List<Comparable<?>> getMode()
public void merge(Frequency other) throws NullArgumentException
other
 the other Frequency
object to be mergedNullArgumentException
 if other
is nullpublic void merge(Collection<Frequency> others) throws NullArgumentException
Collection
of Frequency
objects into this instance.
This Frequency's counts will be incremented (or set when not already set)
by the counts represented by each of the others.others
 the other Frequency
objects to be mergedNullArgumentException
 if the collection is nullCopyright © 2003–2015 The Apache Software Foundation. All rights reserved.