CounterMap (canova-api 0.0.0.15 API)

java.lang.Object
- org.canova.api.berkeley.CounterMap<K,V>

All Implemented Interfaces:

Serializable
```
public class CounterMap<K,V>
extends Object
implements Serializable
```
Maintains counts of (key, value) pairs. The map is structured so that for every key, one can getFromOrigin a counter over values. Example usage: keys might be words with values being POS tags, and the count being the number of occurences of that word/tag pair. The sub-counters returned by getCounter(word) would be count distributions over tags for that word.

Author:

Dan Klein

See Also:

Serialized Form

Constructor Summary

Constructors
Constructor and Description
`CounterMap()`
`CounterMap(boolean identityHashMap)`
`CounterMap(CounterMap<K,V> cm)`
`CounterMap(MapFactory<K,Counter<V>> outerMF, MapFactory<V,Double> innerMF)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Pair<K,V>`	`argMax()` Finds the key with maximum count.
`protected Counter<V>`	`buildCounter(MapFactory<V,Double> mf)`
`boolean`	`containsKey(K key)`
`protected Counter<V>`	`ensureCounter(K key)`
`double`	`getCount(K key)` Gets the total count of the given key, or zero if that key is not present.
`double`	`getCount(K key, V value)` Gets the count of the given (key, value) entry, or zero if that entry is not present.
`Counter<V>`	`getCounter(K key)` Gets the sub-counter for the given key.
`Collection<Counter<V>>`	`getCounters()`
`Set<Map.Entry<K,Counter<V>>>`	`getEntrySet()`
`Iterator<Pair<K,V>>`	`getPairIterator()`
`void`	`incrementAll(CounterMap<K,V> cMap)`
`void`	`incrementAll(Map<K,V> map, double count)`
`void`	`incrementCount(K key, V value, double count)` Increments the count for a particular (key, value) pair.
`CounterMap<V,K>`	`invert()` Constructs reverse CounterMap where the count of a pair (k,v) is the count of (v,k) in the current CounterMap
`boolean`	`isEmpty()` True if there are no entries in the CounterMap (false does not mean totalCount > 0)
`boolean`	`isEqualTo(CounterMap<K,V> map)`
`Set<K>`	`keySet()` Returns the keys that have been inserted into this CounterMap.
`static void`	`main(String[] args)`
`void`	`normalize()`
`void`	`normalizeWithDiscount(double discount)`
`void`	`removeKey(K oldIndex)`
`void`	`scale(double scaleFactor)` Scale all entries in `CounterMap` by `scaleFactor`
`void`	`setCount(K key, V value, double count)` Sets the count for a particular (key, value) pair.
`void`	`setCounter(K newIndex, Counter<V> counter)`
`void`	`setDefault(double defaultValue)`
`int`	`size()` The number of keys in this CounterMap (not the number of key-value entries -- use totalSize() for that)
`String`	`toString()`
`String`	`toString(Collection<String> keyFilter)`
`String`	`toString(int maxValsPerKey)`
`double`	`totalCount()` Returns the total of all counts in sub-counters.
`int`	`totalSize()` Returns the total number of (key, value) entries in the CounterMap (not their total counts).

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

- Constructor Detail
  - CounterMap
```
public CounterMap(CounterMap<K,V> cm)
```
  - CounterMap
```
public CounterMap()
```
  - CounterMap
```
public CounterMap(MapFactory<K,Counter<V>> outerMF,
                  MapFactory<V,Double> innerMF)
```
  - CounterMap
```
public CounterMap(boolean identityHashMap)
```
- Method Detail
  - ensureCounter
```
protected Counter<V> ensureCounter(K key)
```
  - getCounters
```
public Collection<Counter<V>> getCounters()
```
  - buildCounter
```
protected Counter<V> buildCounter(MapFactory<V,Double> mf)
```
    Returns:
  - keySet
```
public Set<K> keySet()
```
    Returns the keys that have been inserted into this CounterMap.
  - setCount
```
public void setCount(K key,
                     V value,
                     double count)
```
    Sets the count for a particular (key, value) pair.
  - incrementCount
```
public void incrementCount(K key,
                           V value,
                           double count)
```
    Increments the count for a particular (key, value) pair.
  - getCount
```
public double getCount(K key,
                       V value)
```
    Gets the count of the given (key, value) entry, or zero if that entry is not present. Does not createComplex any objects.
  - getCounter
```
public Counter<V> getCounter(K key)
```
    Gets the sub-counter for the given key. If there is none, a counter is created for that key, and installed in the CounterMap. You can, for example, add to the returned empty counter directly (though you shouldn't). This is so whether the key is present or not, modifying the returned counter has the same effect (but don't do it).
  - incrementAll
```
public void incrementAll(Map<K,V> map,
                         double count)
```
  - incrementAll
```
public void incrementAll(CounterMap<K,V> cMap)
```
  - getCount
```
public double getCount(K key)
```
    Gets the total count of the given key, or zero if that key is not present. Does not createComplex any objects.
  - totalCount
```
public double totalCount()
```
    Returns the total of all counts in sub-counters. This implementation is linear; it recalculates the total each time.
  - totalSize
```
public int totalSize()
```
    Returns the total number of (key, value) entries in the CounterMap (not their total counts).
  - size
```
public int size()
```
    The number of keys in this CounterMap (not the number of key-value entries -- use totalSize() for that)
  - isEmpty
```
public boolean isEmpty()
```
    True if there are no entries in the CounterMap (false does not mean totalCount > 0)
  - argMax
```
public Pair<K,V> argMax()
```
    Finds the key with maximum count. This is a linear operation, and ties are broken arbitrarily.
    
    Returns:
    
    a key with minumum count
  - toString
```
public String toString(int maxValsPerKey)
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - toString
```
public String toString(Collection<String> keyFilter)
```
  - isEqualTo
```
public boolean isEqualTo(CounterMap<K,V> map)
```
  - main
```
public static void main(String[] args)
```
  - normalize
```
public void normalize()
```
  - normalizeWithDiscount
```
public void normalizeWithDiscount(double discount)
```
  - invert
```
public CounterMap<V,K> invert()
```
    Constructs reverse CounterMap where the count of a pair (k,v) is the count of (v,k) in the current CounterMap
    
    Returns:
  - scale
```
public void scale(double scaleFactor)
```
    Scale all entries in CounterMap by scaleFactor
    
    Parameters:
    
    scaleFactor -
  - containsKey
```
public boolean containsKey(K key)
```
  - getPairIterator
```
public Iterator<Pair<K,V>> getPairIterator()
```
  - getEntrySet
```
public Set<Map.Entry<K,Counter<V>>> getEntrySet()
```
  - removeKey
```
public void removeKey(K oldIndex)
```
  - setCounter
```
public void setCounter(K newIndex,
                       Counter<V> counter)
```
  - setDefault
```
public void setDefault(double defaultValue)
```

Class CounterMap<K,V>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

CounterMap

CounterMap

CounterMap

CounterMap

Method Detail

ensureCounter

getCounters

buildCounter

keySet

setCount

incrementCount

getCount

getCounter

incrementAll

incrementAll

getCount

totalCount

totalSize

size

isEmpty

argMax

toString

toString

toString

isEqualTo

main

normalize

normalizeWithDiscount

invert

scale

containsKey

getPairIterator

getEntrySet

removeKey

setCounter

setDefault