A | |
add [Rational] | |
add [Union] |
Add an element to the universe (initially belonging to its singleton)
|
add [Symbol] |
Returns the symbol associated to the given string, after having possibly
registered the string if it wasn't (in this case, the symbol is fresh
symbol).
|
add [MultiSetList.S] | add x s returns a multiset containing all elements of s , plus
x .
|
add [MultiSetList] | add x s returns a multiset containing all elements of s , plus
x .
|
add [SetList.S] | add x s returns a set containing all elements of s ,
plus x .
|
add [SetList] | add x s returns a set containing all elements of s ,
plus x .
|
add [PDHashhe] | |
add [DHashhe.S] | |
add [DHashhe] |
Add a new binding to the table.
|
add [PDMappe] | |
add [DMappe.S] | |
add [DMappe] |
Add a new binding to the current map and return the new map.
|
add [PHashhe] | |
add [Hashhe.Compare] | |
add [Hashhe.S] | |
add [Hashhe] | add tbl x y adds a binding of x to y in table tbl .
|
add [PMappe] | |
add [Mappe.Compare] | |
add [Mappe.S] | |
add [Mappe] | add x y m returns a map containing the same bindings as
m , plus a binding of x to y .
|
add [PSette] | add x s returns a set containing all elements of s ,
plus x .
|
add [Sette.Compare] | |
add [Sette.S] | add x s returns a set containing all elements of s ,
plus x .
|
add [Sette] | add x s returns a set containing all elements of s ,
plus x .
|
add_edge [FGraph.S] | |
add_edge [FGraph] | |
add_edge [FGraph1.S] | |
add_edge [FGraph1] | |
add_hedge [PSHGraph] | |
add_hedge [SHGraph.Compare] | |
add_hedge [SHGraph.S] | |
add_hedge [SHGraph] |
Add an hyperedge.
|
add_vertex [PSHGraph] | |
add_vertex [SHGraph.Compare] | |
add_vertex [SHGraph.S] | |
add_vertex [SHGraph] |
Add a vertex
|
add_vertex [FGraph.S] | |
add_vertex [FGraph] | |
add_vertex [FGraph1.S] | |
add_vertex [FGraph1] | |
addmap [PMappe] | |
addmap [Mappe.Compare] | |
addmap [Mappe.S] | |
addmap [Mappe] | addmap m1 m2 merges the two maps m1 and m2 .
|
append [Ilist] |
Append two lists
|
array [Print] |
Print an array
|
atome [Ilist] |
Create a list element from a single element.
|
attredge [FGraph.S] | |
attredge [FGraph] | |
attredge [FGraph1.S] | |
attredge [FGraph1] | |
attrhedge [PSHGraph] | |
attrhedge [SHGraph.Compare] | |
attrhedge [SHGraph.S] | |
attrhedge [SHGraph] | attrhedge graph hedge returns the information associated to the
hyperedge hedge
|
attrvertex [PSHGraph] | |
attrvertex [SHGraph.Compare] | |
attrvertex [SHGraph.S] | |
attrvertex [SHGraph] | attrvertex graph vertex returns the information associated to the
vertex vertex
|
attrvertex [FGraph.S] | |
attrvertex [FGraph] | |
attrvertex [FGraph1.S] | |
attrvertex [FGraph1] | |
B | |
bindings [PMappe] | |
bindings [Mappe.S] | |
bindings [Mappe] |
Return the list of all bindings of the given map.
|
C | |
cardinal [MultiSetList.S] |
Return the number of elements of a multiset.
|
cardinal [MultiSetList] |
Return the number of elements of a multiset.
|
cardinal [SetList.S] |
Return the number of elements of a set.
|
cardinal [SetList] |
Return the number of elements of a set.
|
cardinal [PDHashhe] | |
cardinal [DHashhe.S] | |
cardinal [DHashhe] |
Return the number of bindings.
|
cardinal [PDMappe] | |
cardinal [DMappe.S] | |
cardinal [DMappe] |
Return the number of bindings.
|
cardinal [PMappe] | |
cardinal [Mappe.S] | |
cardinal [Mappe] |
Number of keys of a map
|
cardinal [PSette] |
Return the number of elements of a set.
|
cardinal [Sette.S] |
Return the number of elements of a set.
|
cardinal [Sette] |
Return the number of elements of a set.
|
cfc [PSHGraph] | |
cfc [SHGraph.Compare] | |
cfc [SHGraph.S] | |
cfc [SHGraph] |
Decomposition of the graph into Strongly Connected Components,
|
cfc [FGraph.S] | |
cfc [FGraph] | |
cfc [FGraph1.S] | |
cfc [FGraph1] | |
cfc_multi [PSHGraph] | |
cfc_multi [SHGraph.Compare] | |
cfc_multi [SHGraph.S] | |
cfc_multi [SHGraph] |
idem, but from several initial vertices.
|
cfc_multi [FGraph.S] | |
cfc_multi [FGraph] | |
cfc_multi [FGraph1.S] | |
cfc_multi [FGraph1] | |
choose [MultiSetList.S] |
Return one element of the given multiset, or raise
Not_found if the
multiset is empty.
|
choose [MultiSetList] |
Return one element of the given multiset, or raise
Not_found if the
multiset is empty.
|
choose [SetList.S] |
Return one element of the given set, or raise
Not_found if the set
is empty.
|
choose [SetList] |
Return one element of the given set, or raise
Not_found if the set
is empty.
|
choose [PMappe] | |
choose [Mappe.S] | |
choose [Mappe] |
Returns a binding, or raise
Not_found if empty
|
choose [PSette] |
Return one element of the given set, or raise
Not_found if the set
is empty.
|
choose [Sette.S] |
Return one element of the given set, or raise
Not_found if
the set is empty.
|
choose [Sette] |
Return one element of the given set, or raise
Not_found if the set
is empty.
|
clear [PSHGraph] | |
clear [SHGraph.S] | |
clear [SHGraph] |
Remove all vertices and hyperedges of the graph.
|
clear [PDHashhe] | |
clear [DHashhe.S] | |
clear [DHashhe] |
Clear a table
|
clear [PHashhe] | |
clear [Hashhe.S] | |
clear [Hashhe] |
Empty a hash table.
|
combine [PMappe] | |
combine [Mappe.Compare] | |
combine [Mappe.S] | |
combine [Mappe] | |
common [PDMappe] | |
common [DMappe.S] | |
common [DMappe] |
Return the common bindings.
|
common [PMappe] | |
common [Mappe.Compare] | |
common [Mappe.S] | |
common [Mappe] | common commondata a b returns a map the keys of which must be
keys in both a and in b , and those keys are bound to interdata
d1 d2 .
|
commoni [PMappe] | |
commoni [Mappe.Compare] | |
commoni [Mappe.S] | |
commoni [Mappe] |
Same as
common , but the function receives as arguments the key
(of the first map)
|
compare [Symbol] |
Comparison (do not correspond at all to alphabetic order, depend on the
registration order of names in the module)
|
compare [MultiSetList.S] |
Total ordering between multisets.
|
compare [MultiSetList] |
Total ordering between multisets.
|
compare [SetList.S] |
Total ordering between sets.
|
compare [SetList] |
Total ordering between sets.
|
compare [PMappe] | |
compare [Mappe.Compare] | |
compare [Mappe.S] | |
compare [Mappe] | |
compare [PSette] |
Total ordering between sets.
|
compare [Sette.Compare] | |
compare [Sette.S] |
Total ordering between sets.
|
compare [Sette] |
Total ordering between sets.
|
comparei [PMappe] | |
comparei [Mappe.Compare] | |
comparei [Mappe.S] | |
comparei [Mappe] |
Comparison function between maps,
total if the comparison function for data is total
|
cons [Ilist] |
Adding a new list element at the begining of the list
|
copy [PSHGraph] | |
copy [SHGraph.S] | |
copy [SHGraph] |
Copy an hypergraph, using the given functions to duplicate the
attributes associated to the elements of the graph.
|
copy [PHashhe] | |
copy [Hashhe.S] | |
copy [Hashhe] |
Return a copy of the given hashtable.
|
coreachable [FGraph.S] | |
coreachable [FGraph] | |
coreachable_multi [FGraph.S] | |
coreachable_multi [FGraph] | |
create [Union] |
Create a new universe set
|
create [PSHGraph] | |
create [SHGraph.S] | |
create [SHGraph] | create n data creates an hypergraph, using n for the initial size
of internal hashtables, and data for the user information
|
create [PDHashhe] | |
create [DHashhe.S] | |
create [DHashhe] |
Create a new table, with the specified initial size
|
create [PHashhe] | |
create [Hashhe.S] | |
create [Hashhe] | create n creates a new, empty hash table, with
initial size n .
|
create_compare [PSHGraph] | |
create_compare [PDHashhe] | |
create_compare [PHashhe] | |
D | |
depth [Ilist] |
Return the (maximal) depth of the list.
|
diff [MultiSetList.S] |
Union, intersection and multiset difference.
|
diff [MultiSetList] |
Union, intersection and multiset difference.
|
diff [SetList.S] |
Union, intersection and set difference.
|
diff [SetList] |
Union, intersection and set difference.
|
diff [PSette] |
Union, intersection and set difference.
|
diff [Sette.Compare] | |
diff [Sette.S] |
Set difference.
|
diff [Sette] |
Union, intersection and set difference.
|
diff_set [MultiSetList.S] |
Union, intersection and multiset difference with a set.
|
diff_set [MultiSetList] |
Union, intersection and multiset difference with a set.
|
diffset [PMappe] | |
diffset [Mappe.Compare] | |
diffset [Mappe.S] | |
diffset [Mappe] | interset map set removes the bindings of a whose key belongs to
set .
|
diffsetx [PDMappe] | |
diffsetx [DMappe.S] | |
diffsetx [DMappe] |
Remove the two-way bindings
x <->y with x in the set
|
diffsety [PDMappe] | |
diffsety [DMappe.S] | |
diffsety [DMappe] |
Remove the two-way bindings
x <->y with y in the set
|
div [Rational] | |
E | |
edges [FGraph.S] | |
edges [FGraph] | |
edges [FGraph1.S] | |
edges [FGraph1] | |
elements [MultiSetList.S] |
Return the list of all elements of the given multiset.
|
elements [MultiSetList] |
Return the list of all elements of the given multiset.
|
elements [SetList.S] |
Return the list of all elements of the given set.
|
elements [SetList] |
Return the list of all elements of the given set.
|
elements [PSette] |
Return the list of all elements of the given set.
|
elements [Sette.S] |
Return the list of all elements of the given set.
|
elements [Sette] |
Return the list of all elements of the given set.
|
empty [FGraph.S] | |
empty [FGraph] | |
empty [FGraph1.S] | |
empty [FGraph1] | |
empty [MultiSetList.S] |
The empty multiset.
|
empty [MultiSetList] |
The empty multiset.
|
empty [SetList.S] |
The empty set.
|
empty [SetList] |
The empty set.
|
empty [PDMappe] | |
empty [DMappe.S] | |
empty [DMappe] |
Empty map
|
empty [PMappe] | |
empty [Mappe.S] | |
empty [Mappe] |
The empty map.
|
empty [PSette] |
The empty set.
|
empty [Sette.S] |
The empty set.
|
empty [Sette] |
The empty set.
|
equal [Symbol] |
Equality test
|
equal [MultiSetList.S] | equal s1 s2 tests whether the multisets s1 and s2 are equal,
that is, contain equal elements with equal occurence numbers.
|
equal [MultiSetList] | equal s1 s2 tests whether the multisets s1 and s2 are equal, that
is, contain equal elements with equal occurence numbers.
|
equal [SetList.S] | equal s1 s2 tests whether the sets s1 and s2 are
equal, that is, contain equal elements.
|
equal [SetList] | equal s1 s2 tests whether the sets s1 and s2 are
equal, that is, contain equal elements.
|
equal [Hashhe.HashedType] |
The equality predicate used to compare keys.
|
equal [PMappe] | |
equal [Mappe.Compare] | |
equal [Mappe.S] | |
equal [Mappe] | |
equal [PSette] | equal s1 s2 tests whether the sets s1 and s2 are
equal, that is, contain equal elements.
|
equal [Sette.Compare] | |
equal [Sette.S] | equal s1 s2 tests whether the sets s1 and s2 are
equal, that is, contain equal elements.
|
equal [Sette] | equal s1 s2 tests whether the sets s1 and s2 are
equal, that is, contain equal elements.
|
equali [PMappe] | |
equali [Mappe.Compare] | |
equali [Mappe.S] | |
equali [Mappe] |
equality between maps
|
equalx [PDMappe] | |
equalx [DMappe.S] | |
equalx [DMappe] | |
equaly [PDMappe] | |
equaly [DMappe.S] | |
equaly [DMappe] | |
escaped [Print] |
Escape a string, replacing line breaks by
linebreak (default
'\n' ).
|
exists [Symbol] |
Is the string already registered ?
|
exists [Ilist] |
Existence test
|
exists [SetList.S] | exists p s checks if at least one element of
the set satisfies the predicate p .
|
exists [SetList] | exists p s checks if at least one element of
the set satisfies the predicate p .
|
exists [PSette] | exists p s checks if at least one element of
the set satisfies the predicate p .
|
exists [Sette.S] | exists p s checks if at least one element of
the set satisfies the predicate p .
|
exists [Sette] | exists p s checks if at least one element of
the set satisfies the predicate p .
|
extract [Union] |
Extract the list of sets
|
F | |
filter [MultiSetList.S] | filter p l returns all the elements of the multiset l that
satisfy the predicate p .
|
filter [MultiSetList] | filter p l returns all the elements of the multiset l that satisfy
the predicate p .
|
filter [SetList.S] | filter p s returns the set of all elements in s
that satisfy predicate p .
|
filter [SetList] | filter p s returns the set of all elements in s
that satisfy predicate p .
|
filter [PMappe] | |
filter [Mappe.Compare] | |
filter [Mappe.S] | |
filter [Mappe] | filter p m returns the map of all bindings in m that satisfy
predicate p .
|
filter [PSette] | filter p s returns the set of all elements in s
that satisfy predicate p .
|
filter [Sette.Compare] | |
filter [Sette.S] | filter p s returns the set of all elements in s
that satisfy predicate p .
|
filter [Sette] | filter p s returns the set of all elements in s
that satisfy predicate p .
|
find [Union] | |
find [PHashhe] | |
find [Hashhe.Compare] | |
find [Hashhe.S] | |
find [Hashhe] | find tbl x returns the current binding of x in tbl ,
or raises Not_found if no such binding exists.
|
find [PMappe] | |
find [Mappe.Compare] | |
find [Mappe.S] | |
find [Mappe] | find x m returns the current binding of x in m , or raises
Not_found if no such binding exists.
|
find_all [PHashhe] | |
find_all [Hashhe.Compare] | |
find_all [Hashhe.S] | |
find_all [Hashhe] | find_all tbl x returns the list of all data
associated with x in tbl .
|
flatten [Ilist] |
Flatten the recursive list, but only starting from the given
depth.
|
fold [MultiSetList.S] | fold f s a computes (f (xN,On) ... (f (x2,O2) (f (x1,o1) a))...) ,
where (x1,o1) ... (xN,oN) are pairs of elements of s with their
occurence number.
|
fold [MultiSetList] | fold f s a computes (f (xN,On) ... (f (x2,O2) (f (x1,o1) a))...) ,
where (x1,o1) ... (xN,oN) are pairs of elements of s with their
occurence number.
|
fold [SetList.S] | fold f s a
computes (f xN ... (f x2 (f x1 a))...) ,
where x1 ... xN are the elements of s .
|
fold [SetList] | fold f s a
computes (f xN ... (f x2 (f x1 a))...) ,
where x1 ... xN are the elements of s .
|
fold [PDHashhe] | |
fold [DHashhe.S] | |
fold [DHashhe] |
Iterate on bindings and accumulating a result.
|
fold [PDMappe] | |
fold [DMappe.S] | |
fold [DMappe] |
Iterate on bindings and accumulating a result.
|
fold [PHashhe] | |
fold [Hashhe.S] | |
fold [Hashhe] | fold f tbl init computes
(f kN dN ... (f k1 d1 init)...) ,
where k1 ... kN are the keys of all bindings in tbl ,
and d1 ... dN are the associated values.
|
fold [PMappe] | |
fold [Mappe.S] | |
fold [Mappe] | fold f m a computes (f kN dN ... (f k1 d1 a)...) , where k1
... kN are the keys of all bindings in m , and d1 ... dN are
the associated data.
|
fold [PSette] | fold f s a computes (f xN ... (f x2 (f x1 a))...) ,
where x1 ... xN are the elements of s .
|
fold [Sette.S] | fold f s a computes (f xN ... (f x2 (f x1 a))...) ,
where x1 ... xN are the elements of s .
|
fold [Sette] | fold f s a computes (f xN ... (f x2 (f x1 a))...) ,
where x1 ... xN are the elements of s .
|
fold_edge [FGraph.S] | |
fold_edge [FGraph] | |
fold_edge [FGraph1.S] | |
fold_edge [FGraph1] | |
fold_hedge [PSHGraph] | |
fold_hedge [SHGraph.S] | |
fold_hedge [SHGraph] | |
fold_left [Ilist] |
Ordinary fold function, from left to right.
|
fold_left [MultiSetList.S] |
Idem as
List.fold_X functions
|
fold_left [MultiSetList] |
Idem as
List.fold_X functions
|
fold_left [SetList.S] |
Idem as
List.fold_X functions
|
fold_left [SetList] |
Idem as
List.fold_X functions
|
fold_right [Ilist] |
Ordinary fold function, from right to left.
|
fold_right [MultiSetList.S] | |
fold_right [MultiSetList] | |
fold_right [SetList.S] | |
fold_right [SetList] | |
fold_vertex [PSHGraph] | |
fold_vertex [SHGraph.S] | |
fold_vertex [SHGraph] | |
fold_vertex [FGraph.S] | |
fold_vertex [FGraph] | |
fold_vertex [FGraph1.S] | |
fold_vertex [FGraph1] | |
for_all [SetList.S] | for_all p s checks if all elements of the set satisfy the predicate
p .
|
for_all [SetList] | for_all p s checks if all elements of the set
satisfy the predicate p .
|
for_all [PSette] | for_all p s checks if all elements of the set
satisfy the predicate p .
|
for_all [Sette.S] | for_all p s checks if all elements of the set
satisfy the predicate p .
|
for_all [Sette] | for_all p s checks if all elements of the set
satisfy the predicate p .
|
G | |
gcd [Rational] | |
H | |
hash [Hashhe.HashedType] |
A hashing function on keys.
|
hash [Hashhe] | hash x associates a positive integer to any value of
any type.
|
hash [Print] |
Print an hashtable
|
hash_param [Hashhe] | hash_param n m x computes a hash value for x , with the
same properties as for hash .
|
hashx [PDHashhe] | |
hashx [DHashhe.S] | |
hashx [DHashhe] | |
hashy [PDHashhe] | |
hashy [DHashhe.S] | |
hashy [DHashhe] |
Return the correspondance hashtable resp.
|
hd [Ilist] |
Return the head of the list.
|
hedge_dummy [SHGraph.T] |
A dummy (never used) value for hyperedge identifiers (used for
the functions
XXX_multi )
|
hedge_dummy [SHGraph.S] | |
I | |
info [PSHGraph] | |
info [SHGraph.S] | |
info [SHGraph] | info g returns the user-information attached to the graph g
|
info [FGraph.S] | |
info [FGraph] | |
info [FGraph1.S] | |
info [FGraph1] | |
inter [MultiSetList.S] | |
inter [MultiSetList] | |
inter [SetList.S] | |
inter [SetList] | |
inter [PSette] | |
inter [Sette.Compare] | |
inter [Sette.S] |
Set intersection.
|
inter [Sette] | |
inter_set [MultiSetList.S] | |
inter_set [MultiSetList] | |
interset [PMappe] | |
interset [Mappe.Compare] | |
interset [Mappe.S] | |
interset [Mappe] | interset map set selects the bindings in a whose key belongs to
set .
|
intersetx [PDMappe] | |
intersetx [DMappe.S] | |
intersetx [DMappe] |
Select the two-way bindings
x <->y with x in the set
|
intersety [PDMappe] | |
intersety [DMappe.S] | |
intersety [DMappe] |
Select the two-way bindings
x <->y with y in the set
|
inv [Rational] | |
is_edge [FGraph.S] | |
is_edge [FGraph] | |
is_edge [FGraph1.S] | |
is_edge [FGraph1] | |
is_empty [PSHGraph] | |
is_empty [SHGraph.S] | |
is_empty [SHGraph] |
Is the graph empty ?
|
is_empty [FGraph.S] | |
is_empty [FGraph] | |
is_empty [FGraph1.S] | |
is_empty [FGraph1] | |
is_empty [MultiSetList.S] |
Test whether a multiset is empty or not.
|
is_empty [MultiSetList] |
Test whether a multiset is empty or not.
|
is_empty [SetList.S] |
Test whether a set is empty or not.
|
is_empty [SetList] |
Test whether a set is empty or not.
|
is_empty [PDMappe] | |
is_empty [DMappe.S] | |
is_empty [PMappe] | |
is_empty [Mappe.S] | |
is_empty [Mappe] |
Is the map empty ?
|
is_empty [PSette] |
Test whether a set is empty or not.
|
is_empty [Sette.S] |
Test whether a set is empty or not.
|
is_empty [Sette] |
Test whether a set is empty or not.
|
is_hedge [PSHGraph] | |
is_hedge [SHGraph.Compare] | |
is_hedge [SHGraph.S] | |
is_hedge [SHGraph] | |
is_vertex [PSHGraph] | |
is_vertex [SHGraph.Compare] | |
is_vertex [SHGraph.S] | |
is_vertex [SHGraph] | |
is_vertex [FGraph.S] | |
is_vertex [FGraph] | |
is_vertex [FGraph1.S] | |
is_vertex [FGraph1] | |
iter [Ilist] |
Ordinary iteration function.
|
iter [MultiSetList.S] | iter f s applies f in turn to all elements of s , with their
occurence number.
|
iter [MultiSetList] | iter f s applies f in turn to all elements of s , with their
occurence number.
|
iter [SetList.S] | iter f s applies f in turn to all elements of s .
|
iter [SetList] | iter f s applies f in turn to all elements of s .
|
iter [PDHashhe] | |
iter [DHashhe.S] | |
iter [DHashhe] |
Iterate on bindings.
|
iter [PDMappe] | |
iter [DMappe.S] | |
iter [DMappe] |
Iterate on bindings.
|
iter [PHashhe] | |
iter [Hashhe.S] | |
iter [Hashhe] | iter f tbl applies f to all bindings in table tbl .
|
iter [PMappe] | |
iter [Mappe.S] | |
iter [Mappe] | iter f m applies f to all bindings in map m .
|
iter [PSette] | iter f s applies f in turn to all elements of s .
|
iter [Sette.S] | iter f s applies f in turn to all elements of s .
|
iter [Sette] | iter f s applies f in turn to all elements of s .
|
iter_edge [FGraph.S] | |
iter_edge [FGraph] | |
iter_edge [FGraph1.S] | |
iter_edge [FGraph1] | |
iter_hedge [PSHGraph] | |
iter_hedge [SHGraph.S] | |
iter_hedge [SHGraph] |
Iterates the function
f hedge attrhedge succvertices predvertices to
all hyperedges of the graph.
|
iter_vertex [PSHGraph] | |
iter_vertex [SHGraph.S] | |
iter_vertex [SHGraph] |
Iterates the function
f vertex attrvertex succhedges predhedges to all
vertices of the graph.
|
iter_vertex [FGraph.S] | |
iter_vertex [FGraph] | |
iter_vertex [FGraph1.S] | |
iter_vertex [FGraph1] | |
L | |
length [Ilist] |
Return the ength of the list.
|
length [PHashhe] | |
length [Hashhe.S] | |
length [Hashhe] | length tbl returns the number of bindings in tbl .
|
lex_eol [Parse] |
Function to call on line returns in lexer
|
list [Ilist] |
Create a list element from a list.
|
list [Print] |
Print a list
|
M | |
make [Rational] | |
make [PSHGraph] | |
make [PSette] |
Internal, do not use
|
map [PSHGraph] | |
map [SHGraph.S] | |
map [SHGraph] | |
map [FGraph.S] | |
map [FGraph] | |
map [FGraph1.S] | |
map [FGraph1] | |
map [Ilist] |
Ordinary map function.
|
map [PHashhe] | |
map [Hashhe.S] | |
map [Hashhe] | map f tbl applies f to all bindings in table tbl and creates
a new hashtable associating the results of f to the same key type.
|
map [PMappe] | |
map [Mappe.S] | |
map [Mappe] | map f m returns a map with same domain as m , where the
associated value a of all bindings of m has been replaced by
the result of the application of f to a .
|
map_edge [FGraph.S] | |
map_edge [FGraph] | |
map_edge [FGraph1.S] | |
map_edge [FGraph1] | |
map_info [FGraph.S] | |
map_info [FGraph] | |
map_info [FGraph1.S] | |
map_info [FGraph1] | |
map_vertex [FGraph.S] | |
map_vertex [FGraph] | |
map_vertex [FGraph1.S] | |
map_vertex [FGraph1] | |
mapi [PMappe] | |
mapi [Mappe.S] | |
mapi [Mappe] |
Same as
map , but the function receives as arguments both the key
and the associated value for each binding of the map.
|
mapofset [PMappe] | |
mapofset [Mappe.S] | |
mapofset [Mappe] | mapofset f s returns the map associating f key to
key , for each element key of the set s
|
maptoset [PMappe] | |
maptoset [Mappe.S] | |
maptoset [Mappe] | maptoset m returns the set of the keys in the association table
|
mapx [PDMappe] | |
mapx [DMappe.S] | |
mapx [DMappe] | |
mapy [PDMappe] | |
mapy [DMappe.S] | |
mapy [DMappe] |
Return the correspondance map resp.
|
max [PSHGraph] | |
max [SHGraph.Compare] | |
max [SHGraph.S] | |
max [SHGraph] |
Return the set of vertices without successor hyperedges
|
max [FGraph.S] | |
max [FGraph] | |
max [FGraph1.S] | |
max [FGraph1] | |
max [MultiSetList.S] |
Return an element with the maximum occurence number, or raise
Not_found if the multiset is empty.
|
max [MultiSetList] |
Return an element with the maximum occurence number, or raise
Not_found if the multiset is empty.
|
max_elt [MultiSetList.S] |
Same as
min_elt , but returns the largest element of the given
multiset.
|
max_elt [MultiSetList] |
Same as
min_elt , but returns the largest element of the given
multiset.
|
max_elt [SetList.S] |
Same as
min_elt , but returns the largest element of the given
set.
|
max_elt [SetList] |
Same as
min_elt , but returns the largest element of the given
set.
|
max_elt [PSette] |
Same as
min_elt , but returns the largest element of the given
set.
|
max_elt [Sette.S] |
Same as
Sette.S.min_elt , but returns the largest element of the
given set.
|
max_elt [Sette] |
Same as
min_elt , but returns the largest element of the given
set.
|
max_key [PMappe] | |
max_key [Mappe.S] | |
max_key [Mappe] |
Same as
min_elt , but returns the largest key of the given
map.
|
maxs [MultiSetList.S] |
Return the set of elements with the maximum occurence number, or
raise
Not_found if the multiset is empty.
|
maxs [MultiSetList] |
Return the set of elements with the maximum occurence number, or raise
Not_found if the multiset is empty.
|
mean [Statistic] |
Returns the mean of the array.
|
mem [Ilist] |
Membership test.
|
mem [MultiSetList.S] | mem x s tests whether x belongs to the multiset s .
|
mem [MultiSetList] | mem x s tests whether x belongs to the multiset s .
|
mem [SetList.S] | mem x s tests whether x belongs to the set s .
|
mem [SetList] | mem x s tests whether x belongs to the set s .
|
mem [PHashhe] | |
mem [Hashhe.Compare] | |
mem [Hashhe.S] | |
mem [Hashhe] | mem tbl x checks if x is bound in tbl .
|
mem [PMappe] | |
mem [Mappe.Compare] | |
mem [Mappe.S] | |
mem [Mappe] | mem x m returns true if m contains a binding for m ,
and false otherwise.
|
mem [PSette] | mem x s tests whether x belongs to the set s .
|
mem [Sette.Compare] | |
mem [Sette.S] | mem x s tests whether x belongs to the set s .
|
mem [Sette] | mem x s tests whether x belongs to the set s .
|
memx [PDHashhe] | |
memx [DHashhe.S] | |
memx [DHashhe] |
Is the object registered ?
|
memx [PDMappe] | |
memx [DMappe.S] | |
memx [DMappe] |
Is the object in the map ?
|
memy [PDHashhe] | |
memy [DHashhe.S] | |
memy [DHashhe] |
Is the object registered ?
|
memy [PDMappe] | |
memy [DMappe.S] | |
memy [DMappe] |
Is the object in the map ?
|
merge [PDMappe] | |
merge [DMappe.S] | |
merge [DMappe] |
Merge the two double associations.
|
merge [PMappe] | |
merge [Mappe.Compare] | |
merge [Mappe.S] | |
merge [Mappe] | merge mergedata a b is similar to addmap a b , but if a key k
is bound to d1 in m1 and to d2 in m2 , the key k is bound
to mergedata d1 d2 in the result
|
mergei [PMappe] | |
mergei [Mappe.Compare] | |
mergei [Mappe.S] | |
mergei [Mappe] |
Same as
merge , but the function receives as arguments the key
(of the first map)
|
min [PSHGraph] | |
min [SHGraph.Compare] | |
min [SHGraph.S] | |
min [SHGraph] |
Return the set of vertices without predecessor hyperedges
|
min [FGraph.S] | |
min [FGraph] | |
min [FGraph1.S] | |
min [FGraph1] | |
min [MultiSetList.S] |
Return an element with the minimum occurence number, or raise
Not_found if the multiset is empty.
|
min [MultiSetList] |
Return an element with the minimum occurence number, or raise
Not_found if the multiset is empty.
|
min_elt [MultiSetList.S] |
Return the smallest element of the given multiset (with respect to the
Pervasives.compare ordering), or raise Not_found if the multiset is
empty.
|
min_elt [MultiSetList] |
Return the smallest element of the given multiset (with respect to the
Pervasives.compare ordering), or raise Not_found if the multiset is
empty.
|
min_elt [SetList.S] |
Return the smallest element of the given set (with respect to the
Ord.compare ordering), or raise Not_found if the set is empty.
|
min_elt [SetList] |
Return the smallest element of the given set (with respect to the
Pervasives.compare ordering), or raise Not_found if the set is
empty.
|
min_elt [PSette] |
Return the smallest element of the given set (with respect to the
Ord.compare ordering), or raise Not_found if the set is empty.
|
min_elt [Sette.S] |
Return the smallest element of the given set
(with respect to the
Ord.compare ordering), or raise
Not_found if the set is empty.
|
min_elt [Sette] |
Return the smallest element of the given set (with respect to the
Ord.compare ordering), or raise Not_found if the set is empty.
|
min_key [PMappe] | |
min_key [Mappe.S] | |
min_key [Mappe] |
Return the smallest key of the given map or
raise
Not_found if the set is empty.
|
mins [MultiSetList.S] |
Return the set of elements with the minimum occurence number, or
raise
Not_found if the multiset is empty.
|
mins [MultiSetList] |
Return the set of elements with the minimum occurence number, or raise
Not_found if the multiset is empty.
|
mul [Rational] | |
mult [MultiSetList.S] | mult elt mset returns the number of occurences of the element elt
in the multiset mset .
|
mult [MultiSetList] | mult elt mset returns the number of occurences of the element elt
in the multiset mset .
|
N | |
neg [Rational] | |
O | |
obj [FGraph.S] | |
obj [FGraph] | |
obj [Mappe.S] | |
obj [Sette.S] | |
of_list [Ilist] |
Create a recursive list from a list
|
of_list [SetList.S] |
Conversion from a list (unsafe operation)
|
of_list [SetList] |
Conversion from a list (unsafe operation)
|
of_set [MultiSetList.S] |
Conversion from sets of module
SetList .
|
of_set [MultiSetList] |
Conversion from sets of module
SetList .
|
of_string [Symbol] |
Returns the existing symbol associated to the (registered)
string.
|
option [Print] |
Print an optional element
|
P | |
pair [Print] |
Print a pair
|
parse_file [Parse] |
Same as before, but create itself a
lexbuf from the given filename.
|
parse_lexbuf [Parse] |
Takes as input a lexer, a parser compatible with the lexer
(ie, they share the same type for tokens), and a
lexbuf ,
|
parse_string [Parse] |
Same as before, but create itself a
lexbuf from the given string.
|
partition [MultiSetList.S] | partition p l returns a pair of multisets (l1, l2) , where l1 is
the multiset of all the elements of l that satisfy the predicate p ,
and l2 is the multiset of all the elements of l that do not satisfy
p .
|
partition [MultiSetList] | partition p l returns a pair of multisets (l1, l2) , where l1 is
the multiset of all the elements of l that satisfy the predicate p ,
and l2 is the multiset of all the elements of l that do not satisfy
p .
|
partition [SetList.S] | partition p s returns a pair of sets (s1, s2) , where s1 is the
set of all the elements of s that satisfy the predicate p , and s2
is the set of all the elements of s that do not satisfy p .
|
partition [SetList] | partition p s returns a pair of sets (s1, s2) , where s1 is the
set of all the elements of s that satisfy the predicate p , and s2
is the set of all the elements of s that do not satisfy p .
|
partition [PMappe] | |
partition [Mappe.Compare] | |
partition [Mappe.S] | |
partition [Mappe] | partition p m returns a pair of maps (m1, m2) , where m1 is
the map of all the bindings of m that satisfy the predicate p ,
and m2 is the map of all the bindings of m that do not satisfy
p .
|
partition [PSette] | partition p s returns a pair of sets (s1, s2) , where s1 is the
set of all the elements of s that satisfy the predicate p , and s2
is the set of all the elements of s that do not satisfy p .
|
partition [Sette.Compare] | |
partition [Sette.S] | partition p s returns a pair of sets (s1, s2) , where
s1 is the set of all the elements of s that satisfy the
predicate p , and s2 is the set of all the elements of
s that do not satisfy p .
|
partition [Sette] | partition p s returns a pair of sets (s1, s2) , where s1 is the
set of all the elements of s that satisfy the predicate p , and s2
is the set of all the elements of s that do not satisfy p .
|
pred [FGraph.S] | |
pred [FGraph] | |
pred [FGraph1.S] | |
pred [FGraph1] |
Expensive operation, requires iterations on all vertices
|
pred_vertex [PSHGraph] | |
pred_vertex [SHGraph.Compare] | |
pred_vertex [SHGraph.S] | |
pred_vertex [SHGraph] |
Predecessor vertices of a vertex by any hyperedge
|
predhedge [PSHGraph] | |
predhedge [SHGraph.Compare] | |
predhedge [SHGraph.S] | |
predhedge [SHGraph] |
Predecessor hyperedges of a vertex
|
predvertex [PSHGraph] | |
predvertex [SHGraph.Compare] | |
predvertex [SHGraph.S] | |
predvertex [SHGraph] |
Predecessor vertices of an hyperedge
|
print [Rational] | |
print [Symbol] |
Prints the symbol (its associated string).
|
print [PSHGraph] | |
print [SHGraph.Compare] | |
print [SHGraph.S] | |
print [SHGraph] |
Print a graph in textual format on the given formatter, using the given
functions to resp.
|
print [FGraph.S] | |
print [FGraph] | |
print [FGraph1.S] | |
print [FGraph1] | |
print [Ilist] |
Printing function.
|
print [MultiSetList.S] |
Printing function
|
print [MultiSetList] |
Printing function
|
print [SetList.S] |
Printing function
|
print [SetList] |
Printing function
|
print [PDHashhe] | |
print [DHashhe.S] | |
print [DHashhe] |
Print the set of bindings.
|
print [PDMappe] | |
print [DMappe.S] | |
print [DMappe] |
Print the set of bindings.
|
print [PHashhe] | |
print [Hashhe.S] | |
print [Hashhe] | |
print [PMappe] | |
print [Mappe.S] | |
print [Mappe] |
Print a map.
|
print [PSette] | |
print [Sette.S] | |
print [Sette] | |
print_dot [PSHGraph] | |
print_dot [SHGraph.S] | |
print_dot [SHGraph] |
Output the graph in DOT format on the given formatter, using the given
functions to resp print:
|
print_dot [FGraph.S] | |
print_dot [FGraph] | |
print_hash [Symbol] |
Prints hashtables on symbols.
|
print_map [Symbol] |
Prints maps on symbols.
|
print_of_string [Print] |
Transforms a conversion-to-string function to a printing function.
|
print_set [Symbol] |
Prints sets of symbols.
|
R | |
reachable [PSHGraph] | |
reachable [SHGraph.Compare] | |
reachable [SHGraph.S] | |
reachable [SHGraph] |
Returns the set of vertices and hyperedges that are *NOT* reachable from
the given root vertex.
|
reachable [FGraph.S] | |
reachable [FGraph] | |
reachable [FGraph1.S] | |
reachable [FGraph1] | |
reachable_multi [PSHGraph] | |
reachable_multi [SHGraph.Compare] | |
reachable_multi [SHGraph.S] | |
reachable_multi [SHGraph] | |
reachable_multi [FGraph.S] | |
reachable_multi [FGraph] | |
reachable_multi [FGraph1.S] | |
reachable_multi [FGraph1] | |
remove [MultiSetList.S] | remove x s returns a multiset containing all elements of s , with
the occurence number of x decremented.
|
remove [MultiSetList] | remove x s returns a multiset containing all elements of s , with
the occurence number of x decremented.
|
remove [SetList.S] | remove x s returns a set containing all elements of s , except
x .
|
remove [SetList] | remove x s returns a set containing all elements of s , except
x .
|
remove [PDMappe] | |
remove [DMappe.S] | |
remove [DMappe] |
Remove a binding defined by its first element and return the new map.
|
remove [PHashhe] | |
remove [Hashhe.Compare] | |
remove [Hashhe.S] | |
remove [Hashhe] | remove tbl x removes the current binding of x in tbl ,
restoring the previous binding if it exists.
|
remove [PMappe] | |
remove [Mappe.Compare] | |
remove [Mappe.S] | |
remove [Mappe] | remove x m returns a map containing the same bindings as m ,
except for x which is unbound in the returned map.
|
remove [PSette] | remove x s returns a set containing all elements of s , except
x .
|
remove [Sette.Compare] | |
remove [Sette.S] | remove x s returns a set containing all elements of s ,
except x .
|
remove [Sette] | remove x s returns a set containing all elements of s , except
x .
|
remove_edge [FGraph.S] | |
remove_edge [FGraph] | |
remove_edge [FGraph1.S] | |
remove_edge [FGraph1] | |
remove_hedge [PSHGraph] | |
remove_hedge [SHGraph.Compare] | |
remove_hedge [SHGraph.S] | |
remove_hedge [SHGraph] |
Remove the hyperedge from the graph.
|
remove_vertex [PSHGraph] | |
remove_vertex [SHGraph.Compare] | |
remove_vertex [SHGraph.S] | |
remove_vertex [SHGraph] |
Remove the vertex from the graph, as well as all related hyperedges.
|
remove_vertex [FGraph.S] | |
remove_vertex [FGraph] | |
remove_vertex [FGraph1.S] | |
remove_vertex [FGraph1] |
Expensive operation, requires iterations on all vertices
|
removex [PDHashhe] | |
removex [DHashhe.S] | |
removex [DHashhe] |
Remove a binding defined by its first element.
|
removex [PDMappe] | |
removey [PDHashhe] | |
removey [DHashhe.S] | |
removey [DHashhe] |
Remove a binding defined by its second element.
|
removey [PDMappe] | |
replace [PHashhe] | |
replace [Hashhe.Compare] | |
replace [Hashhe.S] | |
replace [Hashhe] | replace tbl x y replaces the current binding of x
in tbl by a binding of x to y .
|
replace_attrhedge [PSHGraph] | |
replace_attrhedge [SHGraph.Compare] | |
replace_attrhedge [SHGraph.S] | |
replace_attrhedge [SHGraph] |
Change the attribute of an existing hyperedge
|
replace_attrvertex [PSHGraph] | |
replace_attrvertex [SHGraph.Compare] | |
replace_attrvertex [SHGraph.S] | |
replace_attrvertex [SHGraph] |
Change the attribute of an existing vertex
|
repr [FGraph.S] | |
repr [FGraph] | |
repr [Mappe.S] | |
repr [Sette.S] | |
resize [Hashhe.Compare] | |
rev [Ilist] |
Recursively reverse the recursive list
rev [a;[b;[c];d];e;[f]] = [[f];e;[d;[c];b];a]
|
S | |
scfc [PSHGraph] | |
scfc [SHGraph.Compare] | |
scfc [SHGraph.S] | |
scfc [SHGraph] |
Decomposition of the graph into Strongly Connected Sub-Components,
|
scfc [FGraph.S] | |
scfc [FGraph] | |
scfc [FGraph1.S] | |
scfc [FGraph1] | |
scfc_multi [PSHGraph] | |
scfc_multi [SHGraph.Compare] | |
scfc_multi [SHGraph.S] | |
scfc_multi [SHGraph] |
idem, but from several initial vertices.
|
scfc_multi [FGraph.S] | |
scfc_multi [FGraph] | |
scfc_multi [FGraph1.S] | |
scfc_multi [FGraph1] | |
set_info [FGraph.S] | |
set_info [FGraph] | |
set_info [FGraph1.S] | |
set_info [FGraph1] | |
setx [PDMappe] | |
setx [DMappe.S] | |
setx [DMappe] |
Return the set of all objects in the first place of bindings.
|
sety [PDMappe] | |
sety [DMappe.S] | |
sety [DMappe] |
Return the set of all objects in the second place of bindings.
|
singleton [MultiSetList.S] | singleton x returns the one-element multiset containing only
x .
|
singleton [MultiSetList] | singleton x returns the one-element multiset containing only x .
|
singleton [SetList.S] | singleton x returns the one-element set containing only x .
|
singleton [SetList] | singleton x returns the one-element set containing only x .
|
singleton [PSette] | singleton x returns the one-element set containing only x .
|
singleton [Sette.S] | singleton x returns the one-element set containing only x .
|
singleton [Sette] | singleton x returns the one-element set containing only x .
|
size [PSHGraph] | |
size [SHGraph.S] | |
size [SHGraph] | size graph returns (nbvertex,nbhedge,nbedgevh,nbedgehv)
|
size [FGraph.S] | |
size [FGraph] | |
size [FGraph1.S] | |
size [FGraph1] | |
size_edge [FGraph.S] | |
size_edge [FGraph] | |
size_edgehv [PSHGraph] | |
size_edgehv [SHGraph.S] | |
size_edgehv [SHGraph] |
Number of edges (hyperedge,vertex) in the hypergraph
|
size_edgevh [PSHGraph] | |
size_edgevh [SHGraph.S] | |
size_edgevh [SHGraph] |
Number of edges (vertex,hyperedge) in the hypergraph
|
size_hedge [PSHGraph] | |
size_hedge [SHGraph.S] | |
size_hedge [SHGraph] |
Number of hyperedges in the hypergraph
|
size_vertex [PSHGraph] | |
size_vertex [SHGraph.S] | |
size_vertex [SHGraph] |
Number of vertices in the hypergraph
|
size_vertex [FGraph.S] | |
size_vertex [FGraph] | |
split [Sette.Compare] |
Meant to be internal, but exporting needed for Mappe.maptoset.
|
sprintf [Print] |
Better
sprintf function than Format.sprintf , as it takes the same
kind of formatters as other Format.Xprintf functions.
|
std_deviation [Statistic] |
Given the mean, returns the standard deviation of the array.
|
stdcompare [PSHGraph] | |
stdcompare [SHGraph.S] | |
stdcompare [SHGraph] | |
stdcompare [PHashhe] | |
stdcompare [Hashhe] | |
string_of_print [Print] |
Transforms a printing function into a conversion-to-string function.
|
sub [Rational] | |
subset [MultiSetList.S] | subset s1 s2 tests whether the multiset s1 is a subset of
the multiset s2 .
|
subset [MultiSetList] | subset s1 s2 tests whether the multiset s1 is a subset of
the multiset s2 .
|
subset [SetList.S] | subset s1 s2 tests whether the set s1 is a subset of
the set s2 .
|
subset [SetList] | subset s1 s2 tests whether the set s1 is a subset of
the set s2 .
|
subset [PMappe] | |
subset [Mappe.Compare] | |
subset [Mappe.S] | |
subset [Mappe] | |
subset [PSette] | subset s1 s2 tests whether the set s1 is a subset of
the set s2 .
|
subset [Sette.Compare] | |
subset [Sette.S] | subset s1 s2 tests whether the set s1 is a subset of
the set s2 .
|
subset [Sette] | subset s1 s2 tests whether the set s1 is a subset of
the set s2 .
|
subseti [PMappe] | |
subseti [Mappe.Compare] | |
subseti [Mappe.S] | |
subseti [Mappe] |
subset between maps
|
subsetx [PDMappe] | |
subsetx [DMappe.S] | |
subsetx [DMappe] | |
subsety [PDMappe] | |
subsety [DMappe.S] | |
subsety [DMappe] |
Test two two-way association for equality and inclusion.
|
succ [FGraph.S] | |
succ [FGraph] | |
succ [FGraph1.S] | |
succ [FGraph1] | |
succ_vertex [PSHGraph] | |
succ_vertex [SHGraph.Compare] | |
succ_vertex [SHGraph.S] | |
succ_vertex [SHGraph] |
Successor vertices of a vertex by any hyperedge
|
succhedge [PSHGraph] | |
succhedge [SHGraph.Compare] | |
succhedge [SHGraph.S] | |
succhedge [SHGraph] |
Successor hyperedges of a vertex
|
succvertex [PSHGraph] | |
succvertex [SHGraph.Compare] | |
succvertex [SHGraph.S] | |
succvertex [SHGraph] |
Successor vertices of an hyperedge
|
T | |
tl [Ilist] |
Return the tail of the list.
|
to_list [SetList.S] |
Conversion to a list
|
to_list [SetList] |
Conversion to a list
|
to_set [MultiSetList.S] | to_set m returns the set of elements in the multiset m .
|
to_set [MultiSetList] | to_set m returns the set of elements in the multiset m .
|
to_string [Rational] | |
to_string [Symbol] |
Returns the string represented by the symbol.
|
topological_sort [PSHGraph] | |
topological_sort [SHGraph.Compare] | |
topological_sort [SHGraph.S] | |
topological_sort [SHGraph] |
Topological sort of the vertices of the hypergraph starting from
a root vertex.
|
topological_sort [FGraph.S] | |
topological_sort [FGraph] | |
topological_sort [FGraph1.S] | |
topological_sort [FGraph1] | |
topological_sort_multi [PSHGraph] | |
topological_sort_multi [SHGraph.Compare] | |
topological_sort_multi [SHGraph.S] | |
topological_sort_multi [SHGraph] |
Topological sort from a set of root vertices.
|
topological_sort_multi [FGraph.S] | |
topological_sort_multi [FGraph] | |
topological_sort_multi [FGraph1.S] | |
topological_sort_multi [FGraph1] | |
transpose [PSHGraph] | |
transpose [SHGraph.S] | |
transpose [SHGraph] |
Similar to
copy , but hyperedges are reversed: successor vertices
and predecessor vertices are exchanged.
|
transpose [FGraph.S] | |
transpose [FGraph] | |
U | |
union [Union] |
Computes the union of two sets and returns the resulting set
|
union [MultiSetList.S] | |
union [MultiSetList] | |
union [SetList.S] | |
union [SetList] | |
union [PSette] | |
union [Sette.Compare] | |
union [Sette.S] |
Set union.
|
union [Sette] | |
union_set [MultiSetList.S] | |
union_set [MultiSetList] | |
V | |
variance [Statistic] |
Given the mean, returns the variance of the array.
|
vertex_dummy [SHGraph.T] |
A dummy (never used) value for vertex identifiers (used for the
functions
XXX_multi )
|
vertex_dummy [SHGraph.S] | |
vertices [FGraph.S] | |
vertices [FGraph] | |
vertices [FGraph1.S] | |
vertices [FGraph1] | |
W | |
weak [Print] |
Print a weak pointer array
|
wrap_duration [Time] | wrap_duration duration f executes the function f and stores into
!duration the time spent in f , in seconds.
|
wrap_duration_add [Time] |
Similar to
wrap_duration , but here the time spent in f is added to
the value !duration .
|
X | |
x_of_y [PDHashhe] | |
x_of_y [DHashhe.S] | |
x_of_y [DHashhe] |
Inverse association.
|
x_of_y [PDMappe] | |
x_of_y [DMappe.S] | |
x_of_y [DMappe] |
Inverse association
|
Y | |
y_of_x [PDHashhe] | |
y_of_x [DHashhe.S] | |
y_of_x [DHashhe] |
Association.
|
y_of_x [PDMappe] | |
y_of_x [DMappe.S] | |
y_of_x [DMappe] |
Association
|