ContingencyTable

Instance Constructors

new ContingencyTable(t: Vector[Vector[A]])(implicit n: Numeric[A])

t
two dimensional table of values

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def apply(s: String): Double

Makes CTable callable, retrieving values according to String keys in ctVals
Makes CTable callable, retrieving values according to String keys in ctVals
s
string present in ctVals' keys

Definition Classes
CTable
final def asInstanceOf[T0]: T0

Definition Classes
Any
lazy val cTableWithDoubles: ContingencyTable[Double]

Definition Classes
CTable
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
lazy val cols: Int

The number of columns in the table.
The number of columns in the table.

Definition Classes
ContingencyTable → CTable
lazy val condColEntropy: Double

Conditional entropy of the column variable, H(Col|Row).
Conditional entropy of the column variable, H(Col|Row).

Definition Classes
CTable
def condEntropy(t: Vector[Vector[A]]): Double

Returns the conditional entropy of a 2D table (rows conditioned on cols).
Returns the conditional entropy of a 2D table (rows conditioned on cols).
For a contingency table for two random variables X = {x1, x2, x3 ...} and Y = {y1, y2, y3 ...}, of the form
```
|    y1  y2  y3 ...
| x1  .   .   . ...
| x2  .   .   . ...
| x3  .   .   . ...
| ...
```
this function calculates the entropy of the row variable X conditional on the column variable Y, H(X|Y).
t
2-dimensional vector of integer vectors
returns
conditional entropy

Definition Classes
CTable
lazy val condRowEntropy: Double

Conditional entropy of the row variable, H(Row|Col).
Conditional entropy of the row variable, H(Row|Col).

Definition Classes
CTable
lazy val ctVals: Map[String, Double]

Map of strings to various CTable values
Map of strings to various CTable values

Definition Classes
CTable
def eTerm(prob: Double): Double

Calculates an entropy term from a probability.
Calculates an entropy term from a probability.
Note that this function returns the term p*log2(p) for a probability p, which is always negative. Callers of this function must therefore take the negative of sums of entropies calculated using this function, as the definition of entropy is E[-log(P(X)].

Definition Classes
CTable
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(ct: Any): Boolean

Checks two contingency tables for equality.
Checks two contingency tables for equality.

Definition Classes
CTable → AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def generateCtPos(rand: Boolean = false): List[CtPos]

Converts the probability table to a list of CtPos instances for sorting by probability
Converts the probability table to a list of CtPos instances for sorting by probability

Definition Classes
CTable
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
lazy val jointProbTable: Vector[Vector[Double]]

table entries as frequencies
table entries as frequencies

Definition Classes
CTable
def mapNegSum[T](f: (T) ⇒ Double): (TraversableOnce[T]) ⇒ Double

Higher order function that returns a function for calculating the negated sum of a numerical data set that has a another function applied to it
Higher order function that returns a function for calculating the negated sum of a numerical data set that has a another function applied to it
f
function to apply to numerical data
returns
function which applies f to a data set and calculates the negation of the resulting sum

Definition Classes
CTable
lazy val margColEntropy: Double

Marginal entropy of the column variable.
Marginal entropy of the column variable.

Definition Classes
CTable
def margEntFunc: (Vector[A]) ⇒ Double

Composition to produce marginal entropy function
Composition to produce marginal entropy function

Definition Classes
CTable
def margEntropy(t: Vector[Vector[A]]): Double

Returns the marginal entropy (marginalized across columns) of a 2D table.
Returns the marginal entropy (marginalized across columns) of a 2D table.
For a contingency table for two random variables X = {x1, x2, x3 ...} and Y = {y1, y2, y3 ...}, of the form
```
|    y1  y2  y3 ...
| x1  .   .   . ...
| x2  .   .   . ...
| x3  .   .   . ...
| ...
```
this function calculates the marginal entropy of the row variable X, H(X).
t
2-dimensional vector of integer vectors
returns
marginal entropy

Definition Classes
CTable
lazy val margRowEntropy: Double

Marginal entropy of the row variable.
Marginal entropy of the row variable.

Definition Classes
CTable
lazy val mutualInformation: Double

Mutual information calculated via entropies.
Mutual information calculated via entropies.
Since mutual information is symmetric, it can be calculated either in terms of the row variable or the column variable (here it is calculated in terms of the row variable).

Definition Classes
CTable
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val numSamples: A

The total number of samples (the sum of all counts in the table).
The total number of samples (the sum of all counts in the table).
Note: depending on the weighting scheme being used, this number may be 0, leading to NaN in output.

Definition Classes
CTable
def probVect: (Vector[A]) ⇒ Double

Converts a vector of counts to a marginal probability.
Converts a vector of counts to a marginal probability.
Takes the sum of all counts in the vector and divides by the total number of samples in the table to give the probability of observing any of the events tabulated in that vector.

Definition Classes
CTable
lazy val rows: Int

The number of rows in the table.
The number of rows in the table.

Definition Classes
ContingencyTable → CTable
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
lazy val table: Vector[Vector[A]]

The table of counts, as a matrix of integers.
The table of counts, as a matrix of integers.

Definition Classes
ContingencyTable → CTable
def tableToFile(f: String): Unit

Writes a contingency table to a file (with space-delimited columns).
Writes a contingency table to a file (with space-delimited columns).

Definition Classes
CTable
lazy val tableWithDoubles: Vector[Vector[Double]]

table with doubles
table with doubles

Definition Classes
CTable
def toString(): String

Pretty-prints contingency table to string
Pretty-prints contingency table to string

Definition Classes
CTable → AnyRef → Any
lazy val transferEfficiency: Double

The transfer efficiency is the amount of information transmitted, normalized by the maximum possible information transfer, ie, the marginal entropy of the input distribution.
The transfer efficiency is the amount of information transmitted, normalized by the maximum possible information transfer, ie, the marginal entropy of the input distribution.

Definition Classes
CTable
lazy val ttable: Vector[Vector[A]]

The table of counts, transposed.
The table of counts, transposed.

Definition Classes
CTable
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package tables

class ContingencyTable[A] extends CTable[A]

Instance Constructors

new ContingencyTable(t: Vector[Vector[A]])(implicit n: Numeric[A])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply(s: String): Double

final def asInstanceOf[T0]: T0

lazy val cTableWithDoubles: ContingencyTable[Double]

def clone(): AnyRef

lazy val cols: Int

lazy val condColEntropy: Double

def condEntropy(t: Vector[Vector[A]]): Double

lazy val condRowEntropy: Double

lazy val ctVals: Map[String, Double]

def eTerm(prob: Double): Double

final def eq(arg0: AnyRef): Boolean

def equals(ct: Any): Boolean

def finalize(): Unit

def generateCtPos(rand: Boolean = false): List[CtPos]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

lazy val jointProbTable: Vector[Vector[Double]]

def mapNegSum[T](f: (T) ⇒ Double): (TraversableOnce[T]) ⇒ Double

lazy val margColEntropy: Double

def margEntFunc: (Vector[A]) ⇒ Double

def margEntropy(t: Vector[Vector[A]]): Double

lazy val margRowEntropy: Double

lazy val mutualInformation: Double

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val numSamples: A

def probVect: (Vector[A]) ⇒ Double

lazy val rows: Int

final def synchronized[T0](arg0: ⇒ T0): T0

lazy val table: Vector[Vector[A]]

def tableToFile(f: String): Unit

lazy val tableWithDoubles: Vector[Vector[Double]]

def toString(): String

lazy val transferEfficiency: Double

lazy val ttable: Vector[Vector[A]]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from CTable[A]

Inherited from AnyRef

Inherited from Any

Ungrouped