Factor

Abstract Value Members

abstract def combination(that: Factor[T], op: (T, T) ⇒ T): Factor[T]

Generic combination function for factors.
Generic combination function for factors. By default, this is product, but other operations (such as divide that is a valid operation for some semirings) can use this
abstract def convert[U](): Factor[U]

Creates a new Factor of the same class with a different type
abstract def deDuplicate(): Factor[T]

Returns a new Factor with duplicate variable(s) removed
abstract def fillByRule(rule: (List[Extended[_]]) ⇒ T): Factor[T]

Fill the contents of this factor by applying a rule to every combination of values.
abstract def mapTo[U](fn: (T) ⇒ U): Factor[U]

Fill the contents of the target by applying the given function to all elements of this factor.
abstract def marginalizeTo(semiring: Semiring[T], targets: Variable[_]*): Factor[T]

Returns the marginalization of the factor to a variable according to the given addition function.
Returns the marginalization of the factor to a variable according to the given addition function. This involves summing out all other variables.
abstract def output: List[Variable[_]]
abstract def parents: List[Variable[_]]
abstract def product(that: Factor[T], semiring: Semiring[T]): Factor[T]

Returns the product of this factor with another factor according to a given multiplication function.
Returns the product of this factor with another factor according to a given multiplication function. The product is associated with all variables in the two inputs, and the value associated with an assignment is the product of the values in the two inputs.
abstract def recordArgMax[U](variable: Variable[U], comparator: (T, T) ⇒ Boolean): Factor[U]

Returns a factor that maps values of the other variables to the value of the given variable that maximizes the entry associated with that value, according to some maximization function.
Returns a factor that maps values of the other variables to the value of the given variable that maximizes the entry associated with that value, according to some maximization function. comparator defines the maximization. It returns true iff its second argument is greater than its first.
U
The type of element whose value is being recorded. The resulting factor maps values of other variables in this factor to this type.
abstract def sumOver(variable: Variable[_], semiring: Semiring[T]): Factor[T]

Returns the summation of the factor over a variable according to an addition function.
Returns the summation of the factor over a variable according to an addition function. The result is associated with all the variables in the input except for the summed over variable and the value for a set of assignments is the sum of the values of the corresponding assignments in the input.
abstract def toReadableString: String

Produce a readable string representation of the factor

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 allIndices: List[List[Int]]

Returns the indices lists corresponding to all the rows in order.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
var contents: Map[List[Int], T]

Attributes
protected[com.cra.figaro]
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def firstIndices: List[Int]

Returns the list of indices into the variable ranges associated with the first row in the factor.
def foldLeft(initial: T, fn: (T, T) ⇒ T): T

Fold the given function through the contents of the factor, beginning with the given initial values
def get(indices: List[Int]): T

Get the value associated with a row.
Get the value associated with a row. The row is identified by an list of indices into the ranges of the variables over which the factor is defined.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hasStar: Boolean

Indicates if any of this Factor's variables has Star
def hashCode(): Int

Definition Classes
AnyRef → Any
def isEmpty: Boolean

Indicates if this Factor has any variables
final def isInstanceOf[T0]: Boolean

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

Definition Classes
AnyRef
def nextIndices(indices: List[Int]): Option[List[Int]]

Given a list of indices corresponding to a row in the factor, returns the list of indices corresponding to the next row.
Given a list of indices corresponding to a row in the factor, returns the list of indices corresponding to the next row. Returns None if the last index list has been reached.
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
lazy val numVars: Int
def set(indices: List[Int], value: T): Factor[T]

Set the value associated with a row.
Set the value associated with a row. The row is identified by an list of indices into the ranges of the variables over which the factor is defined.
val size: Int
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Description that includes the variable list and conditional probabilites
Description that includes the variable list and conditional probabilites

Definition Classes
Factor → AnyRef → Any
def variables: List[Variable[_]]
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( ... )

trait Factor[T] extends AnyRef

Abstract Value Members

abstract def combination(that: Factor[T], op: (T, T) ⇒ T): Factor[T]

abstract def convert[U](): Factor[U]

abstract def deDuplicate(): Factor[T]

abstract def fillByRule(rule: (List[Extended[_]]) ⇒ T): Factor[T]

abstract def mapTo[U](fn: (T) ⇒ U): Factor[U]

abstract def marginalizeTo(semiring: Semiring[T], targets: Variable[_]*): Factor[T]

abstract def output: List[Variable[_]]

abstract def parents: List[Variable[_]]

abstract def product(that: Factor[T], semiring: Semiring[T]): Factor[T]

abstract def recordArgMax[U](variable: Variable[U], comparator: (T, T) ⇒ Boolean): Factor[U]

abstract def sumOver(variable: Variable[_], semiring: Semiring[T]): Factor[T]

abstract def toReadableString: String

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def allIndices: List[List[Int]]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

var contents: Map[List[Int], T]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def firstIndices: List[Int]

def foldLeft(initial: T, fn: (T, T) ⇒ T): T

def get(indices: List[Int]): T

final def getClass(): Class[_]

def hasStar: Boolean

def hashCode(): Int

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

def nextIndices(indices: List[Int]): Option[List[Int]]

final def notify(): Unit

final def notifyAll(): Unit

lazy val numVars: Int

def set(indices: List[Int], value: T): Factor[T]

val size: Int

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

def toString(): String

def variables: List[Variable[_]]

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