CTable

Instance Constructors

new CTable()(implicit n: Numeric[A])

Abstract Value Members

abstract val cols: Int

The number of columns in the table.
abstract val rows: Int

The number of rows in the table.
abstract val table: Vector[Vector[A]]

The table of counts, as a matrix of integers.

Concrete 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
final def asInstanceOf[T0]: T0

Definition Classes
Any
lazy val cTableWithDoubles: ContingencyTable[Double]
def clone(): AnyRef

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

Conditional entropy of the column variable, H(Col|Row).
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
lazy val condRowEntropy: Double

Conditional entropy of the row variable, H(Row|Col).
lazy val ctVals: Map[String, Double]

Map of strings to various CTable values
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)].
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
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
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
lazy val margColEntropy: Double

Marginal entropy of the column variable.
def margEntFunc: (Vector[A]) ⇒ Double

Composition to produce marginal entropy function
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
lazy val margRowEntropy: Double

Marginal entropy of the row variable.
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).
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.
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.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tableToFile(f: String): Unit

Writes a contingency table to a file (with space-delimited columns).
lazy val tableWithDoubles: Vector[Vector[Double]]

table with doubles
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.
lazy val ttable: Vector[Vector[A]]

The table of counts, transposed.
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 Docs: object CTable | package tables

abstract class CTable[A] extends AnyRef

Instance Constructors

new CTable()(implicit n: Numeric[A])

Abstract Value Members

abstract val cols: Int

abstract val rows: Int

abstract val table: Vector[Vector[A]]

Concrete 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 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

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

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 AnyRef

Inherited from Any

Ungrouped