MakeArrayComponent

Instance Constructors

new MakeArrayComponent(problem: Problem, makeArray: MakeArray[Value])

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 constraintFactors(bounds: Bounds = Lower): List[Factor[Double]]

Gets the constraint factors for this component.
Gets the constraint factors for this component. Returns the lower bound factors unless an Upper argument is provided.

Definition Classes
ProblemComponent
var constraintLower: List[Factor[Double]]

Lower bound factors resulting from conditions and constraints on this element.
Lower bound factors resulting from conditions and constraints on this element. These should be updated when the range changes but otherwise should be left alone.

Definition Classes
ProblemComponent
var constraintUpper: List[Factor[Double]]

Upper bound factors resulting from conditions and constraints on this element.
Upper bound factors resulting from conditions and constraints on this element. These should be updated when the range changes but otherwise should be left alone.

Definition Classes
ProblemComponent
val element: Element[FixedSizeArray[Value]]

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

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

Definition Classes
AnyRef → Any
def expand(): Unit

Expand all the potential items according to the maximum value in the range of the MakeArray's number of items.
Expand all the potential items according to the maximum value in the range of the MakeArray's number of items.

Definition Classes
MakeArrayComponent → ExpandableComponent
def expand(n: Int): Unit

Ensure that the given number of items is expanded.
Ensure that the given number of items is expanded.

Definition Classes
MakeArrayComponent → ExpandableComponent
val expandFunction: (Int) ⇒ Constant[FixedSizeArray[Value]]

Definition Classes
MakeArrayComponent → ExpandableComponent
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def generateRange(numValues: Int = ...): Unit

Generate a range of values for this component.
Generate a range of values for this component. Also sets the variable for this component. The optional argument is the number of values to include in the range. This argument is only used for atomic elements. If an argument is not in the component collection, we do not generate the argument, but instead assume its only value is *. This doesn't change the range of any other element or expand any subproblems. The range will include * based on argument ranges including * or any subproblem not being expanded.\

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

Definition Classes
AnyRef → Any
def hashCode(): Int

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

Definition Classes
Any
val makeArray: MakeArray[Value]
def makeConstraintFactors(bounds: Bounds = Lower): Unit

Generate the constraint factors based on the current range.
Generate the constraint factors based on the current range. Bounds specifies whether these should be created for computing lower or upper bounds.

Definition Classes
ProblemComponent
def makeNonConstraintFactors(parameterized: Boolean = false): Unit

Generate the non-constraint factors based on the current range.
Generate the non-constraint factors based on the current range. For most elements, this just generates the factors in the usual way. For a chain, this takes the current solution to the subproblems, which are lists of factors over this and other components. The parameterized flag indicates whether parameterized elements should have special factors created that use the MAP values of their arguments.

Definition Classes
ProblemComponent
var maxExpanded: Int

The maximum number of items expanded so far.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
var nonConstraintFactors: List[Factor[Double]]

All non-constraint factors resulting from the definition of this element.
All non-constraint factors resulting from the definition of this element. For many element classes, these factors will be generated directly in the usual way. For chains, they will include the solutions of subproblems.

Definition Classes
ProblemComponent
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val problem: Problem

Definition Classes
ProblemComponent
var range: ValueSet[FixedSizeArray[Value]]

The current range of the element.
The current range of the element. May grow or change over time.

Definition Classes
ProblemComponent
def setVariable(v: Variable[FixedSizeArray[Value]]): Unit

Set the variable associated with this component to the given variable.
Set the variable associated with this component to the given variable.

Definition Classes
ProblemComponent
var subproblems: Map[Int, NestedProblem[FixedSizeArray[Value]]]

The subproblems nested inside this expandable component.
The subproblems nested inside this expandable component. They are created for particular parent values.

Definition Classes
ExpandableComponent
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def variable: Variable[FixedSizeArray[Value]]

The current variable representing this component in factors.
The current variable representing this component in factors. This is set automatically when the range is updated.

Definition Classes
ProblemComponent
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 structured

class MakeArrayComponent[Value] extends ExpandableComponent[Int, FixedSizeArray[Value]]

Instance Constructors

new MakeArrayComponent(problem: Problem, makeArray: MakeArray[Value])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def constraintFactors(bounds: Bounds = Lower): List[Factor[Double]]

var constraintLower: List[Factor[Double]]

var constraintUpper: List[Factor[Double]]

val element: Element[FixedSizeArray[Value]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def expand(): Unit

def expand(n: Int): Unit

val expandFunction: (Int) ⇒ Constant[FixedSizeArray[Value]]

def finalize(): Unit

def generateRange(numValues: Int = ...): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

val makeArray: MakeArray[Value]

def makeConstraintFactors(bounds: Bounds = Lower): Unit

def makeNonConstraintFactors(parameterized: Boolean = false): Unit

var maxExpanded: Int

final def ne(arg0: AnyRef): Boolean

var nonConstraintFactors: List[Factor[Double]]

final def notify(): Unit

final def notifyAll(): Unit

val problem: Problem

var range: ValueSet[FixedSizeArray[Value]]

def setVariable(v: Variable[FixedSizeArray[Value]]): Unit

var subproblems: Map[Int, NestedProblem[FixedSizeArray[Value]]]

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

def toString(): String

def variable: Variable[FixedSizeArray[Value]]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from ExpandableComponent[Int, FixedSizeArray[Value]]

Inherited from ProblemComponent[FixedSizeArray[Value]]

Inherited from AnyRef

Inherited from Any

Ungrouped