SimpleGraphEquationSystem

Instance Constructors

new SimpleGraphEquationSystem(unknowns: Iterable[U], inputUnknowns: Set[U], edgeAction: EdgeAction[U, V, E], sources: (E) ⇒ Iterable[U], target: (E) ⇒ U, outgoing: (U) ⇒ Iterable[E], ingoing: (U) ⇒ Iterable[E], initial: InputAssignment[U, V], tracer: Option[EquationSystemTracer[U, V]] = None)(implicit dom: Domain[V])

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
val body: Body[U, V]

The body of the equation system, i.e., a map Assignment[U,V] => Assignment[U,V].
The body of the equation system, i.e., a map Assignment[U,V] => Assignment[U,V].

Definition Classes
SimpleGraphEquationSystem → EquationSystem
def bodyWithBaseAssignment(init: PartialFunction[U, V], comb: (V, V) ⇒ V): Body[U, V]

Returns a new body, in which the init assignment is combined with the result of body evaluation trough the use of the comb combiner.
Returns a new body, in which the init assignment is combined with the result of body evaluation trough the use of the comb combiner.

Attributes
protected
Definition Classes
EquationSystemBase
def bodyWithBoxAssignment(boxes: BoxAssignment[U, V]): Body[U, V]

Returns a new body with boxes added to the evaluation.
Returns a new body with boxes added to the evaluation. If tracer is defined, the boxEvaluation callback is invoked during evaluation.

Attributes
protected
Definition Classes
EquationSystemBase
val bodyWithDependencies: BodyWithDependencies[U, V]

Implement the bodyWithDependencies method by instrumenting the source assignment in order to record access to unknowns.
Implement the bodyWithDependencies method by instrumenting the source assignment in order to record access to unknowns.

Definition Classes
SimpleGraphEquationSystem → EquationSystemBase → EquationSystem
def bodyWithTracer(t: EquationSystemTracer[U, V]): Body[U, V]

Returns a new body which calls the current tracer before and after evaluation.
Returns a new body which calls the current tracer before and after evaluation.
t
the tracer to be called by the new body

Attributes
protected
Definition Classes
EquationSystemBase
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
implicit val dom: Domain[V]

The domain type-class for the type V.
The domain type-class for the type V.

Definition Classes
SimpleGraphEquationSystem → GraphEquationSystem
val edgeAction: EdgeAction[U, V, E]

A function which, given an assignment and an edge, returns the output value of the edge.
A function which, given an assignment and an edge, returns the output value of the edge.

Definition Classes
SimpleGraphEquationSystem → GraphEquationSystem
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
val infl: Relation[U]

The static relation between an unknown x and the unknowns y it influences.
The static relation between an unknown x and the unknowns y it influences. If infl(x) does not contain y, it means that eqs(rho)(y) == eqs(rho')(y), when rho' = rho[x / eqs(rho)(x)].

Definition Classes
SimpleGraphEquationSystem → FiniteEquationSystem
val ingoing: (U) ⇒ Iterable[E]

Maps each unknown to the collection of edges arriving on it.
Maps each unknown to the collection of edges arriving on it.

Definition Classes
SimpleGraphEquationSystem → GraphEquationSystem
val initial: InputAssignment[U, V]

An initial value for starting the analyzer
An initial value for starting the analyzer

Definition Classes
SimpleGraphEquationSystem → EquationSystem
val inputUnknowns: Set[U]

The unknowns which may be considered the input to this equation system.
The unknowns which may be considered the input to this equation system.

Definition Classes
SimpleGraphEquationSystem → FiniteEquationSystem → EquationSystem
final def isInstanceOf[T0]: Boolean

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val outgoing: (U) ⇒ Iterable[E]

Maps each unknown to the collection of edges departing from it.
Maps each unknown to the collection of edges departing from it.

Definition Classes
SimpleGraphEquationSystem → GraphEquationSystem
val sources: (E) ⇒ Iterable[U]

Maps each edge to its source unknowns.
Maps each edge to its source unknowns.

Definition Classes
SimpleGraphEquationSystem → GraphEquationSystem
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
val target: (E) ⇒ U

Maps each edge to its target unknown.
Maps each edge to its target unknown.

Definition Classes
SimpleGraphEquationSystem → GraphEquationSystem
val tracer: Option[EquationSystemTracer[U, V]]

An optional tracer which should be called during body evaluation.
An optional tracer which should be called during body evaluation.

Definition Classes
SimpleGraphEquationSystem → EquationSystemBase
val unknowns: Iterable[U]

The collection of all unknowns.
The collection of all unknowns.

Definition Classes
SimpleGraphEquationSystem → FiniteEquationSystem
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( ... )
def withBaseAssignment(init: PartialFunction[U, V])(implicit magma: Magma[V]): FiniteEquationSystem[U, V]

Combine a base assignment with the equation system.
Combine a base assignment with the equation system. The type V should be endowed with a magma.
init
the assignment to add to the equation system

Definition Classes
SimpleGraphEquationSystem → FiniteEquationSystem → EquationSystem
def withBoxes(boxes: BoxAssignment[U, V]): FiniteEquationSystem[U, V]

Add boxes to the equation system
Add boxes to the equation system
boxes
a box assignment

Definition Classes
SimpleGraphEquationSystem → FiniteEquationSystem → EquationSystem
def withLocalizedBoxes(boxes: BoxAssignment[U, V], ordering: Ordering[U]): GraphEquationSystem[U, V, E]

Add boxes to the equation system in a localized way.
Add boxes to the equation system in a localized way.
boxes
new boxes to add.
ordering
an order on unknown used to decide which edges needs to be widened

Definition Classes
SimpleGraphEquationSystem → GraphEquationSystem
def withLocalizedWarrowing(widenings: BoxAssignment[U, V], narrowings: BoxAssignment[U, V], ordering: Ordering[U]): FiniteEquationSystem[U, V]

Add warrowing to the equation system in a localized way.
Add warrowing to the equation system in a localized way. Localized warrowing requires a different procedure than standard localized widenings. Moreover, it is not entirely clear whether this works as intended or not.
widenings
a widening assignment
narrowings
a narrowing assignment

Definition Classes
SimpleGraphEquationSystem → GraphEquationSystem
def withTracer(t: EquationSystemTracer[U, V]): GraphEquationSystem[U, V, E]

Add a tracer to the equation system.
Add a tracer to the equation system. The tracer contains call-backs to be invoked during body evaluation.
t
the tracer

Definition Classes
SimpleGraphEquationSystem → GraphEquationSystem → FiniteEquationSystem → EquationSystem

Related Doc: package finite

Instance Constructors

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

val body: Body[U, V]

def bodyWithBaseAssignment(init: PartialFunction[U, V], comb: (V, V) ⇒ V): Body[U, V]

def bodyWithBoxAssignment(boxes: BoxAssignment[U, V]): Body[U, V]

val bodyWithDependencies: BodyWithDependencies[U, V]

def bodyWithTracer(t: EquationSystemTracer[U, V]): Body[U, V]

def clone(): AnyRef

implicit val dom: Domain[V]

val edgeAction: EdgeAction[U, V, E]

final def eq(arg0: AnyRef): Boolean

def finalize(): Unit

final def getClass(): Class[_]

val infl: Relation[U]

val ingoing: (U) ⇒ Iterable[E]

val initial: InputAssignment[U, V]

val inputUnknowns: Set[U]

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val outgoing: (U) ⇒ Iterable[E]

val sources: (E) ⇒ Iterable[U]

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

val target: (E) ⇒ U

val tracer: Option[EquationSystemTracer[U, V]]

val unknowns: Iterable[U]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withBaseAssignment(init: PartialFunction[U, V])(implicit magma: Magma[V]): FiniteEquationSystem[U, V]

def withBoxes(boxes: BoxAssignment[U, V]): FiniteEquationSystem[U, V]

def withLocalizedBoxes(boxes: BoxAssignment[U, V], ordering: Ordering[U]): GraphEquationSystem[U, V, E]

def withLocalizedWarrowing(widenings: BoxAssignment[U, V], narrowings: BoxAssignment[U, V], ordering: Ordering[U]): FiniteEquationSystem[U, V]

def withTracer(t: EquationSystemTracer[U, V]): GraphEquationSystem[U, V, E]

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from GraphEquationSystem[U, V, E]

Inherited from FiniteEquationSystem[U, V]

Inherited from EquationSystemBase[U, V]

Inherited from EquationSystem[U, V]

Inherited from AnyRef

Inherited from Any

Ungrouped