Class Counter<E>

java.lang.Object
edu.berkeley.nlp.lm.collections.Counter<E>
All Implemented Interfaces:
Serializable

public class Counter<E> extends Object implements Serializable
A map from objects to doubles. Includes convenience methods for getting, setting, and incrementing element counts. Objects not in the counter will return a count of zero. The counter is backed by a HashMap .(unless specified otherwise with the MapFactory constructor).
Author:
lots of people
See Also:
  • Constructor Details

    • Counter

      public Counter()
    • Counter

      public Counter(Counter<? extends E> counter)
    • Counter

      public Counter(Collection<? extends E> collection)
  • Method Details

    • getDefaultCount

      public double getDefaultCount()
    • setDefaultCount

      public void setDefaultCount(double deflt)
    • keySet

      public Set<E> keySet()
      The elements in the counter.
      Returns:
      set of keys
    • entrySet

      public Set<Map.Entry<E,Double>> entrySet()
    • size

      public int size()
      The number of entries in the counter (not the total count -- use totalCount() instead).
    • isEmpty

      public boolean isEmpty()
      True if there are no entries in the counter (false does not mean totalCount > 0)
    • containsKey

      public boolean containsKey(E key)
      Returns whether the counter contains the given key. Note that this is the way to distinguish keys which are in the counter with count zero, and those which are not in the counter (and will therefore return count zero from getCount().
      Parameters:
      key -
      Returns:
      whether the counter contains the key
    • getCount

      public double getCount(E key)
      Get the count of the element, or zero if the element is not in the counter.
      Parameters:
      key -
      Returns:
    • getProbability

      public double getProbability(E key)
      I know, I know, this should be wrapped in a Distribution class, but it's such a common use...why not. Returns the MLE prob. Assumes all the counts are >= 0.0 and totalCount > 0.0. If the latter is false, return 0.0 (i.e. 0/0 == 0)
      Parameters:
      key -
      Returns:
      MLE prob of the key
    • normalize

      public void normalize()
      Destructively normalize this Counter in place.
    • setCount

      public void setCount(E key, double count)
      Set the count for the given key, clobbering any previous count.
      Parameters:
      key -
      count -
    • put

      public void put(E key, double count, boolean keepHigher)
      Set the count for the given key if it is larger than the previous one;
      Parameters:
      key -
      count -
    • sample

      public E sample(Random rand)
      Will return a sample from the counter, will throw exception if any of the counts are invalid input: '<' 0.0 or if the totalCount() invalid input: '<'= 0.0
      Returns:
    • sample

      public E sample()
      Will return a sample from the counter, will throw exception if any of the counts are invalid input: '<' 0.0 or if the totalCount() invalid input: '<'= 0.0
      Returns:
    • removeKey

      public void removeKey(E key)
    • removeKeyFromEntries

      protected void removeKeyFromEntries(E key)
      Parameters:
      key -
    • setMaxCount

      public void setMaxCount(E key, double val)
      Set's the key's count to the maximum of the current count and val. Always sets to val if key is not yet present.
      Parameters:
      key -
      val -
    • setMinCount

      public void setMinCount(E key, double val)
      Set's the key's count to the minimum of the current count and val. Always sets to val if key is not yet present.
      Parameters:
      key -
      val -
    • incrementCount

      public double incrementCount(E key, double increment)
      Increment a key's count by the given amount.
      Parameters:
      key -
      increment -
    • incrementAll

      public void incrementAll(Collection<? extends E> collection, double count)
      Increment each element in a given collection by a given amount.
    • incrementAll

      public <T extends E> void incrementAll(Counter<T> counter)
    • incrementAll

      public <T extends E> void incrementAll(Counter<T> counter, double scale)
    • totalCount

      public double totalCount()
      Finds the total of all counts in the counter. This implementation iterates through the entire counter every time this method is called.
      Returns:
      the counter's total
    • getEntriesSortedByIncreasingCount

      public Collection<Map.Entry<E,Double>> getEntriesSortedByIncreasingCount()
    • getEntriesSortedByDecreasingCount

      public Collection<Map.Entry<E,Double>> getEntriesSortedByDecreasingCount()
    • argMax

      public E argMax()
      Finds the key with maximum count. This is a linear operation, and ties are broken arbitrarily.
      Returns:
      a key with minumum count
    • min

      public double min()
    • max

      public double max()
    • toString

      public String toString()
      Returns a string representation with the keys ordered by decreasing counts.
      Overrides:
      toString in class Object
      Returns:
      string representation
    • toStringSortedByKeys

      public String toStringSortedByKeys()
    • pruneKeysBelowThreshold

      public void pruneKeysBelowThreshold(double cutoff)
    • getEntrySet

      public Set<Map.Entry<E,Double>> getEntrySet()
    • isEqualTo

      public boolean isEqualTo(Counter<E> counter)
    • main

      public static void main(String[] args)
    • clear

      public void clear()
    • setAllCounts

      public void setAllCounts(double val)
      Sets all counts to the given value, but does not remove any keys
    • dotProduct

      public double dotProduct(Counter<E> other)
    • scale

      public void scale(double c)
    • scaledClone

      public Counter<E> scaledClone(double c)
    • difference

      public Counter<E> difference(Counter<E> counter)
    • toLogSpace

      public Counter<E> toLogSpace()
    • approxEquals

      public boolean approxEquals(Counter<E> other, double tol)
    • setDirty

      public void setDirty(boolean dirty)
    • values

      public Iterable<Double> values()
    • prune

      public void prune(Set<E> toRemove)
    • pruneExcept

      public void pruneExcept(Set<E> toKeep)
    • absCounts

      public static <L> Counter<L> absCounts(Counter<L> counts)
    • putAll

      public void putAll(double d)