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
|