SplittingTree(V, C)

newdata.spad line 295 [edit on github]

This domain exports a modest implementation of splitting trees. Splitting trees are needed when the evaluation of some quantity under some hypothesis requires to split the hypothesis into sub-cases. For instance by adding some new hypothesis on one hand and its negation on another hand. The computations are terminated for a splitting tree a when status(value(a)) is true. Thus, if for the splitting tree a the flag status(value(a)) is true, then status(value(d)) is true for any subtree d of a. This property of splitting trees is called the termination condition. If no vertex in a splitting tree a is equal to another, a is said to satisfy the no-duplicates condition. The splitting tree a will satisfy this condition if nodes are added to a by means of splitNodeOf! and if construct is only used to create the root of a with no children.

# : % -> NonNegativeInteger
from Aggregate
= : (%, %) -> Boolean
from BasicType
any? : (Mapping(Boolean, SplittingNode(V, C)), %) -> Boolean
from HomogeneousAggregate(SplittingNode(V, C))
child? : (%, %) -> Boolean
from RecursiveAggregate(SplittingNode(V, C))
children : % -> List(%)
from RecursiveAggregate(SplittingNode(V, C))
coerce : % -> OutputForm
from CoercibleTo(OutputForm)
conditions : % -> List(C)

conditions(a) returns the list of the conditions of the leaves of a

construct : (V, C, V, List(C)) -> %

construct(v1, t, v2, lt) creates a splitting tree with value (i.e. root vertex) given by [v, t]$S and with children list given by [[[v, t]$S]$% for s in ls].

construct : (V, C, List(%)) -> %

construct(v, t, la) creates a splitting tree with value (i.e. root vertex) given by [v, t]$S and with la as children list.

construct : (V, C, List(SplittingNode(V, C))) -> %

construct(v, t, ls) creates a splitting tree with value (i.e. root vertex) given by [v, t]$S and with children list given by [[s]$% for s in ls].

construct : SplittingNode(V, C) -> %

construct(s) creates a splitting tree with value (i.e. root vertex) given by s and no children. Thus, if the status of s is false, [s] represents the starting point of the evaluation value(s) under the hypothesis condition(s).

copy : % -> %
from Aggregate
count : (Mapping(Boolean, SplittingNode(V, C)), %) -> NonNegativeInteger
from HomogeneousAggregate(SplittingNode(V, C))
count : (SplittingNode(V, C), %) -> NonNegativeInteger
from HomogeneousAggregate(SplittingNode(V, C))
cyclic? : % -> Boolean
from RecursiveAggregate(SplittingNode(V, C))
distance : (%, %) -> Integer
from RecursiveAggregate(SplittingNode(V, C))
elt : (%, "value") -> SplittingNode(V, C)
from RecursiveAggregate(SplittingNode(V, C))
empty : () -> %
from Aggregate
empty? : % -> Boolean
from Aggregate
eq? : (%, %) -> Boolean
from Aggregate
eval : (%, Equation(SplittingNode(V, C))) -> % if SplittingNode(V, C) has Evalable(SplittingNode(V, C))
from Evalable(SplittingNode(V, C))
eval : (%, List(Equation(SplittingNode(V, C)))) -> % if SplittingNode(V, C) has Evalable(SplittingNode(V, C))
from Evalable(SplittingNode(V, C))
eval : (%, List(SplittingNode(V, C)), List(SplittingNode(V, C))) -> % if SplittingNode(V, C) has Evalable(SplittingNode(V, C))
from InnerEvalable(SplittingNode(V, C), SplittingNode(V, C))
eval : (%, SplittingNode(V, C), SplittingNode(V, C)) -> % if SplittingNode(V, C) has Evalable(SplittingNode(V, C))
from InnerEvalable(SplittingNode(V, C), SplittingNode(V, C))
every? : (Mapping(Boolean, SplittingNode(V, C)), %) -> Boolean
from HomogeneousAggregate(SplittingNode(V, C))
extractSplittingLeaf : % -> Union(%, "failed")

extractSplittingLeaf(a) returns the left most leaf (as a tree) whose status is false if any, else "failed" is returned.

latex : % -> String
from SetCategory
leaf? : % -> Boolean
from RecursiveAggregate(SplittingNode(V, C))
leaves : % -> List(SplittingNode(V, C))
from RecursiveAggregate(SplittingNode(V, C))
less? : (%, NonNegativeInteger) -> Boolean
from Aggregate
map : (Mapping(SplittingNode(V, C), SplittingNode(V, C)), %) -> %
from HomogeneousAggregate(SplittingNode(V, C))
map! : (Mapping(SplittingNode(V, C), SplittingNode(V, C)), %) -> %
from HomogeneousAggregate(SplittingNode(V, C))
max : % -> SplittingNode(V, C) if SplittingNode(V, C) has OrderedSet
from HomogeneousAggregate(SplittingNode(V, C))
max : (Mapping(Boolean, SplittingNode(V, C), SplittingNode(V, C)), %) -> SplittingNode(V, C)
from HomogeneousAggregate(SplittingNode(V, C))
member? : (SplittingNode(V, C), %) -> Boolean
from HomogeneousAggregate(SplittingNode(V, C))
members : % -> List(SplittingNode(V, C))
from HomogeneousAggregate(SplittingNode(V, C))
min : % -> SplittingNode(V, C) if SplittingNode(V, C) has OrderedSet
from HomogeneousAggregate(SplittingNode(V, C))
more? : (%, NonNegativeInteger) -> Boolean
from Aggregate
node? : (%, %) -> Boolean
from RecursiveAggregate(SplittingNode(V, C))
nodeOf? : (SplittingNode(V, C), %) -> Boolean

nodeOf?(s, a) returns true iff some node of a is equal to s

nodes : % -> List(%)
from RecursiveAggregate(SplittingNode(V, C))
parts : % -> List(SplittingNode(V, C))
from HomogeneousAggregate(SplittingNode(V, C))
remove : (SplittingNode(V, C), %) -> %

remove(s, a) returns the splitting tree obtained from a by removing every sub-tree b such that value(b) and s have the same value, condition and status.

remove! : (SplittingNode(V, C), %) -> %

remove!(s, a) replaces a by remove(s, a)

result : % -> List(Record(val : V, tower : C))

result(a) where ls is the leaves list of a returns [[value(s), condition(s)]$VT for s in ls] if the computations are terminated in a else an error is produced.

sample : () -> %
from Aggregate
setchildren! : (%, List(%)) -> %
from RecursiveAggregate(SplittingNode(V, C))
setelt! : (%, "value", SplittingNode(V, C)) -> SplittingNode(V, C)
from RecursiveAggregate(SplittingNode(V, C))
setvalue! : (%, SplittingNode(V, C)) -> SplittingNode(V, C)
from RecursiveAggregate(SplittingNode(V, C))
size? : (%, NonNegativeInteger) -> Boolean
from Aggregate
splitNodeOf! : (%, %, List(SplittingNode(V, C))) -> %

splitNodeOf!(l, a, ls) returns a where the children list of l has been set to [[s]$% for s in ls | not nodeOf?(s, a)]. Thus, if l is not a node of a, this latter splitting tree is unchanged.

splitNodeOf! : (%, %, List(SplittingNode(V, C)), Mapping(Boolean, C, C)) -> %

splitNodeOf!(l, a, ls, sub?) returns a where the children list of l has been set to [[s]$% for s in ls | not subNodeOf?(s, a, sub?)]. Thus, if l is not a node of a, this latter splitting tree is unchanged.

subNodeOf? : (SplittingNode(V, C), %, Mapping(Boolean, C, C)) -> Boolean

subNodeOf?(s, a, sub?) returns true iff for some node n in a we have s = n or status(n) and subNode?(s, n, sub?).

updateStatus! : % -> %

updateStatus!(a) returns a where the status of the vertices are updated to satisfy the "termination condition".

value : % -> SplittingNode(V, C)
from RecursiveAggregate(SplittingNode(V, C))
~= : (%, %) -> Boolean
from BasicType

Evalable(SplittingNode(V, C))

RecursiveAggregate(SplittingNode(V, C))

BasicType

InnerEvalable(SplittingNode(V, C), SplittingNode(V, C))

shallowlyMutable

SetCategory

finiteAggregate

HomogeneousAggregate(SplittingNode(V, C))

CoercibleTo(OutputForm)

Aggregate