TwoDimensionalCounter (Stanford JavaNLP API)

java.lang.Object
- edu.stanford.nlp.stats.TwoDimensionalCounter<K1,K2>

All Implemented Interfaces:

TwoDimensionalCounterInterface<K1,K2>, java.io.Serializable
```
public class TwoDimensionalCounter<K1,K2>
extends java.lang.Object
implements TwoDimensionalCounterInterface<K1,K2>, java.io.Serializable
```
A class representing a mapping between pairs of typed objects and double values.

Author:

Teg Grenager

See Also:

Serialized Form

Constructor Summary

Constructors
Constructor and Description
`TwoDimensionalCounter()`
`TwoDimensionalCounter(MapFactory<K1,ClassicCounter<K2>> outerFactory, MapFactory<K2,MutableDouble> innerFactory)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addAll(K1 key, Counter<K2> c)`
`void`	`addAll(TwoDimensionalCounterInterface<K1,K2> c)`
`void`	`clean()`
`void`	`clear()` clears the map, total and default value
`boolean`	`containsFirstKey(K1 o1)`
`boolean`	`containsKey(K1 o1, K2 o2)`
`void`	`decrementCount(K1 o1, K2 o2)`
`void`	`decrementCount(K1 o1, K2 o2, double count)`
`double`	`defaultReturnValue()`
`void`	`defaultReturnValue(double rv)`
`java.util.Set<java.util.Map.Entry<K1,ClassicCounter<K2>>>`	`entrySet()`
`boolean`	`equals(java.lang.Object o)`
`java.util.Set<K1>`	`firstKeySet()`
`ClassicCounter<Pair<K1,K2>>`	`flatten()`
`double`	`getCount(K1 o1, K2 o2)`
`ClassicCounter<K2>`	`getCounter(K1 o)`
`MapFactory<K2,MutableDouble>`	`getInnerMapFactory()`
`MapFactory<K1,ClassicCounter<K2>>`	`getOuterMapFactory()`
`int`	`hashCode()`
`static <K1,K2> TwoDimensionalCounter<K1,K2>`	`identityHashMapCounter()`
`void`	`incrementCount(K1 o1, K2 o2)`
`void`	`incrementCount(K1 o1, K2 o2, double count)`
`boolean`	`isEmpty()`
`static void`	`main(java.lang.String[] args)`
`void`	`recomputeTotal()`
`void`	`remove(K1 key)`
`double`	`remove(K1 o1, K2 o2)`
`void`	`removeZeroCounts()`
`static <K1,K2> TwoDimensionalCounter<K2,K1>`	`reverseIndexOrder(TwoDimensionalCounter<K1,K2> cc)` Produces a new ConditionalCounter.
`java.util.Set<K2>`	`secondKeySet()`
`void`	`setCount(K1 o1, K2 o2, double count)`
`ClassicCounter<K2>`	`setCounter(K1 o, Counter<K2> c)` replace the counter for K1-index o by new counter c
`int`	`size()`
`int`	`sizeOuterMap()`
`void`	`subtractAll(K1 key, Counter<K2> c)`
`void`	`subtractAll(TwoDimensionalCounterInterface<K1,K2> c, boolean removeKeys)`
`Counter<K1>`	`sumInnerCounter()` Returns the counters with keys as the first key and count as the total count of the inner counter for that key
`java.lang.String`	`toCSVString(java.text.NumberFormat nf)`
`double[][]`	`toMatrix(java.util.List<K1> firstKeys, java.util.List<K2> secondKeys)` Given an ordering of the first (row) and second (column) keys, will produce a double matrix.
`java.lang.String`	`toMatrixString(int cellSize)`
`java.lang.String`	`toMatrixString(int cellSize, java.text.NumberFormat nf)`
`java.lang.String`	`toString()` A simple String representation of this TwoDimensionalCounter, which has the String representation of each key pair on a separate line, followed by the count for that pair.
`double`	`totalCount()` Takes linear time.
`double`	`totalCount(K1 k1)`

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

- Constructor Detail
  - TwoDimensionalCounter
```
public TwoDimensionalCounter()
```
  - TwoDimensionalCounter
```
public TwoDimensionalCounter(MapFactory<K1,ClassicCounter<K2>> outerFactory,
                             MapFactory<K2,MutableDouble> innerFactory)
```
- Method Detail
  - defaultReturnValue
```
public void defaultReturnValue(double rv)
```
    Specified by:
    
    defaultReturnValue in interface TwoDimensionalCounterInterface<K1,K2>
  - defaultReturnValue
```
public double defaultReturnValue()
```
    Specified by:
    
    defaultReturnValue in interface TwoDimensionalCounterInterface<K1,K2>
  - equals
```
public boolean equals(java.lang.Object o)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - getCounter
```
public ClassicCounter<K2> getCounter(K1 o)
```
    Specified by:
    
    getCounter in interface TwoDimensionalCounterInterface<K1,K2>
    
    Returns:
    
    the inner Counter associated with key o
  - entrySet
```
public java.util.Set<java.util.Map.Entry<K1,ClassicCounter<K2>>> entrySet()
```
  - size
```
public int size()
```
    Specified by:
    
    size in interface TwoDimensionalCounterInterface<K1,K2>
    
    Returns:
    
    total number of entries (key pairs)
  - sizeOuterMap
```
public int sizeOuterMap()
```
    Returns:
    
    size of the outer map
  - containsKey
```
public boolean containsKey(K1 o1,
                           K2 o2)
```
    Specified by:
    
    containsKey in interface TwoDimensionalCounterInterface<K1,K2>
  - containsFirstKey
```
public boolean containsFirstKey(K1 o1)
```
  - incrementCount
```
public void incrementCount(K1 o1,
                           K2 o2)
```
    Specified by:
    
    incrementCount in interface TwoDimensionalCounterInterface<K1,K2>
  - incrementCount
```
public void incrementCount(K1 o1,
                           K2 o2,
                           double count)
```
    Specified by:
    
    incrementCount in interface TwoDimensionalCounterInterface<K1,K2>
  - decrementCount
```
public void decrementCount(K1 o1,
                           K2 o2)
```
    Specified by:
    
    decrementCount in interface TwoDimensionalCounterInterface<K1,K2>
  - decrementCount
```
public void decrementCount(K1 o1,
                           K2 o2,
                           double count)
```
    Specified by:
    
    decrementCount in interface TwoDimensionalCounterInterface<K1,K2>
  - setCount
```
public void setCount(K1 o1,
                     K2 o2,
                     double count)
```
    Specified by:
    
    setCount in interface TwoDimensionalCounterInterface<K1,K2>
  - remove
```
public double remove(K1 o1,
                     K2 o2)
```
    Specified by:
    
    remove in interface TwoDimensionalCounterInterface<K1,K2>
  - getCount
```
public double getCount(K1 o1,
                       K2 o2)
```
    Specified by:
    
    getCount in interface TwoDimensionalCounterInterface<K1,K2>
  - totalCount
```
public double totalCount()
```
    Takes linear time.
    
    Specified by:
    
    totalCount in interface TwoDimensionalCounterInterface<K1,K2>
  - totalCount
```
public double totalCount(K1 k1)
```
    Specified by:
    
    totalCount in interface TwoDimensionalCounterInterface<K1,K2>
  - firstKeySet
```
public java.util.Set<K1> firstKeySet()
```
    Specified by:
    
    firstKeySet in interface TwoDimensionalCounterInterface<K1,K2>
  - setCounter
```
public ClassicCounter<K2> setCounter(K1 o,
                                     Counter<K2> c)
```
    replace the counter for K1-index o by new counter c
  - reverseIndexOrder
```
public static <K1,K2> TwoDimensionalCounter<K2,K1> reverseIndexOrder(TwoDimensionalCounter<K1,K2> cc)
```
    Produces a new ConditionalCounter.
    
    Returns:
    
    a new ConditionalCounter, where order of indices is reversed
  - toString
```
public java.lang.String toString()
```
    A simple String representation of this TwoDimensionalCounter, which has the String representation of each key pair on a separate line, followed by the count for that pair. The items are tab separated, so the result is a tab-separated value (TSV) file. Iff none of the keys contain spaces, it will also be possible to treat this as whitespace separated fields.
    
    Overrides:
    
    toString in class java.lang.Object
  - toMatrixString
```
public java.lang.String toMatrixString(int cellSize)
```
    Specified by:
    
    toMatrixString in interface TwoDimensionalCounterInterface<K1,K2>
  - toMatrixString
```
public java.lang.String toMatrixString(int cellSize,
                                       java.text.NumberFormat nf)
```
  - toMatrix
```
public double[][] toMatrix(java.util.List<K1> firstKeys,
                           java.util.List<K2> secondKeys)
```
    Given an ordering of the first (row) and second (column) keys, will produce a double matrix.
    
    Specified by:
    
    toMatrix in interface TwoDimensionalCounterInterface<K1,K2>
  - toCSVString
```
public java.lang.String toCSVString(java.text.NumberFormat nf)
```
    Specified by:
    
    toCSVString in interface TwoDimensionalCounterInterface<K1,K2>
  - secondKeySet
```
public java.util.Set<K2> secondKeySet()
```
    Specified by:
    
    secondKeySet in interface TwoDimensionalCounterInterface<K1,K2>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface TwoDimensionalCounterInterface<K1,K2>
  - flatten
```
public ClassicCounter<Pair<K1,K2>> flatten()
```
  - addAll
```
public void addAll(TwoDimensionalCounterInterface<K1,K2> c)
```
  - addAll
```
public void addAll(K1 key,
                   Counter<K2> c)
```
  - subtractAll
```
public void subtractAll(K1 key,
                        Counter<K2> c)
```
  - subtractAll
```
public void subtractAll(TwoDimensionalCounterInterface<K1,K2> c,
                        boolean removeKeys)
```
  - sumInnerCounter
```
public Counter<K1> sumInnerCounter()
```
    Returns the counters with keys as the first key and count as the total count of the inner counter for that key
    
    Returns:
    
    counter of type K1
  - removeZeroCounts
```
public void removeZeroCounts()
```
  - remove
```
public void remove(K1 key)
```
    Specified by:
    
    remove in interface TwoDimensionalCounterInterface<K1,K2>
  - clear
```
public void clear()
```
    clears the map, total and default value
  - clean
```
public void clean()
```
  - getOuterMapFactory
```
public MapFactory<K1,ClassicCounter<K2>> getOuterMapFactory()
```
  - getInnerMapFactory
```
public MapFactory<K2,MutableDouble> getInnerMapFactory()
```
  - identityHashMapCounter
```
public static <K1,K2> TwoDimensionalCounter<K1,K2> identityHashMapCounter()
```
  - recomputeTotal
```
public void recomputeTotal()
```
  - main
```
public static void main(java.lang.String[] args)
```

Class TwoDimensionalCounter<K1,K2>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

TwoDimensionalCounter

TwoDimensionalCounter

Method Detail

defaultReturnValue

defaultReturnValue

equals

hashCode

getCounter

entrySet

size

sizeOuterMap

containsKey

containsFirstKey

incrementCount

incrementCount

decrementCount

decrementCount

setCount

remove

getCount

totalCount

totalCount

firstKeySet

setCounter

reverseIndexOrder

toString

toMatrixString

toMatrixString

toMatrix

toCSVString

secondKeySet

isEmpty

flatten

addAll

addAll

subtractAll

subtractAll

sumInnerCounter

removeZeroCounts

remove

clear

clean

getOuterMapFactory

getInnerMapFactory

identityHashMapCounter

recomputeTotal

main