|
|||||||||
PREV NEXT | FRAMES NO FRAMES |
Action
is a wrapper for a void
returning
method.t
.
<key, value>
to the relation.
this
ternary
relation.
elem
to this
workset.
key
to each element of the set
values
.
elems
to this
workset.
ct
is included in the set s
".
s1
and s2
should be
equal.
WorkSetAbstr.addToOrder(T)
.
Concat
.
Union
.
Map
view of the disjoint
set, where every element is mapped to its canonical representative.
Constraint.cost()
BasicBlock
is a straight-line sequence of
vertices.BasicBlockDiGraph
is a basic block representation of
a directed graph.BasicBlockDiGraph
representation for
diGraph
.
BijMap
BijMap
.
BinTreeNav
models the arcs of a binary tree.BinTreeUtil
contains utilities for binary trees.BoolMCell
is a mutable cell with boolean content.BoolMCell
with initial value
initValue
.
CachedFunction
is a caching wrapper around a (presumably pure) function.func
.
obj1
is null, and next invokes
equals
.
CollectionFactory
is a collection-specific instance of
the factory pattern.CompoundIterable
allows the construction of an
Iterable
by merging several smaller
Iterable
s.CompoundIterable
.
Constraint
models a constraint between several
variables.ConstraintSystem
is an efficient solver for a system
of constraints.ConstraintSystem
.
getForwardNavigator
.
o
.
<key,value>
.
this
ternary relation.
this
workset contains the element
e
.node
belongs to this
\
strongly connected component.
key
and every element from values
.
key
key in this relation.
s
.
x
.
this
constraint.
HIGH_COST
.
HIGH_COST
.
T
.
T
, as a copy of
t
.
create()
to create
an empty map, and next adds each entry from m
to
the newly-created map.
RelationFactory.create()
to create an
empty relation, and next add each pair from r
to
the new relation.
SetFactory.newColl(Collection)
.
NFA
.
NFA
.
jpaul
project.
CtConstraint
models a constraint of the form
"constant ct
is less than the value of the
variable vd
".LtConstraint
with default cost Constraint.VERY_LOW_COST
.
CtConstraint
with the meaning "the
constant ct
is smaller than the value of the
variable vd
."
CtDiffConstraint
models a "difference with a constant set" constraint.CtDiffConstraint
with the meaning
vIn \ ctSet <= vDest
.
Debug
contains some simple debugging methods.System.out
).
this
digraph.
DiGraph
models a directed graph.DiGraph
with no caching (the safest
choice).
DiGraph
.
DiGraph
object.
DiGraph
object.
DisjointSet
is an implementation of disjoint-set forests
using the path compression and union-by-rank heuristics to achieve
O(m * alpha(m, n)) runtime, where 'm' is the total number of
operations, 'n' is the total number of elements in the set, and
'alpha' denotes the *extremely* slowly-growing inverse Ackermann
function.DisjointSet
.
DSUtil
contains commonly used data-structure utilities.this
strongly
connected component.
BijMap
.
this
Comparator.
this
strongly connected
component.
this
workset
(according to the order specific to this
workset.
TRes
and returns a TArg.
Factory
for the factory pattern.newColl
all elements of coll
that satisfy the predicate pred
.
FilterConstraint
models a filtering constraint.FilterConstraint
with the meaning
vIn | pred <= vDest
.
o
.
<key,value>
of
this
relation and calls visitor.visit
on each of them.
this
directed graph.
ForwardNavigator
is a forward-only graph navigator:
given a vertex, it returns its successors in the graph.Function
is a wrapper around a function that takes a
TArg
and returns a TRes
.i
th element from the end of the
original list.
this
ternary
relation and has a
in its 1st position.
this
ternary relation.
this
graph.
this
digraph.
this
SCComponent
.
this
ternary relation.
LDiGraph
.
LDiGraph
.
this
digraph.
key
, if any.
this
directed
graph.
LDiGraph
).
key
through this relation.
GraphUtil
contains various graph utilities.LinkedHashMap
s.
LinkedHashSet
s.
Constraint.cost()
IdentityWrapper
is useful when you want to assign some
information to each object, not to each class of equal objects.IdentityWrapper
.
IdFunction
- identity functionIntersectConstraint
models a set intersection constraint.IntersectConstraint
with the meaning
vIn1 /\ vIn2 <= vDest
.
IntMCell
is a mutable cell with integer content.IntMCell
with initial content
0
.
IntMCell
with initial content
initValue
.
this
workset is empty.this
strongly connected component
corresponds to a loop, ie it has at least one arc to
itself.
Collection
view of an
Iterable
.
itrbl
contains the element
elem
.
Iterable
.
itrbl
has exactly
k
elements.
itrbl
has more than
k
elements.
s2
to
s1
.
v
by
joining delta
to it.
this
variable
takes values from.
this
relation.
LDiGraph
models a labeled directed graph.LDiGraph
.
LDiGraph
.
node
, if any, or
null
otherwise.
v
.
jpaul
project.
Constraint.cost()
v
.
LtConstraint
models a "less than"
constraint: the value of variable vs
is smaller than
the value of variable vd
, according to the order
relation from the corresponding lattice.LtConstraint
with default cost Constraint.LOW_COST
.
LtConstraint
with the meaning
"value of variable vs
is smaller than the
value of the variable vd
."
jpaul
release.
Function
based on a map.
coll
into a new collection
(stored in newColl
), according to the function
func
.
mapColl
method, but the
function is given as a map.
mapColl
, but filters out all
null
elements produced by func
.
MapFactory
is a map-specific instance of the factory
pattern.MapFacts
contains several common map factories.MapFacts.hash()
instead.MapFacts.tree(Comparator)
instead.TreeMapFactory
.
Relation
s interface backed by a
LinkedHashMap
from keys to
LinkedHashSet
s of values.
Relation
s interface backed by a Map
from keys to Set
s of values.
MapSetRelation
is an implementation of the
Relation
interface based on a Map
from
keys to Set
s of values.Relation
represented using a
LinkedHashMap
from keys to
LinkedHashSet
s of values.
Relation
represented by a
Map
from keys to Set
s of values.
MapWithDefault
is a map that returns default values
for unassigned keys.MapWithDefault
, backed by a
LinkedHashMap
.
MapWithDefault
.
MapWrapper
is a map backed by another map.MapWrapper
.
MCell
is a mutable cell with content of type
T
.MutableCell
.
Navigator
interface allows graph algorithms to
detect (and use) the arcs from and to a certain vertex.c
.
Factory.create()
.
create()
to create
an empty set, and next adds all elements from
coll
to the newly-created set.
vertex
.
NFA
models a Non-deterministic Finite Automaton.NFA
.
NFA
transformations (ex: NFA.simplify()
) produce NFA
s whose states are sets of
original states.NoCompTreeMap
.
NoCompTreeMap
s.
NoCompTreeMap
is tree map that does not require any
used-defined Comparator
.NoCompTreeMap
.
NoCompTreeMap
with the same mappings as the
given map.
this
strongly connected component
(set version).
this
directed
graph.
this
directed
graph.
Pair
is an immutable pair of two values.Predicate
wraps a boolean predicate.vertex
.
RegExp
models a regular expression.Atomic
regular expression that
matches only the 1-length string consisting of the symbol
a
.
Concat
regular expression that
matches any string of A
s consisting of a
string matched by left
followed by a string
matched by right
.
RegExp
that matches any string that
is obtained by the concatenation of a finite number of
strings (possibly none), each matched by the regular
expression regExp
.
Union
regular expression that
matches any string that is matched by (at least one of)
left
and right
.
RegExp
s.Relation
is a binary relation, accepting one to many
and many to one mappings.Relation.EntryVisitor
is a wrapper for a function that is
called on a relation entry of the form
<key,value>
.Relation3
models a simple ternary relation.Relation3MapRelImpl
is a simple implementation of
Relation3
, backed by a Map
from
Ta
keys to RelationTb,Tc
between
Tb
and Tc
.Relation3MapRelImpl
.
Relation3MapRelImpl
object using a
factory of LinkedHashMap
s and a factory of
MapSetRelation
s.
RelationFactory
is a relation-specific instance of the
factory pattern.jpaul
library.
RelFacts
contains common relation factories.RelFacts.cow(RelationFactory)
instead.COWRelationFactory
.
RelFacts.mapSet()
or RelFacts.mapSet(MapFactory,SetFactory)
instead.MapSetRelationFactory
that generates
relations whose representation uses
LinkedHashMap
s and LinkedHashSet
s.
MapSetRelationFactory
that
generates relations whose representation uses maps
generated by mapFact
and sets generated by
setFact
.
key
.
key
and
value
.
this
ternary
relation.
key
and
any element from values
.
key
.
predicate.check()
.
predicate.check()
.
BijMap
.
this
directed graph: a
directed graph with the same set of vertices, that contains an
arc from v1
to v2
iff
this
graph contains an arc from v2
to v1
.
ReverseListIterator
takes a List
and
produces a ListIterator
that traverses the list in
reverse order.ReverseListIterator
.
ReverseViewList
is an immutable, reverse view of a
List
.origList
.
this
relation and store the result into
the relation result
.
this
constraint by replacing each
variable with the representative of its equivalence class.
CtDiffConstraint.rewrite(jpaul.DataStructs.DisjointSet>)
, CtDiffConstraint.equals(java.lang.Object)
, and CtDiffConstraint.hashCode
, such that constraints that are identical after
variable unification are not duplicated needlessly.
IntersectConstraint.rewrite(jpaul.DataStructs.DisjointSet>)
, IntersectConstraint.equals(java.lang.Object)
, and IntersectConstraint.hashCode
, such that constraints that are identical after
variable unification are not duplicated needlessly.
node
, if any, or
null
otherwise.
SCComponent
models a strongly-connected
component of a directed graph: a set of vertices such that
there is a path between any two of them.SetConstraints
is a collection of set constraints.SetFactory
is a set-instance of the factory pattern.SetFacts
contains common set factories.SetFacts.cow(SetFactory)
instead.COWSetFactory
.
SetFacts.hash()
instead.SetFacts.tree(Comparator)
instead.TreeSetFactory
.
SetMembership
is a predicate that checks whether an
element is member of a specific set.SetMembership
that checks membership in
the set set
.
NFA
that accepts the same
strings as this NFA.
this
workset.isEmpty()
iff size() ==
0
.this
strongly connected
component.
SolAccessor
provides access to the values of the
variables from a system of constraints.SolReader
provides read-only access to the (possibly
partial) solution of a system of constraints.this
system of constraints.
this
directed graph
containing only the vertices from verts
.
SVar
is a variable whose values are sets of T
s.SVar
.
SVar
using a HashSet
factory (SetFacts.hash
)
TopSortedCompDiGraph
is a topologically-sorted
component digraph.digraph
.
A
,
representing all strings accepted by this NFA.
this
variable.
"null"
if the argument o
is
null, and o.toString()
otherwise.
TreeMap
s.
TreeSet
s.
UComp
is an universal comparator, which compares any two
objecs by simply comparing their string representation.o1
and
o2
, say S1 and S2, into a new set that is the
union of these two sets.
this
relation with relation
rel
.
ForwardNavigator
.
Iterable
that is the union
of two Iterable
s.
Iterable
that is the union
of several Iterable
s (in the order thet are given
in its
).
List
that is the union of
two lists: it contains first the elements from
l1
, and next the elements from
l2
.
Navigator
.
Iterable
into an unmodifiable
one.
Iterator
into an unmodifiable
one.
BijMap
.
this
relation.
Var
models a variable from a system of constraints.VerboseWorkSet
- Debugging wrapper for a
WorkSet
.VerboseWorkSet
.
Version
contains fields naming the current
jpaul
version.this
digraph: vertices that are (trasitively and reflexively)
reachable from the root vertices by following the forward arcs
provided by the navigator.
Constraint.cost()
<key,value>
entry of a relation.
None
regular expression.
Atomic
regular expression.
EmptyStr
regular expression.
Union
regular expression.
Concat
regular expression.
Star
regular expression.
WorkList
is a WorkSet
with FIFO order.WorkPriorityQueue
is a WorkSet
whose
elements are extracted in the increasing order of their priorities.WorkPriorityQueue
.
WorkQueue
WorkQueue
.
WorkSet
is an ordered set-like data structure.WorkStack
is a WorkSet
with LIFO order.hashCode
.
|
|||||||||
PREV NEXT | FRAMES NO FRAMES |