SplittingTree(V, C)ΒΆ

newdata.spad line 295

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 is 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 mean of splitNodeOf! and if construct is only used to create the root of a with no children.

#: % -> NonNegativeInteger
from Aggregate
=: (%, %) -> Boolean
from BasicType
~=: (%, %) -> Boolean
from BasicType
any?: (SplittingNode(V, C) -> Boolean, %) -> 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, 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: (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: 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: (SplittingNode(V, C) -> Boolean, %) -> 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?: (SplittingNode(V, C) -> Boolean, %) -> 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.
hash: % -> SingleInteger
from SetCategory
hashUpdate!: (HashState, %) -> HashState
from SetCategory
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!: (SplittingNode(V, C) -> SplittingNode(V, C), %) -> %
from HomogeneousAggregate SplittingNode(V, C)
map: (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)
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) replaces a by remove(s, a)
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.
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), (C, C) -> Boolean) -> %
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), %, (C, C) -> Boolean) -> 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)

Aggregate

BasicType

CoercibleTo OutputForm

Evalable SplittingNode(V, C) if SplittingNode(V, C) has Evalable SplittingNode(V, C)

finiteAggregate

HomogeneousAggregate SplittingNode(V, C)

InnerEvalable(SplittingNode(V, C), SplittingNode(V, C)) if SplittingNode(V, C) has Evalable SplittingNode(V, C)

RecursiveAggregate SplittingNode(V, C)

SetCategory

shallowlyMutable