|
Commons Math example source code file (Frequency.java)
The Commons Math Frequency.java source code/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.math.stat; import java.io.Serializable; import java.text.NumberFormat; import java.util.Iterator; import java.util.Comparator; import java.util.TreeMap; import org.apache.commons.math.MathRuntimeException; /** * Maintains a frequency distribution. * <p> * 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.</p> * <p> * Integer values (int, long, Integer, Long) are not distinguished by type -- * i.e. <code>addValue(Long.valueOf(2)), addValue(2), addValue(2l) all have * the same effect (similarly for arguments to <code>getCount, etc.). * <p> * char values are converted by <code>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. * </p> * <p> * The values are ordered using the default (natural order), unless a * <code>Comparator is supplied in the constructor. * * @version $Revision: 922722 $ $Date: 2010-03-13 21:15:01 -0500 (Sat, 13 Mar 2010) $ */ public class Frequency implements Serializable { /** Serializable version identifier */ private static final long serialVersionUID = -3845586908418844111L; /** underlying collection */ private final TreeMap<Comparable>, Long> freqTable; /** * Default constructor. */ public Frequency() { freqTable = new TreeMap<Comparable>, Long>(); } /** * Constructor allowing values Comparator to be specified. * * @param comparator Comparator used to order values */ @SuppressWarnings("unchecked") // TODO is the cast OK? public Frequency(Comparator<?> comparator) { freqTable = new TreeMap<Comparable>, Long>((Comparator super Comparable>>) comparator); } /** * Return a string representation of this frequency * distribution. * * @return a string representation. */ @Override public String toString() { NumberFormat nf = NumberFormat.getPercentInstance(); StringBuffer outBuffer = new StringBuffer(); outBuffer.append("Value \t Freq. \t Pct. \t Cum Pct. \n"); Iterator<Comparable>> iter = freqTable.keySet().iterator(); while (iter.hasNext()) { Comparable<?> value = iter.next(); outBuffer.append(value); outBuffer.append('\t'); outBuffer.append(getCount(value)); outBuffer.append('\t'); outBuffer.append(nf.format(getPct(value))); outBuffer.append('\t'); outBuffer.append(nf.format(getCumPct(value))); outBuffer.append('\n'); } return outBuffer.toString(); } /** * Adds 1 to the frequency count for v. * <p> * If other objects have already been added to this Frequency, v must * be comparable to those that have already been added. * </p> * * @param v the value to add. * @throws IllegalArgumentException if <code>v is not Comparable, * or is not comparable with previous entries * @deprecated use {@link #addValue(Comparable)} instead */ @Deprecated public void addValue(Object v) { if (v instanceof Comparable<?>){ addValue((Comparable<?>) v); } else { throw MathRuntimeException.createIllegalArgumentException( "class ({0}) does not implement Comparable", v.getClass().getName()); } } /** * Adds 1 to the frequency count for v. * <p> * If other objects have already been added to this Frequency, v must * be comparable to those that have already been added. * </p> * * @param v the value to add. * @throws IllegalArgumentException if <code>v is not comparable with previous entries */ public void addValue(Comparable<?> v){ Comparable<?> obj = v; if (v instanceof Integer) { obj = Long.valueOf(((Integer) v).longValue()); } try { Long count = freqTable.get(obj); if (count == null) { freqTable.put(obj, Long.valueOf(1)); } else { freqTable.put(obj, Long.valueOf(count.longValue() + 1)); } } catch (ClassCastException ex) { //TreeMap will throw ClassCastException if v is not comparable throw MathRuntimeException.createIllegalArgumentException( "instance of class {0} not comparable to existing values", v.getClass().getName()); } } /** * Adds 1 to the frequency count for v. * * @param v the value to add. */ public void addValue(int v) { addValue(Long.valueOf(v)); } /** * Adds 1 to the frequency count for v. * * @param v the value to add. * @deprecated to be removed in math 3.0 */ @Deprecated public void addValue(Integer v) { addValue(Long.valueOf(v.longValue())); } /** * Adds 1 to the frequency count for v. * * @param v the value to add. */ public void addValue(long v) { addValue(Long.valueOf(v)); } /** * Adds 1 to the frequency count for v. * * @param v the value to add. */ public void addValue(char v) { addValue(Character.valueOf(v)); } /** Clears the frequency table */ public void clear() { freqTable.clear(); } /** * Returns an Iterator over the set of values that have been added. * <p> * 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.</p> * * @return values Iterator */ public Iterator<Comparable>> valuesIterator() { return freqTable.keySet().iterator(); } //------------------------------------------------------------------------- /** * Returns the sum of all frequencies. * * @return the total frequency count. */ public long getSumFreq() { long result = 0; Iterator<Long> iterator = freqTable.values().iterator(); while (iterator.hasNext()) { result += iterator.next().longValue(); } return result; } /** * Returns the number of values = v. * Returns 0 if the value is not comparable. * * @param v the value to lookup. * @return the frequency of v. * @deprecated replaced by {@link #getCount(Comparable)} as of 2.0 */ @Deprecated public long getCount(Object v) { return getCount((Comparable<?>) v); } /** * Returns the number of values = v. * Returns 0 if the value is not comparable. * * @param v the value to lookup. * @return the frequency of v. */ public long getCount(Comparable<?> v) { if (v instanceof Integer) { return getCount(((Integer) v).longValue()); } long result = 0; try { Long count = freqTable.get(v); if (count != null) { result = count.longValue(); } } catch (ClassCastException ex) { // ignore and return 0 -- ClassCastException will be thrown if value is not comparable } return result; } /** * Returns the number of values = v. * * @param v the value to lookup. * @return the frequency of v. */ public long getCount(int v) { return getCount(Long.valueOf(v)); } /** * Returns the number of values = v. * * @param v the value to lookup. * @return the frequency of v. */ public long getCount(long v) { return getCount(Long.valueOf(v)); } /** * Returns the number of values = v. * * @param v the value to lookup. * @return the frequency of v. */ public long getCount(char v) { return getCount(Character.valueOf(v)); } //------------------------------------------------------------- /** * Returns the percentage of values that are equal to v * (as a proportion between 0 and 1). * <p> * Returns <code>Double.NaN if no values have been added. * * @param v the value to lookup * @return the proportion of values equal to v * @deprecated replaced by {@link #getPct(Comparable)} as of 2.0 */ @Deprecated public double getPct(Object v) { return getPct((Comparable<?>) v); } /** * Returns the percentage of values that are equal to v * (as a proportion between 0 and 1). * <p> * Returns <code>Double.NaN if no values have been added. * * @param v the value to lookup * @return the proportion of values equal to v */ public double getPct(Comparable<?> v) { final long sumFreq = getSumFreq(); if (sumFreq == 0) { return Double.NaN; } return (double) getCount(v) / (double) sumFreq; } /** * Returns the percentage of values that are equal to v * (as a proportion between 0 and 1). * * @param v the value to lookup * @return the proportion of values equal to v */ public double getPct(int v) { return getPct(Long.valueOf(v)); } /** * Returns the percentage of values that are equal to v * (as a proportion between 0 and 1). * * @param v the value to lookup * @return the proportion of values equal to v */ public double getPct(long v) { return getPct(Long.valueOf(v)); } /** * Returns the percentage of values that are equal to v * (as a proportion between 0 and 1). * * @param v the value to lookup * @return the proportion of values equal to v */ public double getPct(char v) { return getPct(Character.valueOf(v)); } //----------------------------------------------------------------------------------------- /** * Returns the cumulative frequency of values less than or equal to v. * <p> * Returns 0 if v is not comparable to the values set.</p> * * @param v the value to lookup. * @return the proportion of values equal to v * @deprecated replaced by {@link #getCumFreq(Comparable)} as of 2.0 */ @Deprecated public long getCumFreq(Object v) { return getCumFreq((Comparable<?>) v); } /** * Returns the cumulative frequency of values less than or equal to v. * <p> * Returns 0 if v is not comparable to the values set.</p> * * @param v the value to lookup. * @return the proportion of values equal to v */ public long getCumFreq(Comparable<?> v) { if (getSumFreq() == 0) { return 0; } if (v instanceof Integer) { return getCumFreq(((Integer) v).longValue()); } @SuppressWarnings("unchecked") // OK, freqTable is Comparable<?> Comparator<Comparable>> c = (Comparator* * @param o1 the first object * @param o2 the second object * @return result of comparison * @throws NullPointerException when <i>o1 is null ,
* or when <code>((Comparable)o1).compareTo(o2) does
* @throws ClassCastException when <i>o1 is not a {@link Comparable Comparable},
* or when <code>((Comparable)o1).compareTo(o2) does
*/
@SuppressWarnings("unchecked") // cast to (T) may throw ClassCastException, see Javadoc
public int compare(Comparable<T> o1, ComparableOther Commons Math examples (source code examples)Here is a short list of links related to this Commons Math Frequency.java source code file: |
... this post is sponsored by my books ... | |
![]() #1 New Release! |
![]() FP Best Seller |
Copyright 1998-2024 Alvin Alexander, alvinalexander.com
All Rights Reserved.
A percentage of advertising revenue from
pages under the /java/jwarehouse
URI on this website is
paid back to open source projects.