A | |
| add [Emc.S.ARITH] | |
| add [Zdd.ARITH] | |
| add [Zdd] | |
| apply [Tiling.Tile] | apply i t creates a new tile by applying transformation i to t
|
| apply [Tiling.Pattern] | apply i p creates a new pattern which is the result of the
transformation of p by i
|
B | |
| bottom [Zdd] | |
C | |
| cardinal [Zdd.Cardinal] | |
| cardinal [Zdd] | |
| choose [Zdd] | |
| choose_list [Zdd] | |
| compare [Zdd] | |
| construct [Zdd] |
Smart constructors for ZDD.
|
| count_solutions [Emc.S.Count] | |
| count_solutions [Emc.S] |
The total number of solutions.
|
| count_solutions [Dlx] |
Returns the number of solutions.
|
| create [Tiling.Tile] |
construct a tile from his name, its symetries
s and
its multiplicity m.
|
| create [Tiling.Pattern] | create m creates a pattern of type t from a boolean matrix
|
| create [Emc.Sat] | |
| create [Emc.S] |
Creates an EMC problem.
|
| create [Dlx] |
Creates a DLX data structure from a matrix of Boolean values.
|
| create_problem [Tiling] |
construct a problem from his name, the board pattern and
a list of tile
|
| create_sparse [Emc.Sat] | |
| create_sparse [Emc.S] |
To be used instead of
create when the matrix is large but sparse.
|
| create_sparse [Dlx] |
To be used when the matrix is sparse.
|
| crop [Tiling.Pattern] | crop p x y w h creates a pattern from p with the rectangle of size
w, h at position x, y in p
|
D | |
| diff [Tiling.Pattern] | inter p1 p2 creates a pattern from the logical difference
beetween p1 and p2
|
| diff [Zdd] | |
E | |
| elements [Zdd] | |
| emc [Tiling] |
Encode the given problem under EMC
|
| empty [Zdd] | |
| equal [Zdd] | |
| exists [Zdd] | |
F | |
| filter [Zdd] | |
| find_solution [Emc.S] |
Returns the first solution that is found.
|
| fold [Zdd] | |
| for_all [Zdd] | |
G | |
| get_first_solution [Dlx] |
Returns the first solution that is found.
|
H | |
| has_iso [Tiling.Pattern] | has_iso t p returns true if p is invariant by i
|
I | |
| inter [Tiling.Pattern] | inter p1 p2 creates a pattern from the logical intersection
beetween p1 and p2
|
| inter [Zdd] | |
| is_empty [Zdd] | |
| iter [Zdd] | |
| iter_list [Zdd] | |
| iter_solution [Emc.S] | Emc.iter_solution f p applies f in turn to each solution.
|
| iter_solution [Dlx] | iter_solution f p applies f on each solution of the problem p,
one at a time.
|
L | |
| list_of_solution [Dlx] |
Decodes a solution as a list of rows (rows are 0-based)
|
M | |
| max_elt [Zdd] | |
| mem [Zdd] | |
| memo_rec1 [Zdd] | |
| memo_rec2 [Zdd] | |
| min_elt [Zdd] | |
O | |
| one [Emc.S.ARITH] | |
| one [Zdd.ARITH] | |
P | |
| partition [Zdd] | |
| print [Tiling.Tile] |
print a tile
|
| print [Tiling.Pattern] |
print a pattern
|
| print [Emc.Sat] | |
| print [Zdd] |
Prints a ZDD as a set of sets of integers, e.g.
|
| print_boolean_array [Emc] | |
| print_boolean_matrix [Emc] | |
| print_emc [Tiling] | |
| print_emc_size [Tiling] | |
| print_in_file [Emc.Sat] | |
| print_matrix_size [Emc] | |
| print_problem [Tiling] |
print a problem
|
| print_solution [Dlx] |
Print a solution, as a space-separated list of integers
|
| print_solution_ascii [Tiling] |
print a solution with ascii symboles to draw tiles
|
| print_solution_to_svg [Tiling] |
print a solution under the svg format
|
| print_solution_to_svg_file [Tiling] |
print a solution to the svg format on the given file
|
| print_to_dot [Zdd] | print_to_dot fmt z prints a ZDD z in DOT format
|
| print_to_dot_file [Zdd] | print_to_dot f z outputs ZDD z in DOT format in file f
|
R | |
| remove [Zdd] | |
| resize [Tiling.Pattern] | resize p w h change the size of p to w (width) and h (height).
|
S | |
| shift [Tiling.Pattern] | shift p ofsx ofsy shift pattern p by osfx, osfy
|
| singleton [Zdd] | |
| size [Zdd] |
Number of internal nodes of a given ZDD.
|
| split [Zdd] | |
| stat [Zdd] |
Returns the total number of unique ZDD built so far
|
| subset [Zdd] | |
T | |
| top [Zdd] | |
U | |
| union [Tiling.Pattern] | union p1 p2 creates a pattern from the logical union beetween p1 and
p2
|
| union [Zdd] | |
| unique [Zdd] |
Each ZDD has a unique integer
|
X | |
| xor [Tiling.Pattern] | xor p1 p2 creates a pattern from the logical xor
beetween p1 and p2
|
Z | |
| zero [Emc.S.ARITH] | |
| zero [Zdd.ARITH] |