Counter (deeplearning4j-core 0.0.3.2 API)

java.lang.Object
- org.deeplearning4j.berkeley.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:

Dan Klein

See Also:

Serialized Form

Constructor Summary

Constructors
Constructor and Description
`Counter()`
`Counter(boolean identityHashMap)`
`Counter(Collection<? extends E> collection)`
`Counter(Counter<? extends E> counter)`
`Counter(Map<? extends E,Double> mapCounts)`
`Counter(MapFactory<E,Double> mf)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`approxEquals(Counter<E> other, double tol)`
`E`	`argMax()` Finds the key with maximum count.
`PriorityQueue<E>`	`asMinPriorityQueue()` Warning: all priorities are the negative of their counts in the counter here
`PriorityQueue<E>`	`asPriorityQueue()` Builds a priority queue whose elements are the counter's elements, and whose priorities are those elements' counts in the counter.
`void`	`clear()`
`boolean`	`containsKey(E key)` Returns whether the counter contains the given key.
`Counter<E>`	`difference(Counter<E> counter)`
`double`	`dotProduct(Counter<E> other)`
`Set<Map.Entry<E,Double>>`	`entrySet()`
`double`	`getCount(E key)` Get the count of the element, or zero if the element is not in the counter.
`double`	`getDeflt()`
`Set<Map.Entry<E,Double>>`	`getEntrySet()`
`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.
`List<E>`	`getSortedKeys()`
`void`	`incrementAll(Collection<? extends E> collection, double count)` Increment each element in a given collection by a given amount.
`<T extends E> void`	`incrementAll(Counter<T> counter)`
`double`	`incrementCount(E key, double increment)` Increment a key's count by the given amount.
`boolean`	`isEmpty()` True if there are no entries in the counter (false does not mean totalCount > 0)
`boolean`	`isEqualTo(Counter<E> counter)`
`void`	`keepBottomNKeys(int keepN)`
`void`	`keepTopNKeys(int keepN)`
`Set<E>`	`keySet()` The elements in the counter.
`static void`	`main(String[] args)`
`double`	`max()`
`double`	`min()`
`void`	`normalize()` Destructively normalize this Counter in place.
`void`	`pruneKeysBelowThreshold(double cutoff)`
`void`	`put(E key, double count, boolean keepHigher)` Set the count for the given key if it is larger than the previous one;
`void`	`removeKey(E key)`
`protected void`	`removeKeyFromEntries(E key)`
`E`	`sample()` Will return a sample from the counter, will throw exception if any of the counts are < 0.0 or if the totalCount() <= 0.0
`E`	`sample(Random rand)` Will return a sample from the counter, will throw exception if any of the counts are < 0.0 or if the totalCount() <= 0.0
`void`	`scale(double c)`
`Counter<E>`	`scaledClone(double c)`
`void`	`setAllCounts(double val)` Sets all counts to the given value, but does not remove any keys
`void`	`setCount(E key, double count)` Set the count for the given key, clobbering any previous count.
`void`	`setDeflt(double deflt)`
`void`	`setDirty(boolean dirty)`
`void`	`setMaxCount(E key, double val)` Set's the key's count to the maximum of the current count and val.
`void`	`setMinCount(E key, double val)` Set's the key's count to the minimum of the current count and val.
`int`	`size()` The number of entries in the counter (not the total count -- use totalCount() instead).
`Counter<E>`	`toLogSpace()`
`String`	`toString()` Returns a string representation with the keys ordered by decreasing counts.
`String`	`toString(int maxKeysToPrint)` Returns a string representation which includes no more than the maxKeysToPrint elements with largest counts.
`String`	`toString(int maxKeysToPrint, boolean multiline)` Returns a string representation which includes no more than the maxKeysToPrint elements with largest counts and optionally prints one element per line.
`String`	`toStringSortedByKeys()`
`String`	`toStringTabSeparated()`
`double`	`totalCount()` Finds the total of all counts in the counter.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - Counter
```
public Counter()
```
  - Counter
```
public Counter(boolean identityHashMap)
```
  - Counter
```
public Counter(MapFactory<E,Double> mf)
```
  - Counter
```
public Counter(Map<? extends E,Double> mapCounts)
```
  - Counter
```
public Counter(Counter<? extends E> counter)
```
  - Counter
```
public Counter(Collection<? extends E> collection)
```
- Method Detail
  - getDeflt
```
public double getDeflt()
```
  - setDeflt
```
public void setDeflt(double deflt)
```
  - keySet
```
public Set<E> keySet()
```
    The elements in the counter.
    
    Returns:
    
    applyTransformToDestination 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 < 0.0 or if the totalCount() <= 0.0
    
    Returns:
  - sample
```
public E sample()
```
    Will return a sample from the counter, will throw exception if any of the counts are < 0.0 or if the totalCount() <= 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 -
    
    increment -
  - 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 -
    
    increment -
  - 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)
```
  - 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
  - getSortedKeys
```
public List<E> getSortedKeys()
```
  - 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()
```
  - toString
```
public String toString(int maxKeysToPrint)
```
    Returns a string representation which includes no more than the maxKeysToPrint elements with largest counts.
    
    Parameters:
    
    maxKeysToPrint -
    
    Returns:
    
    partial string representation
  - toString
```
public String toString(int maxKeysToPrint,
                       boolean multiline)
```
    Returns a string representation which includes no more than the maxKeysToPrint elements with largest counts and optionally prints one element per line.
    
    Parameters:
    
    maxKeysToPrint -
    
    Returns:
    
    partial string representation
  - asPriorityQueue
```
public PriorityQueue<E> asPriorityQueue()
```
    Builds a priority queue whose elements are the counter's elements, and whose priorities are those elements' counts in the counter.
  - asMinPriorityQueue
```
public PriorityQueue<E> asMinPriorityQueue()
```
    Warning: all priorities are the negative of their counts in the counter here
    
    Returns:
  - 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()
```
  - keepTopNKeys
```
public void keepTopNKeys(int keepN)
```
  - keepBottomNKeys
```
public void keepBottomNKeys(int keepN)
```
  - 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)
```
  - toStringTabSeparated
```
public String toStringTabSeparated()
```

Class Counter<E>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Counter

Counter

Counter

Counter

Counter

Counter

Method Detail

getDeflt

setDeflt

keySet

entrySet

size

isEmpty

containsKey

getCount

getProbability

normalize

setCount

put

sample

sample

removeKey

removeKeyFromEntries

setMaxCount

setMinCount

incrementCount

incrementAll

incrementAll

totalCount

getSortedKeys

argMax

min

max

toString

toStringSortedByKeys

toString

toString

asPriorityQueue

asMinPriorityQueue

pruneKeysBelowThreshold

getEntrySet

isEqualTo

main

clear

keepTopNKeys

keepBottomNKeys

setAllCounts

dotProduct

scale

scaledClone

difference

toLogSpace

approxEquals

setDirty

toStringTabSeparated