|
|||||||||
| 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.
BijMapBijMap.
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
Iterables.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.ith 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.LinkedHashMaps.
LinkedHashSets.
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.
Relations interface backed by a
LinkedHashMap from keys to
LinkedHashSets of values.
Relations interface backed by a Map
from keys to Sets of values.
MapSetRelation is an implementation of the
Relation interface based on a Map from
keys to Sets of values.Relation represented using a
LinkedHashMap from keys to
LinkedHashSets of values.
Relation represented by a
Map from keys to Sets 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 NFAs whose states are sets of
original states.NoCompTreeMap.
NoCompTreeMaps.
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 As 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.
RegExps.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 LinkedHashMaps and a factory of
MapSetRelations.
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
LinkedHashMaps and LinkedHashSets.
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 Ts.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.
TreeMaps.
TreeSets.
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 Iterables.
Iterable that is the union
of several Iterables (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.
WorkQueueWorkQueue.
WorkSet is an ordered set-like data structure.WorkStack is a WorkSet with LIFO order.hashCode.
|
|||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||