ConstraintFactor

Instance Constructors

new ConstraintFactor(parents: List[Variable[_]], output: List[Variable[_]], _semiring: Semiring[T] = ...)(implicit tag: scala.reflect.api.JavaUniverse.TypeTag[T])

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

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def combination(that: Factor[T], op: (T, T) ⇒ T): Factor[T]

produces a new Factor from the combined input variables of the input factors.
produces a new Factor from the combined input variables of the input factors.
The factor values are computed using the corresponding values from the input factors. This correspondence is determined by the indices of the input factors that overlap with each of the indices of the result factor
that
The Factor to combine with this one
op
The operation used to combine (multiply) factor values
returns
The new Factor containing the combined values of the inputs

Definition Classes
BasicFactor → Factor
def contains(index: List[Int]): Boolean

Definition Classes
Factor
var contents: Map[List[Int], T]

Attributes
protected[com.cra.figaro]
Definition Classes
Factor
def convert[U](semiring: Semiring[U]): Factor[U]

Creates a new Factor of the same class with a different type and semiring
Creates a new Factor of the same class with a different type and semiring

Definition Classes
BasicFactor → Factor
def convertIndicesToValues(indices: List[Int]): List[Extended[_]]

Definition Classes
Factor
def createFactor[T](parents: List[Variable[_]], output: List[Variable[_]], _semiring: Semiring[T] = semiring): Factor[T]

Creates a new factor of the same type
Creates a new factor of the same type

Definition Classes
BasicFactor → Factor
def deDuplicate(): Factor[T]

Returns a new Factor with duplicate variable(s) removed
Returns a new Factor with duplicate variable(s) removed

Definition Classes
BasicFactor → Factor
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def fillByRule(rule: (List[Extended[_]]) ⇒ T): Factor[T]

Fill the contents of this factor by applying a rule to every combination of parent and output values.
Fill the contents of this factor by applying a rule to every combination of parent and output values.

Definition Classes
BasicFactor → Factor
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
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
Fold the given function through the contents of the factor, beginning with the given initial values

Definition Classes
Factor
def generateIndices: Indices

Definition Classes
Factor
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.

Definition Classes
BasicFactor → Factor
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getIndices: Indices

Definition Classes
Factor
def hasStar: Boolean

Indicates if any of this Factor's variables has Star
Indicates if any of this Factor's variables has Star

Definition Classes
Factor
def hashCode(): Int

Definition Classes
AnyRef → Any
val isConstraint: Boolean

Indicates if this Factor is condition/constrained
Indicates if this Factor is condition/constrained

Definition Classes
ConstraintFactor → Factor
def isEmpty: Boolean

Indicates if this Factor has any variables
Indicates if this Factor has any variables

Definition Classes
Factor
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def mapTo[U](fn: (T) ⇒ U, _semiring: Semiring[U] = semiring): Factor[U]

Convert the contents of the target by applying the given function to all elements of this factor.
Convert the contents of the target by applying the given function to all elements of this factor.

Definition Classes
BasicFactor → Factor
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.

Definition Classes
BasicFactor → Factor
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
lazy val numVars: Int

Definition Classes
Factor
val output: List[Variable[_]]

The single output variable for this factor
The single output variable for this factor

Definition Classes
BasicFactor → Factor
val parents: List[Variable[_]]

A list of parent variables for this factor representing all the dependencies of this factor
A list of parent variables for this factor representing all the dependencies of this factor

Definition Classes
BasicFactor → Factor
def product(that: Factor[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 the combined variables of the two inputs, and the value associated with an assignment is the product of the values in the two inputs.

Definition Classes
BasicFactor → Factor
def recordArgMax[U](variable: Variable[U], comparator: (T, T) ⇒ Boolean, _semiring: Semiring[U] = semiring.asInstanceOf[Semiring[U]]): 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.

Definition Classes
BasicFactor → Factor
val semiring: Semiring[T]

A Semiring class that defines the operations (sum/max, product) to be used in this factor.
A Semiring class that defines the operations (sum/max, product) to be used in this factor. This defaults to SumProductSemiring

Definition Classes
BasicFactor → Factor
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.

Definition Classes
Factor
val size: Int

Definition Classes
Factor
def sumOver(variable: Variable[_]): 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.

Definition Classes
BasicFactor → Factor
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toReadableString: String

Produce a readable string representation of the factor
Produce a readable string representation of the factor

Definition Classes
BasicFactor → Factor
def toString(): String

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

Definition Classes
Factor → AnyRef → Any
def unionVars[U](that: Factor[U]): (List[Variable[_]], List[Variable[_]], List[Int], List[Int])

takes the variables in two factors and produces their set union.
takes the variables in two factors and produces their set union.
It produces a mapping from each original variable to its new location. Similarly it produces a mapping from each new variable to its new location.

Definition Classes
BasicFactor
def variables: List[Variable[_]]

Definition Classes
Factor
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( ... )

class ConstraintFactor[T] extends BasicFactor[T]

Instance Constructors

new ConstraintFactor(parents: List[Variable[_]], output: List[Variable[_]], _semiring: Semiring[T] = ...)(implicit tag: scala.reflect.api.JavaUniverse.TypeTag[T])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

def contains(index: List[Int]): Boolean

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

def convert[U](semiring: Semiring[U]): Factor[U]

def convertIndicesToValues(indices: List[Int]): List[Extended[_]]

def createFactor[T](parents: List[Variable[_]], output: List[Variable[_]], _semiring: Semiring[T] = semiring): Factor[T]

def deDuplicate(): Factor[T]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

def finalize(): Unit

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

def generateIndices: Indices

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

final def getClass(): Class[_]

def getIndices: Indices

def hasStar: Boolean

def hashCode(): Int

val isConstraint: Boolean

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def mapTo[U](fn: (T) ⇒ U, _semiring: Semiring[U] = semiring): Factor[U]

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

lazy val numVars: Int

val output: List[Variable[_]]

val parents: List[Variable[_]]

def product(that: Factor[T]): Factor[T]

def recordArgMax[U](variable: Variable[U], comparator: (T, T) ⇒ Boolean, _semiring: Semiring[U] = semiring.asInstanceOf[Semiring[U]]): Factor[U]

val semiring: Semiring[T]

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

val size: Int

def sumOver(variable: Variable[_]): Factor[T]

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

def toReadableString: String

def toString(): String

def unionVars[U](that: Factor[U]): (List[Variable[_]], List[Variable[_]], List[Int], List[Int])

def variables: List[Variable[_]]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from BasicFactor[T]

Inherited from Factor[T]

Inherited from AnyRef

Inherited from Any

Ungrouped