add isl_map_align_params
[platform/upstream/isl.git] / doc / user.pod
1 =head1 Introduction
2
3 C<isl> is a thread-safe C library for manipulating
4 sets and relations of integer points bounded by affine constraints.
5 The descriptions of the sets and relations may involve
6 both parameters and existentially quantified variables.
7 All computations are performed in exact integer arithmetic
8 using C<GMP>.
9 The C<isl> library offers functionality that is similar
10 to that offered by the C<Omega> and C<Omega+> libraries,
11 but the underlying algorithms are in most cases completely different.
12
13 The library is by no means complete and some fairly basic
14 functionality is still missing.
15 Still, even in its current form, the library has been successfully
16 used as a backend polyhedral library for the polyhedral
17 scanner C<CLooG> and as part of an equivalence checker of
18 static affine programs.
19 For bug reports, feature requests and questions,
20 visit the the discussion group at
21 L<http://groups.google.com/group/isl-development>.
22
23 =head2 Backward Incompatible Changes
24
25 =head3 Changes since isl-0.02
26
27 =over
28
29 =item * The old printing functions have been deprecated
30 and replaced by C<isl_printer> functions, see L<Input and Output>.
31
32 =item * Most functions related to dependence analysis have acquired
33 an extra C<must> argument.  To obtain the old behavior, this argument
34 should be given the value 1.  See L<Dependence Analysis>.
35
36 =back
37
38 =head3 Changes since isl-0.03
39
40 =over
41
42 =item * The function C<isl_pw_qpolynomial_fold_add> has been
43 renamed to C<isl_pw_qpolynomial_fold_fold>.
44 Similarly, C<isl_union_pw_qpolynomial_fold_add> has been
45 renamed to C<isl_union_pw_qpolynomial_fold_fold>.
46
47 =back
48
49 =head3 Changes since isl-0.04
50
51 =over
52
53 =item * All header files have been renamed from C<isl_header.h>
54 to C<isl/header.h>.
55
56 =back
57
58 =head3 Changes since isl-0.05
59
60 =over
61
62 =item * The functions C<isl_printer_print_basic_set> and
63 C<isl_printer_print_basic_map> no longer print a newline.
64
65 =item * The functions C<isl_flow_get_no_source>
66 and C<isl_union_map_compute_flow> now return
67 the accesses for which no source could be found instead of
68 the iterations where those accesses occur.
69
70 =item * The functions C<isl_basic_map_identity> and
71 C<isl_map_identity> now take the dimension specification
72 of a B<map> as input.  An old call
73 C<isl_map_identity(dim)> can be rewritten to
74 C<isl_map_identity(isl_dim_map_from_set(dim))>.
75
76 =item * The function C<isl_map_power> no longer takes
77 a parameter position as input.  Instead, the exponent
78 is now expressed as the domain of the resulting relation.
79
80 =back
81
82 =head1 Installation
83
84 The source of C<isl> can be obtained either as a tarball
85 or from the git repository.  Both are available from
86 L<http://freshmeat.net/projects/isl/>.
87 The installation process depends on how you obtained
88 the source.
89
90 =head2 Installation from the git repository
91
92 =over
93
94 =item 1 Clone or update the repository
95
96 The first time the source is obtained, you need to clone
97 the repository.
98
99         git clone git://repo.or.cz/isl.git
100
101 To obtain updates, you need to pull in the latest changes
102
103         git pull
104
105 =item 2 Generate C<configure>
106
107         ./autogen.sh
108
109 =back
110
111 After performing the above steps, continue
112 with the L<Common installation instructions>.
113
114 =head2 Common installation instructions
115
116 =over
117
118 =item 1 Obtain C<GMP>
119
120 Building C<isl> requires C<GMP>, including its headers files.
121 Your distribution may not provide these header files by default
122 and you may need to install a package called C<gmp-devel> or something
123 similar.  Alternatively, C<GMP> can be built from
124 source, available from L<http://gmplib.org/>.
125
126 =item 2 Configure
127
128 C<isl> uses the standard C<autoconf> C<configure> script.
129 To run it, just type
130
131         ./configure
132
133 optionally followed by some configure options.
134 A complete list of options can be obtained by running
135
136         ./configure --help
137
138 Below we discuss some of the more common options.
139
140 C<isl> can optionally use C<piplib>, but no
141 C<piplib> functionality is currently used by default.
142 The C<--with-piplib> option can
143 be used to specify which C<piplib>
144 library to use, either an installed version (C<system>),
145 an externally built version (C<build>)
146 or no version (C<no>).  The option C<build> is mostly useful
147 in C<configure> scripts of larger projects that bundle both C<isl>
148 and C<piplib>.
149
150 =over
151
152 =item C<--prefix>
153
154 Installation prefix for C<isl>
155
156 =item C<--with-gmp-prefix>
157
158 Installation prefix for C<GMP> (architecture-independent files).
159
160 =item C<--with-gmp-exec-prefix>
161
162 Installation prefix for C<GMP> (architecture-dependent files).
163
164 =item C<--with-piplib>
165
166 Which copy of C<piplib> to use, either C<no> (default), C<system> or C<build>.
167
168 =item C<--with-piplib-prefix>
169
170 Installation prefix for C<system> C<piplib> (architecture-independent files).
171
172 =item C<--with-piplib-exec-prefix>
173
174 Installation prefix for C<system> C<piplib> (architecture-dependent files).
175
176 =item C<--with-piplib-builddir>
177
178 Location where C<build> C<piplib> was built.
179
180 =back
181
182 =item 3 Compile
183
184         make
185
186 =item 4 Install (optional)
187
188         make install
189
190 =back
191
192 =head1 Library
193
194 =head2 Initialization
195
196 All manipulations of integer sets and relations occur within
197 the context of an C<isl_ctx>.
198 A given C<isl_ctx> can only be used within a single thread.
199 All arguments of a function are required to have been allocated
200 within the same context.
201 There are currently no functions available for moving an object
202 from one C<isl_ctx> to another C<isl_ctx>.  This means that
203 there is currently no way of safely moving an object from one
204 thread to another, unless the whole C<isl_ctx> is moved.
205
206 An C<isl_ctx> can be allocated using C<isl_ctx_alloc> and
207 freed using C<isl_ctx_free>.
208 All objects allocated within an C<isl_ctx> should be freed
209 before the C<isl_ctx> itself is freed.
210
211         isl_ctx *isl_ctx_alloc();
212         void isl_ctx_free(isl_ctx *ctx);
213
214 =head2 Integers
215
216 All operations on integers, mainly the coefficients
217 of the constraints describing the sets and relations,
218 are performed in exact integer arithmetic using C<GMP>.
219 However, to allow future versions of C<isl> to optionally
220 support fixed integer arithmetic, all calls to C<GMP>
221 are wrapped inside C<isl> specific macros.
222 The basic type is C<isl_int> and the operations below
223 are available on this type.
224 The meanings of these operations are essentially the same
225 as their C<GMP> C<mpz_> counterparts.
226 As always with C<GMP> types, C<isl_int>s need to be
227 initialized with C<isl_int_init> before they can be used
228 and they need to be released with C<isl_int_clear>
229 after the last use.
230 The user should not assume that an C<isl_int> is represented
231 as a C<mpz_t>, but should instead explicitly convert between
232 C<mpz_t>s and C<isl_int>s using C<isl_int_set_gmp> and
233 C<isl_int_get_gmp> whenever a C<mpz_t> is required.
234
235 =over
236
237 =item isl_int_init(i)
238
239 =item isl_int_clear(i)
240
241 =item isl_int_set(r,i)
242
243 =item isl_int_set_si(r,i)
244
245 =item isl_int_set_gmp(r,g)
246
247 =item isl_int_get_gmp(i,g)
248
249 =item isl_int_abs(r,i)
250
251 =item isl_int_neg(r,i)
252
253 =item isl_int_swap(i,j)
254
255 =item isl_int_swap_or_set(i,j)
256
257 =item isl_int_add_ui(r,i,j)
258
259 =item isl_int_sub_ui(r,i,j)
260
261 =item isl_int_add(r,i,j)
262
263 =item isl_int_sub(r,i,j)
264
265 =item isl_int_mul(r,i,j)
266
267 =item isl_int_mul_ui(r,i,j)
268
269 =item isl_int_addmul(r,i,j)
270
271 =item isl_int_submul(r,i,j)
272
273 =item isl_int_gcd(r,i,j)
274
275 =item isl_int_lcm(r,i,j)
276
277 =item isl_int_divexact(r,i,j)
278
279 =item isl_int_cdiv_q(r,i,j)
280
281 =item isl_int_fdiv_q(r,i,j)
282
283 =item isl_int_fdiv_r(r,i,j)
284
285 =item isl_int_fdiv_q_ui(r,i,j)
286
287 =item isl_int_read(r,s)
288
289 =item isl_int_print(out,i,width)
290
291 =item isl_int_sgn(i)
292
293 =item isl_int_cmp(i,j)
294
295 =item isl_int_cmp_si(i,si)
296
297 =item isl_int_eq(i,j)
298
299 =item isl_int_ne(i,j)
300
301 =item isl_int_lt(i,j)
302
303 =item isl_int_le(i,j)
304
305 =item isl_int_gt(i,j)
306
307 =item isl_int_ge(i,j)
308
309 =item isl_int_abs_eq(i,j)
310
311 =item isl_int_abs_ne(i,j)
312
313 =item isl_int_abs_lt(i,j)
314
315 =item isl_int_abs_gt(i,j)
316
317 =item isl_int_abs_ge(i,j)
318
319 =item isl_int_is_zero(i)
320
321 =item isl_int_is_one(i)
322
323 =item isl_int_is_negone(i)
324
325 =item isl_int_is_pos(i)
326
327 =item isl_int_is_neg(i)
328
329 =item isl_int_is_nonpos(i)
330
331 =item isl_int_is_nonneg(i)
332
333 =item isl_int_is_divisible_by(i,j)
334
335 =back
336
337 =head2 Sets and Relations
338
339 C<isl> uses six types of objects for representing sets and relations,
340 C<isl_basic_set>, C<isl_basic_map>, C<isl_set>, C<isl_map>,
341 C<isl_union_set> and C<isl_union_map>.
342 C<isl_basic_set> and C<isl_basic_map> represent sets and relations that
343 can be described as a conjunction of affine constraints, while
344 C<isl_set> and C<isl_map> represent unions of
345 C<isl_basic_set>s and C<isl_basic_map>s, respectively.
346 However, all C<isl_basic_set>s or C<isl_basic_map>s in the union need
347 to have the same dimension.  C<isl_union_set>s and C<isl_union_map>s
348 represent unions of C<isl_set>s or C<isl_map>s of I<different> dimensions,
349 where dimensions with different space names
350 (see L<Dimension Specifications>) are considered different as well.
351 The difference between sets and relations (maps) is that sets have
352 one set of variables, while relations have two sets of variables,
353 input variables and output variables.
354
355 =head2 Memory Management
356
357 Since a high-level operation on sets and/or relations usually involves
358 several substeps and since the user is usually not interested in
359 the intermediate results, most functions that return a new object
360 will also release all the objects passed as arguments.
361 If the user still wants to use one or more of these arguments
362 after the function call, she should pass along a copy of the
363 object rather than the object itself.
364 The user is then responsible for making sure that the original
365 object gets used somewhere else or is explicitly freed.
366
367 The arguments and return values of all documents functions are
368 annotated to make clear which arguments are released and which
369 arguments are preserved.  In particular, the following annotations
370 are used
371
372 =over
373
374 =item C<__isl_give>
375
376 C<__isl_give> means that a new object is returned.
377 The user should make sure that the returned pointer is
378 used exactly once as a value for an C<__isl_take> argument.
379 In between, it can be used as a value for as many
380 C<__isl_keep> arguments as the user likes.
381 There is one exception, and that is the case where the
382 pointer returned is C<NULL>.  Is this case, the user
383 is free to use it as an C<__isl_take> argument or not.
384
385 =item C<__isl_take>
386
387 C<__isl_take> means that the object the argument points to
388 is taken over by the function and may no longer be used
389 by the user as an argument to any other function.
390 The pointer value must be one returned by a function
391 returning an C<__isl_give> pointer.
392 If the user passes in a C<NULL> value, then this will
393 be treated as an error in the sense that the function will
394 not perform its usual operation.  However, it will still
395 make sure that all the the other C<__isl_take> arguments
396 are released.
397
398 =item C<__isl_keep>
399
400 C<__isl_keep> means that the function will only use the object
401 temporarily.  After the function has finished, the user
402 can still use it as an argument to other functions.
403 A C<NULL> value will be treated in the same way as
404 a C<NULL> value for an C<__isl_take> argument.
405
406 =back
407
408 =head2 Dimension Specifications
409
410 Whenever a new set or relation is created from scratch,
411 its dimension needs to be specified using an C<isl_dim>.
412
413         #include <isl/dim.h>
414         __isl_give isl_dim *isl_dim_alloc(isl_ctx *ctx,
415                 unsigned nparam, unsigned n_in, unsigned n_out);
416         __isl_give isl_dim *isl_dim_set_alloc(isl_ctx *ctx,
417                 unsigned nparam, unsigned dim);
418         __isl_give isl_dim *isl_dim_copy(__isl_keep isl_dim *dim);
419         void isl_dim_free(__isl_take isl_dim *dim);
420         unsigned isl_dim_size(__isl_keep isl_dim *dim,
421                 enum isl_dim_type type);
422
423 The dimension specification used for creating a set
424 needs to be created using C<isl_dim_set_alloc>, while
425 that for creating a relation
426 needs to be created using C<isl_dim_alloc>.
427 C<isl_dim_size> can be used
428 to find out the number of dimensions of each type in
429 a dimension specification, where type may be
430 C<isl_dim_param>, C<isl_dim_in> (only for relations),
431 C<isl_dim_out> (only for relations), C<isl_dim_set>
432 (only for sets) or C<isl_dim_all>.
433
434 It is often useful to create objects that live in the
435 same space as some other object.  This can be accomplished
436 by creating the new objects
437 (see L<Creating New Sets and Relations> or
438 L<Creating New (Piecewise) Quasipolynomials>) based on the dimension
439 specification of the original object.
440
441         #include <isl/set.h>
442         __isl_give isl_dim *isl_basic_set_get_dim(
443                 __isl_keep isl_basic_set *bset);
444         __isl_give isl_dim *isl_set_get_dim(__isl_keep isl_set *set);
445
446         #include <isl/union_set.h>
447         __isl_give isl_dim *isl_union_set_get_dim(
448                 __isl_keep isl_union_set *uset);
449
450         #include <isl/map.h>
451         __isl_give isl_dim *isl_basic_map_get_dim(
452                 __isl_keep isl_basic_map *bmap);
453         __isl_give isl_dim *isl_map_get_dim(__isl_keep isl_map *map);
454
455         #include <isl/union_map.h>
456         __isl_give isl_dim *isl_union_map_get_dim(
457                 __isl_keep isl_union_map *umap);
458
459         #include <isl/constraint.h>
460         __isl_give isl_dim *isl_constraint_get_dim(
461                 __isl_keep isl_constraint *constraint);
462
463         #include <isl/polynomial.h>
464         __isl_give isl_dim *isl_qpolynomial_get_dim(
465                 __isl_keep isl_qpolynomial *qp);
466         __isl_give isl_dim *isl_pw_qpolynomial_get_dim(
467                 __isl_keep isl_pw_qpolynomial *pwqp);
468         __isl_give isl_dim *isl_union_pw_qpolynomial_get_dim(
469                 __isl_keep isl_union_pw_qpolynomial *upwqp);
470         __isl_give isl_dim *isl_union_pw_qpolynomial_fold_get_dim(
471                 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
472
473 The names of the individual dimensions may be set or read off
474 using the following functions.
475
476         #include <isl/dim.h>
477         __isl_give isl_dim *isl_dim_set_name(__isl_take isl_dim *dim,
478                                  enum isl_dim_type type, unsigned pos,
479                                  __isl_keep const char *name);
480         __isl_keep const char *isl_dim_get_name(__isl_keep isl_dim *dim,
481                                  enum isl_dim_type type, unsigned pos);
482
483 Note that C<isl_dim_get_name> returns a pointer to some internal
484 data structure, so the result can only be used while the
485 corresponding C<isl_dim> is alive.
486 Also note that every function that operates on two sets or relations
487 requires that both arguments have the same parameters.  This also
488 means that if one of the arguments has named parameters, then the
489 other needs to have named parameters too and the names need to match.
490 Pairs of C<isl_union_set> and/or C<isl_union_map> arguments may
491 have different parameters (as long as they are named), in which case
492 the result will have as parameters the union of the parameters of
493 the arguments.
494
495 The names of entire spaces may be set or read off
496 using the following functions.
497
498         #include <isl/dim.h>
499         __isl_give isl_dim *isl_dim_set_tuple_name(
500                 __isl_take isl_dim *dim,
501                 enum isl_dim_type type, const char *s);
502         const char *isl_dim_get_tuple_name(__isl_keep isl_dim *dim,
503                 enum isl_dim_type type);
504
505 The C<dim> argument needs to be one of C<isl_dim_in>, C<isl_dim_out>
506 or C<isl_dim_set>.  As with C<isl_dim_get_name>,
507 the C<isl_dim_get_tuple_name> function returns a pointer to some internal
508 data structure.
509 Binary operations require the corresponding spaces of their arguments
510 to have the same name.
511
512 Spaces can be nested.  In particular, the domain of a set or
513 the domain or range of a relation can be a nested relation.
514 The following functions can be used to construct and deconstruct
515 such nested dimension specifications.
516
517         #include <isl/dim.h>
518         int isl_dim_is_wrapping(__isl_keep isl_dim *dim);
519         __isl_give isl_dim *isl_dim_wrap(__isl_take isl_dim *dim);
520         __isl_give isl_dim *isl_dim_unwrap(__isl_take isl_dim *dim);
521
522 The input to C<isl_dim_is_wrapping> and C<isl_dim_unwrap> should
523 be the dimension specification of a set, while that of
524 C<isl_dim_wrap> should be the dimension specification of a relation.
525 Conversely, the output of C<isl_dim_unwrap> is the dimension specification
526 of a relation, while that of C<isl_dim_wrap> is the dimension specification
527 of a set.
528
529 Dimension specifications can be created from other dimension
530 specifications using the following functions.
531
532         __isl_give isl_dim *isl_dim_domain(__isl_take isl_dim *dim);
533         __isl_give isl_dim *isl_dim_from_domain(__isl_take isl_dim *dim);
534         __isl_give isl_dim *isl_dim_range(__isl_take isl_dim *dim);
535         __isl_give isl_dim *isl_dim_from_range(__isl_take isl_dim *dim);
536         __isl_give isl_dim *isl_dim_reverse(__isl_take isl_dim *dim);
537         __isl_give isl_dim *isl_dim_join(__isl_take isl_dim *left,
538                 __isl_take isl_dim *right);
539         __isl_give isl_dim *isl_dim_insert(__isl_take isl_dim *dim,
540                 enum isl_dim_type type, unsigned pos, unsigned n);
541         __isl_give isl_dim *isl_dim_add(__isl_take isl_dim *dim,
542                 enum isl_dim_type type, unsigned n);
543         __isl_give isl_dim *isl_dim_drop(__isl_take isl_dim *dim,
544                 enum isl_dim_type type, unsigned first, unsigned n);
545         __isl_give isl_dim *isl_dim_map_from_set(
546                 __isl_take isl_dim *dim);
547         __isl_give isl_dim *isl_dim_zip(__isl_take isl_dim *dim);
548
549 Note that if dimensions are added or removed from a space, then
550 the name and the internal structure are lost.
551
552 =head2 Input and Output
553
554 C<isl> supports its own input/output format, which is similar
555 to the C<Omega> format, but also supports the C<PolyLib> format
556 in some cases.
557
558 =head3 C<isl> format
559
560 The C<isl> format is similar to that of C<Omega>, but has a different
561 syntax for describing the parameters and allows for the definition
562 of an existentially quantified variable as the integer division
563 of an affine expression.
564 For example, the set of integers C<i> between C<0> and C<n>
565 such that C<i % 10 <= 6> can be described as
566
567         [n] -> { [i] : exists (a = [i/10] : 0 <= i and i <= n and
568                                 i - 10 a <= 6) }
569
570 A set or relation can have several disjuncts, separated
571 by the keyword C<or>.  Each disjunct is either a conjunction
572 of constraints or a projection (C<exists>) of a conjunction
573 of constraints.  The constraints are separated by the keyword
574 C<and>.
575
576 =head3 C<PolyLib> format
577
578 If the represented set is a union, then the first line
579 contains a single number representing the number of disjuncts.
580 Otherwise, a line containing the number C<1> is optional.
581
582 Each disjunct is represented by a matrix of constraints.
583 The first line contains two numbers representing
584 the number of rows and columns,
585 where the number of rows is equal to the number of constraints
586 and the number of columns is equal to two plus the number of variables.
587 The following lines contain the actual rows of the constraint matrix.
588 In each row, the first column indicates whether the constraint
589 is an equality (C<0>) or inequality (C<1>).  The final column
590 corresponds to the constant term.
591
592 If the set is parametric, then the coefficients of the parameters
593 appear in the last columns before the constant column.
594 The coefficients of any existentially quantified variables appear
595 between those of the set variables and those of the parameters.
596
597 =head3 Extended C<PolyLib> format
598
599 The extended C<PolyLib> format is nearly identical to the
600 C<PolyLib> format.  The only difference is that the line
601 containing the number of rows and columns of a constraint matrix
602 also contains four additional numbers:
603 the number of output dimensions, the number of input dimensions,
604 the number of local dimensions (i.e., the number of existentially
605 quantified variables) and the number of parameters.
606 For sets, the number of ``output'' dimensions is equal
607 to the number of set dimensions, while the number of ``input''
608 dimensions is zero.
609
610 =head3 Input
611
612         #include <isl/set.h>
613         __isl_give isl_basic_set *isl_basic_set_read_from_file(
614                 isl_ctx *ctx, FILE *input, int nparam);
615         __isl_give isl_basic_set *isl_basic_set_read_from_str(
616                 isl_ctx *ctx, const char *str, int nparam);
617         __isl_give isl_set *isl_set_read_from_file(isl_ctx *ctx,
618                 FILE *input, int nparam);
619         __isl_give isl_set *isl_set_read_from_str(isl_ctx *ctx,
620                 const char *str, int nparam);
621
622         #include <isl/map.h>
623         __isl_give isl_basic_map *isl_basic_map_read_from_file(
624                 isl_ctx *ctx, FILE *input, int nparam);
625         __isl_give isl_basic_map *isl_basic_map_read_from_str(
626                 isl_ctx *ctx, const char *str, int nparam);
627         __isl_give isl_map *isl_map_read_from_file(
628                 struct isl_ctx *ctx, FILE *input, int nparam);
629         __isl_give isl_map *isl_map_read_from_str(isl_ctx *ctx,
630                 const char *str, int nparam);
631
632         #include <isl/union_set.h>
633         __isl_give isl_union_set *isl_union_set_read_from_file(
634                 isl_ctx *ctx, FILE *input);
635         __isl_give isl_union_set *isl_union_set_read_from_str(
636                 struct isl_ctx *ctx, const char *str);
637
638         #include <isl/union_map.h>
639         __isl_give isl_union_map *isl_union_map_read_from_file(
640                 isl_ctx *ctx, FILE *input);
641         __isl_give isl_union_map *isl_union_map_read_from_str(
642                 struct isl_ctx *ctx, const char *str);
643
644 The input format is autodetected and may be either the C<PolyLib> format
645 or the C<isl> format.
646 C<nparam> specifies how many of the final columns in
647 the C<PolyLib> format correspond to parameters.
648 If input is given in the C<isl> format, then the number
649 of parameters needs to be equal to C<nparam>.
650 If C<nparam> is negative, then any number of parameters
651 is accepted in the C<isl> format and zero parameters
652 are assumed in the C<PolyLib> format.
653
654 =head3 Output
655
656 Before anything can be printed, an C<isl_printer> needs to
657 be created.
658
659         __isl_give isl_printer *isl_printer_to_file(isl_ctx *ctx,
660                 FILE *file);
661         __isl_give isl_printer *isl_printer_to_str(isl_ctx *ctx);
662         void isl_printer_free(__isl_take isl_printer *printer);
663         __isl_give char *isl_printer_get_str(
664                 __isl_keep isl_printer *printer);
665
666 The behavior of the printer can be modified in various ways
667
668         __isl_give isl_printer *isl_printer_set_output_format(
669                 __isl_take isl_printer *p, int output_format);
670         __isl_give isl_printer *isl_printer_set_indent(
671                 __isl_take isl_printer *p, int indent);
672         __isl_give isl_printer *isl_printer_set_prefix(
673                 __isl_take isl_printer *p, const char *prefix);
674         __isl_give isl_printer *isl_printer_set_suffix(
675                 __isl_take isl_printer *p, const char *suffix);
676
677 The C<output_format> may be either C<ISL_FORMAT_ISL>, C<ISL_FORMAT_OMEGA>,
678 C<ISL_FORMAT_POLYLIB>, C<ISL_FORMAT_EXT_POLYLIB> or C<ISL_FORMAT_LATEX>
679 and defaults to C<ISL_FORMAT_ISL>.
680 Each line in the output is indented by C<indent> spaces
681 (default: 0), prefixed by C<prefix> and suffixed by C<suffix>.
682 In the C<PolyLib> format output,
683 the coefficients of the existentially quantified variables
684 appear between those of the set variables and those
685 of the parameters.
686
687 To actually print something, use
688
689         #include <isl/set.h>
690         __isl_give isl_printer *isl_printer_print_basic_set(
691                 __isl_take isl_printer *printer,
692                 __isl_keep isl_basic_set *bset);
693         __isl_give isl_printer *isl_printer_print_set(
694                 __isl_take isl_printer *printer,
695                 __isl_keep isl_set *set);
696
697         #include <isl/map.h>
698         __isl_give isl_printer *isl_printer_print_basic_map(
699                 __isl_take isl_printer *printer,
700                 __isl_keep isl_basic_map *bmap);
701         __isl_give isl_printer *isl_printer_print_map(
702                 __isl_take isl_printer *printer,
703                 __isl_keep isl_map *map);
704
705         #include <isl/union_set.h>
706         __isl_give isl_printer *isl_printer_print_union_set(
707                 __isl_take isl_printer *p,
708                 __isl_keep isl_union_set *uset);
709
710         #include <isl/union_map.h>
711         __isl_give isl_printer *isl_printer_print_union_map(
712                 __isl_take isl_printer *p,
713                 __isl_keep isl_union_map *umap);
714
715 When called on a file printer, the following function flushes
716 the file.  When called on a string printer, the buffer is cleared.
717
718         __isl_give isl_printer *isl_printer_flush(
719                 __isl_take isl_printer *p);
720
721 =head2 Creating New Sets and Relations
722
723 C<isl> has functions for creating some standard sets and relations.
724
725 =over
726
727 =item * Empty sets and relations
728
729         __isl_give isl_basic_set *isl_basic_set_empty(
730                 __isl_take isl_dim *dim);
731         __isl_give isl_basic_map *isl_basic_map_empty(
732                 __isl_take isl_dim *dim);
733         __isl_give isl_set *isl_set_empty(
734                 __isl_take isl_dim *dim);
735         __isl_give isl_map *isl_map_empty(
736                 __isl_take isl_dim *dim);
737         __isl_give isl_union_set *isl_union_set_empty(
738                 __isl_take isl_dim *dim);
739         __isl_give isl_union_map *isl_union_map_empty(
740                 __isl_take isl_dim *dim);
741
742 For C<isl_union_set>s and C<isl_union_map>s, the dimensions specification
743 is only used to specify the parameters.
744
745 =item * Universe sets and relations
746
747         __isl_give isl_basic_set *isl_basic_set_universe(
748                 __isl_take isl_dim *dim);
749         __isl_give isl_basic_map *isl_basic_map_universe(
750                 __isl_take isl_dim *dim);
751         __isl_give isl_set *isl_set_universe(
752                 __isl_take isl_dim *dim);
753         __isl_give isl_map *isl_map_universe(
754                 __isl_take isl_dim *dim);
755         __isl_give isl_union_set *isl_union_set_universe(
756                 __isl_take isl_union_set *uset);
757         __isl_give isl_union_map *isl_union_map_universe(
758                 __isl_take isl_union_map *umap);
759
760 The sets and relations constructed by the functions above
761 contain all integer values, while those constructed by the
762 functions below only contain non-negative values.
763
764         __isl_give isl_basic_set *isl_basic_set_nat_universe(
765                 __isl_take isl_dim *dim);
766         __isl_give isl_basic_map *isl_basic_map_nat_universe(
767                 __isl_take isl_dim *dim);
768         __isl_give isl_set *isl_set_nat_universe(
769                 __isl_take isl_dim *dim);
770         __isl_give isl_map *isl_map_nat_universe(
771                 __isl_take isl_dim *dim);
772
773 =item * Identity relations
774
775         __isl_give isl_basic_map *isl_basic_map_identity(
776                 __isl_take isl_dim *dim);
777         __isl_give isl_map *isl_map_identity(
778                 __isl_take isl_dim *dim);
779
780 The number of input and output dimensions in C<dim> needs
781 to be the same.
782
783 =item * Lexicographic order
784
785         __isl_give isl_map *isl_map_lex_lt(
786                 __isl_take isl_dim *set_dim);
787         __isl_give isl_map *isl_map_lex_le(
788                 __isl_take isl_dim *set_dim);
789         __isl_give isl_map *isl_map_lex_gt(
790                 __isl_take isl_dim *set_dim);
791         __isl_give isl_map *isl_map_lex_ge(
792                 __isl_take isl_dim *set_dim);
793         __isl_give isl_map *isl_map_lex_lt_first(
794                 __isl_take isl_dim *dim, unsigned n);
795         __isl_give isl_map *isl_map_lex_le_first(
796                 __isl_take isl_dim *dim, unsigned n);
797         __isl_give isl_map *isl_map_lex_gt_first(
798                 __isl_take isl_dim *dim, unsigned n);
799         __isl_give isl_map *isl_map_lex_ge_first(
800                 __isl_take isl_dim *dim, unsigned n);
801
802 The first four functions take a dimension specification for a B<set>
803 and return relations that express that the elements in the domain
804 are lexicographically less
805 (C<isl_map_lex_lt>), less or equal (C<isl_map_lex_le>),
806 greater (C<isl_map_lex_gt>) or greater or equal (C<isl_map_lex_ge>)
807 than the elements in the range.
808 The last four functions take a dimension specification for a map
809 and return relations that express that the first C<n> dimensions
810 in the domain are lexicographically less
811 (C<isl_map_lex_lt_first>), less or equal (C<isl_map_lex_le_first>),
812 greater (C<isl_map_lex_gt_first>) or greater or equal (C<isl_map_lex_ge_first>)
813 than the first C<n> dimensions in the range.
814
815 =back
816
817 A basic set or relation can be converted to a set or relation
818 using the following functions.
819
820         __isl_give isl_set *isl_set_from_basic_set(
821                 __isl_take isl_basic_set *bset);
822         __isl_give isl_map *isl_map_from_basic_map(
823                 __isl_take isl_basic_map *bmap);
824
825 Sets and relations can be converted to union sets and relations
826 using the following functions.
827
828         __isl_give isl_union_map *isl_union_map_from_map(
829                 __isl_take isl_map *map);
830         __isl_give isl_union_set *isl_union_set_from_set(
831                 __isl_take isl_set *set);
832
833 Sets and relations can be copied and freed again using the following
834 functions.
835
836         __isl_give isl_basic_set *isl_basic_set_copy(
837                 __isl_keep isl_basic_set *bset);
838         __isl_give isl_set *isl_set_copy(__isl_keep isl_set *set);
839         __isl_give isl_union_set *isl_union_set_copy(
840                 __isl_keep isl_union_set *uset);
841         __isl_give isl_basic_map *isl_basic_map_copy(
842                 __isl_keep isl_basic_map *bmap);
843         __isl_give isl_map *isl_map_copy(__isl_keep isl_map *map);
844         __isl_give isl_union_map *isl_union_map_copy(
845                 __isl_keep isl_union_map *umap);
846         void isl_basic_set_free(__isl_take isl_basic_set *bset);
847         void isl_set_free(__isl_take isl_set *set);
848         void isl_union_set_free(__isl_take isl_union_set *uset);
849         void isl_basic_map_free(__isl_take isl_basic_map *bmap);
850         void isl_map_free(__isl_take isl_map *map);
851         void isl_union_map_free(__isl_take isl_union_map *umap);
852
853 Other sets and relations can be constructed by starting
854 from a universe set or relation, adding equality and/or
855 inequality constraints and then projecting out the
856 existentially quantified variables, if any.
857 Constraints can be constructed, manipulated and
858 added to basic sets and relations using the following functions.
859
860         #include <isl/constraint.h>
861         __isl_give isl_constraint *isl_equality_alloc(
862                 __isl_take isl_dim *dim);
863         __isl_give isl_constraint *isl_inequality_alloc(
864                 __isl_take isl_dim *dim);
865         void isl_constraint_set_constant(
866                 __isl_keep isl_constraint *constraint, isl_int v);
867         void isl_constraint_set_coefficient(
868                 __isl_keep isl_constraint *constraint,
869                 enum isl_dim_type type, int pos, isl_int v);
870         __isl_give isl_basic_map *isl_basic_map_add_constraint(
871                 __isl_take isl_basic_map *bmap,
872                 __isl_take isl_constraint *constraint);
873         __isl_give isl_basic_set *isl_basic_set_add_constraint(
874                 __isl_take isl_basic_set *bset,
875                 __isl_take isl_constraint *constraint);
876
877 For example, to create a set containing the even integers
878 between 10 and 42, you would use the following code.
879
880         isl_int v;
881         struct isl_dim *dim;
882         struct isl_constraint *c;
883         struct isl_basic_set *bset;
884
885         isl_int_init(v);
886         dim = isl_dim_set_alloc(ctx, 0, 2);
887         bset = isl_basic_set_universe(isl_dim_copy(dim));
888
889         c = isl_equality_alloc(isl_dim_copy(dim));
890         isl_int_set_si(v, -1);
891         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
892         isl_int_set_si(v, 2);
893         isl_constraint_set_coefficient(c, isl_dim_set, 1, v);
894         bset = isl_basic_set_add_constraint(bset, c);
895
896         c = isl_inequality_alloc(isl_dim_copy(dim));
897         isl_int_set_si(v, -10);
898         isl_constraint_set_constant(c, v);
899         isl_int_set_si(v, 1);
900         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
901         bset = isl_basic_set_add_constraint(bset, c);
902
903         c = isl_inequality_alloc(dim);
904         isl_int_set_si(v, 42);
905         isl_constraint_set_constant(c, v);
906         isl_int_set_si(v, -1);
907         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
908         bset = isl_basic_set_add_constraint(bset, c);
909
910         bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 1);
911
912         isl_int_clear(v);
913
914 Or, alternatively,
915
916         struct isl_basic_set *bset;
917         bset = isl_basic_set_read_from_str(ctx,
918                 "{[i] : exists (a : i = 2a and i >= 10 and i <= 42)}", -1);
919
920 A basic set or relation can also be constructed from two matrices
921 describing the equalities and the inequalities.
922
923         __isl_give isl_basic_set *isl_basic_set_from_constraint_matrices(
924                 __isl_take isl_dim *dim,
925                 __isl_take isl_mat *eq, __isl_take isl_mat *ineq,
926                 enum isl_dim_type c1,
927                 enum isl_dim_type c2, enum isl_dim_type c3,
928                 enum isl_dim_type c4);
929         __isl_give isl_basic_map *isl_basic_map_from_constraint_matrices(
930                 __isl_take isl_dim *dim,
931                 __isl_take isl_mat *eq, __isl_take isl_mat *ineq,
932                 enum isl_dim_type c1,
933                 enum isl_dim_type c2, enum isl_dim_type c3,
934                 enum isl_dim_type c4, enum isl_dim_type c5);
935
936 The C<isl_dim_type> arguments indicate the order in which
937 different kinds of variables appear in the input matrices
938 and should be a permutation of C<isl_dim_cst>, C<isl_dim_param>,
939 C<isl_dim_set> and C<isl_dim_div> for sets and
940 of C<isl_dim_cst>, C<isl_dim_param>,
941 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div> for relations.
942
943 =head2 Inspecting Sets and Relations
944
945 Usually, the user should not have to care about the actual constraints
946 of the sets and maps, but should instead apply the abstract operations
947 explained in the following sections.
948 Occasionally, however, it may be required to inspect the individual
949 coefficients of the constraints.  This section explains how to do so.
950 In these cases, it may also be useful to have C<isl> compute
951 an explicit representation of the existentially quantified variables.
952
953         __isl_give isl_set *isl_set_compute_divs(
954                 __isl_take isl_set *set);
955         __isl_give isl_map *isl_map_compute_divs(
956                 __isl_take isl_map *map);
957         __isl_give isl_union_set *isl_union_set_compute_divs(
958                 __isl_take isl_union_set *uset);
959         __isl_give isl_union_map *isl_union_map_compute_divs(
960                 __isl_take isl_union_map *umap);
961
962 This explicit representation defines the existentially quantified
963 variables as integer divisions of the other variables, possibly
964 including earlier existentially quantified variables.
965 An explicitly represented existentially quantified variable therefore
966 has a unique value when the values of the other variables are known.
967 If, furthermore, the same existentials, i.e., existentials
968 with the same explicit representations, should appear in the
969 same order in each of the disjuncts of a set or map, then the user should call
970 either of the following functions.
971
972         __isl_give isl_set *isl_set_align_divs(
973                 __isl_take isl_set *set);
974         __isl_give isl_map *isl_map_align_divs(
975                 __isl_take isl_map *map);
976
977 Alternatively, the existentially quantified variables can be removed
978 using the following functions, which compute an overapproximation.
979
980         __isl_give isl_basic_set *isl_basic_set_remove_divs(
981                 __isl_take isl_basic_set *bset);
982         __isl_give isl_basic_map *isl_basic_map_remove_divs(
983                 __isl_take isl_basic_map *bmap);
984         __isl_give isl_set *isl_set_remove_divs(
985                 __isl_take isl_set *set);
986         __isl_give isl_map *isl_map_remove_divs(
987                 __isl_take isl_map *map);
988
989 To iterate over all the sets or maps in a union set or map, use
990
991         int isl_union_set_foreach_set(__isl_keep isl_union_set *uset,
992                 int (*fn)(__isl_take isl_set *set, void *user),
993                 void *user);
994         int isl_union_map_foreach_map(__isl_keep isl_union_map *umap,
995                 int (*fn)(__isl_take isl_map *map, void *user),
996                 void *user);
997
998 The number of sets or maps in a union set or map can be obtained
999 from
1000
1001         int isl_union_set_n_set(__isl_keep isl_union_set *uset);
1002         int isl_union_map_n_map(__isl_keep isl_union_map *umap);
1003
1004 To extract the set or map from a union with a given dimension
1005 specification, use
1006
1007         __isl_give isl_set *isl_union_set_extract_set(
1008                 __isl_keep isl_union_set *uset,
1009                 __isl_take isl_dim *dim);
1010         __isl_give isl_map *isl_union_map_extract_map(
1011                 __isl_keep isl_union_map *umap,
1012                 __isl_take isl_dim *dim);
1013
1014 To iterate over all the basic sets or maps in a set or map, use
1015
1016         int isl_set_foreach_basic_set(__isl_keep isl_set *set,
1017                 int (*fn)(__isl_take isl_basic_set *bset, void *user),
1018                 void *user);
1019         int isl_map_foreach_basic_map(__isl_keep isl_map *map,
1020                 int (*fn)(__isl_take isl_basic_map *bmap, void *user),
1021                 void *user);
1022
1023 The callback function C<fn> should return 0 if successful and
1024 -1 if an error occurs.  In the latter case, or if any other error
1025 occurs, the above functions will return -1.
1026
1027 It should be noted that C<isl> does not guarantee that
1028 the basic sets or maps passed to C<fn> are disjoint.
1029 If this is required, then the user should call one of
1030 the following functions first.
1031
1032         __isl_give isl_set *isl_set_make_disjoint(
1033                 __isl_take isl_set *set);
1034         __isl_give isl_map *isl_map_make_disjoint(
1035                 __isl_take isl_map *map);
1036
1037 The number of basic sets in a set can be obtained
1038 from
1039
1040         int isl_set_n_basic_set(__isl_keep isl_set *set);
1041
1042 To iterate over the constraints of a basic set or map, use
1043
1044         #include <isl/constraint.h>
1045
1046         int isl_basic_map_foreach_constraint(
1047                 __isl_keep isl_basic_map *bmap,
1048                 int (*fn)(__isl_take isl_constraint *c, void *user),
1049                 void *user);
1050         void isl_constraint_free(struct isl_constraint *c);
1051
1052 Again, the callback function C<fn> should return 0 if successful and
1053 -1 if an error occurs.  In the latter case, or if any other error
1054 occurs, the above functions will return -1.
1055 The constraint C<c> represents either an equality or an inequality.
1056 Use the following function to find out whether a constraint
1057 represents an equality.  If not, it represents an inequality.
1058
1059         int isl_constraint_is_equality(
1060                 __isl_keep isl_constraint *constraint);
1061
1062 The coefficients of the constraints can be inspected using
1063 the following functions.
1064
1065         void isl_constraint_get_constant(
1066                 __isl_keep isl_constraint *constraint, isl_int *v);
1067         void isl_constraint_get_coefficient(
1068                 __isl_keep isl_constraint *constraint,
1069                 enum isl_dim_type type, int pos, isl_int *v);
1070
1071 The explicit representations of the existentially quantified
1072 variables can be inspected using the following functions.
1073 Note that the user is only allowed to use these functions
1074 if the inspected set or map is the result of a call
1075 to C<isl_set_compute_divs> or C<isl_map_compute_divs>.
1076
1077         __isl_give isl_div *isl_constraint_div(
1078                 __isl_keep isl_constraint *constraint, int pos);
1079         isl_ctx *isl_div_get_ctx(__isl_keep isl_div *div);
1080         void isl_div_get_constant(__isl_keep isl_div *div,
1081                 isl_int *v);
1082         void isl_div_get_denominator(__isl_keep isl_div *div,
1083                 isl_int *v);
1084         void isl_div_get_coefficient(__isl_keep isl_div *div,
1085                 enum isl_dim_type type, int pos, isl_int *v);
1086
1087 To obtain the constraints of a basic set or map in matrix
1088 form, use the following functions.
1089
1090         __isl_give isl_mat *isl_basic_set_equalities_matrix(
1091                 __isl_keep isl_basic_set *bset,
1092                 enum isl_dim_type c1, enum isl_dim_type c2,
1093                 enum isl_dim_type c3, enum isl_dim_type c4);
1094         __isl_give isl_mat *isl_basic_set_inequalities_matrix(
1095                 __isl_keep isl_basic_set *bset,
1096                 enum isl_dim_type c1, enum isl_dim_type c2,
1097                 enum isl_dim_type c3, enum isl_dim_type c4);
1098         __isl_give isl_mat *isl_basic_map_equalities_matrix(
1099                 __isl_keep isl_basic_map *bmap,
1100                 enum isl_dim_type c1,
1101                 enum isl_dim_type c2, enum isl_dim_type c3,
1102                 enum isl_dim_type c4, enum isl_dim_type c5);
1103         __isl_give isl_mat *isl_basic_map_inequalities_matrix(
1104                 __isl_keep isl_basic_map *bmap,
1105                 enum isl_dim_type c1,
1106                 enum isl_dim_type c2, enum isl_dim_type c3,
1107                 enum isl_dim_type c4, enum isl_dim_type c5);
1108
1109 The C<isl_dim_type> arguments dictate the order in which
1110 different kinds of variables appear in the resulting matrix
1111 and should be a permutation of C<isl_dim_cst>, C<isl_dim_param>,
1112 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div>.
1113
1114 The names of the domain and range spaces of a set or relation can be
1115 read off using the following functions.
1116
1117         const char *isl_basic_set_get_tuple_name(
1118                 __isl_keep isl_basic_set *bset);
1119         const char *isl_set_get_tuple_name(
1120                 __isl_keep isl_set *set);
1121         const char *isl_basic_map_get_tuple_name(
1122                 __isl_keep isl_basic_map *bmap,
1123                 enum isl_dim_type type);
1124         const char *isl_map_get_tuple_name(
1125                 __isl_keep isl_map *map,
1126                 enum isl_dim_type type);
1127
1128 As with C<isl_dim_get_tuple_name>, the value returned points to
1129 an internal data structure.
1130 The names of individual dimensions can be read off using
1131 the following functions.
1132
1133         const char *isl_constraint_get_dim_name(
1134                 __isl_keep isl_constraint *constraint,
1135                 enum isl_dim_type type, unsigned pos);
1136         const char *isl_basic_set_get_dim_name(
1137                 __isl_keep isl_basic_set *bset,
1138                 enum isl_dim_type type, unsigned pos);
1139         const char *isl_set_get_dim_name(
1140                 __isl_keep isl_set *set,
1141                 enum isl_dim_type type, unsigned pos);
1142         const char *isl_basic_map_get_dim_name(
1143                 __isl_keep isl_basic_map *bmap,
1144                 enum isl_dim_type type, unsigned pos);
1145         const char *isl_map_get_dim_name(
1146                 __isl_keep isl_map *map,
1147                 enum isl_dim_type type, unsigned pos);
1148
1149 These functions are mostly useful to obtain the names
1150 of the parameters.
1151
1152 =head2 Properties
1153
1154 =head3 Unary Properties
1155
1156 =over
1157
1158 =item * Emptiness
1159
1160 The following functions test whether the given set or relation
1161 contains any integer points.  The ``plain'' variants do not perform
1162 any computations, but simply check if the given set or relation
1163 is already known to be empty.
1164
1165         int isl_basic_set_plain_is_empty(__isl_keep isl_basic_set *bset);
1166         int isl_basic_set_is_empty(__isl_keep isl_basic_set *bset);
1167         int isl_set_plain_is_empty(__isl_keep isl_set *set);
1168         int isl_set_is_empty(__isl_keep isl_set *set);
1169         int isl_union_set_is_empty(__isl_keep isl_union_set *uset);
1170         int isl_basic_map_plain_is_empty(__isl_keep isl_basic_map *bmap);
1171         int isl_basic_map_is_empty(__isl_keep isl_basic_map *bmap);
1172         int isl_map_plain_is_empty(__isl_keep isl_map *map);
1173         int isl_map_is_empty(__isl_keep isl_map *map);
1174         int isl_union_map_is_empty(__isl_keep isl_union_map *umap);
1175
1176 =item * Universality
1177
1178         int isl_basic_set_is_universe(__isl_keep isl_basic_set *bset);
1179         int isl_basic_map_is_universe(__isl_keep isl_basic_map *bmap);
1180         int isl_set_plain_is_universe(__isl_keep isl_set *set);
1181
1182 =item * Single-valuedness
1183
1184         int isl_map_is_single_valued(__isl_keep isl_map *map);
1185         int isl_union_map_is_single_valued(__isl_keep isl_union_map *umap);
1186
1187 =item * Injectivity
1188
1189         int isl_map_plain_is_injective(__isl_keep isl_map *map);
1190         int isl_map_is_injective(__isl_keep isl_map *map);
1191         int isl_union_map_plain_is_injective(
1192                 __isl_keep isl_union_map *umap);
1193         int isl_union_map_is_injective(
1194                 __isl_keep isl_union_map *umap);
1195
1196 =item * Bijectivity
1197
1198         int isl_map_is_bijective(__isl_keep isl_map *map);
1199         int isl_union_map_is_bijective(__isl_keep isl_union_map *umap);
1200
1201 =item * Wrapping
1202
1203 The following functions check whether the domain of the given
1204 (basic) set is a wrapped relation.
1205
1206         int isl_basic_set_is_wrapping(
1207                 __isl_keep isl_basic_set *bset);
1208         int isl_set_is_wrapping(__isl_keep isl_set *set);
1209
1210 =item * Internal Product
1211
1212         int isl_basic_map_can_zip(
1213                 __isl_keep isl_basic_map *bmap);
1214         int isl_map_can_zip(__isl_keep isl_map *map);
1215
1216 Check whether the product of domain and range of the given relation
1217 can be computed,
1218 i.e., whether both domain and range are nested relations.
1219
1220 =back
1221
1222 =head3 Binary Properties
1223
1224 =over
1225
1226 =item * Equality
1227
1228         int isl_set_plain_is_equal(__isl_keep isl_set *set1,
1229                 __isl_keep isl_set *set2);
1230         int isl_set_is_equal(__isl_keep isl_set *set1,
1231                 __isl_keep isl_set *set2);
1232         int isl_union_set_is_equal(
1233                 __isl_keep isl_union_set *uset1,
1234                 __isl_keep isl_union_set *uset2);
1235         int isl_basic_map_is_equal(
1236                 __isl_keep isl_basic_map *bmap1,
1237                 __isl_keep isl_basic_map *bmap2);
1238         int isl_map_is_equal(__isl_keep isl_map *map1,
1239                 __isl_keep isl_map *map2);
1240         int isl_map_plain_is_equal(__isl_keep isl_map *map1,
1241                 __isl_keep isl_map *map2);
1242         int isl_union_map_is_equal(
1243                 __isl_keep isl_union_map *umap1,
1244                 __isl_keep isl_union_map *umap2);
1245
1246 =item * Disjointness
1247
1248         int isl_set_plain_is_disjoint(__isl_keep isl_set *set1,
1249                 __isl_keep isl_set *set2);
1250
1251 =item * Subset
1252
1253         int isl_set_is_subset(__isl_keep isl_set *set1,
1254                 __isl_keep isl_set *set2);
1255         int isl_set_is_strict_subset(
1256                 __isl_keep isl_set *set1,
1257                 __isl_keep isl_set *set2);
1258         int isl_union_set_is_subset(
1259                 __isl_keep isl_union_set *uset1,
1260                 __isl_keep isl_union_set *uset2);
1261         int isl_union_set_is_strict_subset(
1262                 __isl_keep isl_union_set *uset1,
1263                 __isl_keep isl_union_set *uset2);
1264         int isl_basic_map_is_subset(
1265                 __isl_keep isl_basic_map *bmap1,
1266                 __isl_keep isl_basic_map *bmap2);
1267         int isl_basic_map_is_strict_subset(
1268                 __isl_keep isl_basic_map *bmap1,
1269                 __isl_keep isl_basic_map *bmap2);
1270         int isl_map_is_subset(
1271                 __isl_keep isl_map *map1,
1272                 __isl_keep isl_map *map2);
1273         int isl_map_is_strict_subset(
1274                 __isl_keep isl_map *map1,
1275                 __isl_keep isl_map *map2);
1276         int isl_union_map_is_subset(
1277                 __isl_keep isl_union_map *umap1,
1278                 __isl_keep isl_union_map *umap2);
1279         int isl_union_map_is_strict_subset(
1280                 __isl_keep isl_union_map *umap1,
1281                 __isl_keep isl_union_map *umap2);
1282
1283 =back
1284
1285 =head2 Unary Operations
1286
1287 =over
1288
1289 =item * Complement
1290
1291         __isl_give isl_set *isl_set_complement(
1292                 __isl_take isl_set *set);
1293
1294 =item * Inverse map
1295
1296         __isl_give isl_basic_map *isl_basic_map_reverse(
1297                 __isl_take isl_basic_map *bmap);
1298         __isl_give isl_map *isl_map_reverse(
1299                 __isl_take isl_map *map);
1300         __isl_give isl_union_map *isl_union_map_reverse(
1301                 __isl_take isl_union_map *umap);
1302
1303 =item * Projection
1304
1305         __isl_give isl_basic_set *isl_basic_set_project_out(
1306                 __isl_take isl_basic_set *bset,
1307                 enum isl_dim_type type, unsigned first, unsigned n);
1308         __isl_give isl_basic_map *isl_basic_map_project_out(
1309                 __isl_take isl_basic_map *bmap,
1310                 enum isl_dim_type type, unsigned first, unsigned n);
1311         __isl_give isl_set *isl_set_project_out(__isl_take isl_set *set,
1312                 enum isl_dim_type type, unsigned first, unsigned n);
1313         __isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
1314                 enum isl_dim_type type, unsigned first, unsigned n);
1315         __isl_give isl_basic_set *isl_basic_map_domain(
1316                 __isl_take isl_basic_map *bmap);
1317         __isl_give isl_basic_set *isl_basic_map_range(
1318                 __isl_take isl_basic_map *bmap);
1319         __isl_give isl_set *isl_map_domain(
1320                 __isl_take isl_map *bmap);
1321         __isl_give isl_set *isl_map_range(
1322                 __isl_take isl_map *map);
1323         __isl_give isl_union_set *isl_union_map_domain(
1324                 __isl_take isl_union_map *umap);
1325         __isl_give isl_union_set *isl_union_map_range(
1326                 __isl_take isl_union_map *umap);
1327
1328         __isl_give isl_basic_map *isl_basic_map_domain_map(
1329                 __isl_take isl_basic_map *bmap);
1330         __isl_give isl_basic_map *isl_basic_map_range_map(
1331                 __isl_take isl_basic_map *bmap);
1332         __isl_give isl_map *isl_map_domain_map(__isl_take isl_map *map);
1333         __isl_give isl_map *isl_map_range_map(__isl_take isl_map *map);
1334         __isl_give isl_union_map *isl_union_map_domain_map(
1335                 __isl_take isl_union_map *umap);
1336         __isl_give isl_union_map *isl_union_map_range_map(
1337                 __isl_take isl_union_map *umap);
1338
1339 The functions above construct a (basic, regular or union) relation
1340 that maps (a wrapped version of) the input relation to its domain or range.
1341
1342 =item * Elimination
1343
1344         __isl_give isl_set *isl_set_eliminate(
1345                 __isl_take isl_set *set, enum isl_dim_type type,
1346                 unsigned first, unsigned n);
1347
1348 Eliminate the coefficients for the given dimensions from the constraints,
1349 without removing the dimensions.
1350
1351 =item * Identity
1352
1353         __isl_give isl_map *isl_set_identity(
1354                 __isl_take isl_set *set);
1355         __isl_give isl_union_map *isl_union_set_identity(
1356                 __isl_take isl_union_set *uset);
1357
1358 Construct an identity relation on the given (union) set.
1359
1360 =item * Deltas
1361
1362         __isl_give isl_basic_set *isl_basic_map_deltas(
1363                 __isl_take isl_basic_map *bmap);
1364         __isl_give isl_set *isl_map_deltas(__isl_take isl_map *map);
1365         __isl_give isl_union_set *isl_union_map_deltas(
1366                 __isl_take isl_union_map *umap);
1367
1368 These functions return a (basic) set containing the differences
1369 between image elements and corresponding domain elements in the input.
1370
1371         __isl_give isl_basic_map *isl_basic_map_deltas_map(
1372                 __isl_take isl_basic_map *bmap);
1373         __isl_give isl_map *isl_map_deltas_map(
1374                 __isl_take isl_map *map);
1375         __isl_give isl_union_map *isl_union_map_deltas_map(
1376                 __isl_take isl_union_map *umap);
1377
1378 The functions above construct a (basic, regular or union) relation
1379 that maps (a wrapped version of) the input relation to its delta set.
1380
1381 =item * Coalescing
1382
1383 Simplify the representation of a set or relation by trying
1384 to combine pairs of basic sets or relations into a single
1385 basic set or relation.
1386
1387         __isl_give isl_set *isl_set_coalesce(__isl_take isl_set *set);
1388         __isl_give isl_map *isl_map_coalesce(__isl_take isl_map *map);
1389         __isl_give isl_union_set *isl_union_set_coalesce(
1390                 __isl_take isl_union_set *uset);
1391         __isl_give isl_union_map *isl_union_map_coalesce(
1392                 __isl_take isl_union_map *umap);
1393
1394 =item * Detecting equalities
1395
1396         __isl_give isl_basic_set *isl_basic_set_detect_equalities(
1397                 __isl_take isl_basic_set *bset);
1398         __isl_give isl_basic_map *isl_basic_map_detect_equalities(
1399                 __isl_take isl_basic_map *bmap);
1400         __isl_give isl_set *isl_set_detect_equalities(
1401                 __isl_take isl_set *set);
1402         __isl_give isl_map *isl_map_detect_equalities(
1403                 __isl_take isl_map *map);
1404         __isl_give isl_union_set *isl_union_set_detect_equalities(
1405                 __isl_take isl_union_set *uset);
1406         __isl_give isl_union_map *isl_union_map_detect_equalities(
1407                 __isl_take isl_union_map *umap);
1408
1409 Simplify the representation of a set or relation by detecting implicit
1410 equalities.
1411
1412 =item * Removing redundant constraints
1413
1414         __isl_give isl_basic_set *isl_basic_set_remove_redundancies(
1415                 __isl_take isl_basic_set *bset);
1416         __isl_give isl_basic_map *isl_basic_map_remove_redundancies(
1417                 __isl_take isl_basic_map *bmap);
1418
1419 =item * Convex hull
1420
1421         __isl_give isl_basic_set *isl_set_convex_hull(
1422                 __isl_take isl_set *set);
1423         __isl_give isl_basic_map *isl_map_convex_hull(
1424                 __isl_take isl_map *map);
1425
1426 If the input set or relation has any existentially quantified
1427 variables, then the result of these operations is currently undefined.
1428
1429 =item * Simple hull
1430
1431         __isl_give isl_basic_set *isl_set_simple_hull(
1432                 __isl_take isl_set *set);
1433         __isl_give isl_basic_map *isl_map_simple_hull(
1434                 __isl_take isl_map *map);
1435         __isl_give isl_union_map *isl_union_map_simple_hull(
1436                 __isl_take isl_union_map *umap);
1437
1438 These functions compute a single basic set or relation
1439 that contains the whole input set or relation.
1440 In particular, the output is described by translates
1441 of the constraints describing the basic sets or relations in the input.
1442
1443 =begin latex
1444
1445 (See \autoref{s:simple hull}.)
1446
1447 =end latex
1448
1449 =item * Affine hull
1450
1451         __isl_give isl_basic_set *isl_basic_set_affine_hull(
1452                 __isl_take isl_basic_set *bset);
1453         __isl_give isl_basic_set *isl_set_affine_hull(
1454                 __isl_take isl_set *set);
1455         __isl_give isl_union_set *isl_union_set_affine_hull(
1456                 __isl_take isl_union_set *uset);
1457         __isl_give isl_basic_map *isl_basic_map_affine_hull(
1458                 __isl_take isl_basic_map *bmap);
1459         __isl_give isl_basic_map *isl_map_affine_hull(
1460                 __isl_take isl_map *map);
1461         __isl_give isl_union_map *isl_union_map_affine_hull(
1462                 __isl_take isl_union_map *umap);
1463
1464 In case of union sets and relations, the affine hull is computed
1465 per space.
1466
1467 =item * Polyhedral hull
1468
1469         __isl_give isl_basic_set *isl_set_polyhedral_hull(
1470                 __isl_take isl_set *set);
1471         __isl_give isl_basic_map *isl_map_polyhedral_hull(
1472                 __isl_take isl_map *map);
1473         __isl_give isl_union_set *isl_union_set_polyhedral_hull(
1474                 __isl_take isl_union_set *uset);
1475         __isl_give isl_union_map *isl_union_map_polyhedral_hull(
1476                 __isl_take isl_union_map *umap);
1477
1478 These functions compute a single basic set or relation
1479 not involving any existentially quantified variables
1480 that contains the whole input set or relation.
1481 In case of union sets and relations, the polyhedral hull is computed
1482 per space.
1483
1484 =item * Dual
1485
1486 The following functions compute either the set of (rational) coefficient
1487 values of valid constraints for the given set or the set of (rational)
1488 values satisfying the constraints with coefficients from the given set.
1489 Internally, these two sets of functions perform essentially the
1490 same operations, except that the set of coefficients is assumed to
1491 be a cone, while the set of values may be any polyhedron.
1492 The current implementation is based on the Farkas lemma and
1493 Fourier-Motzkin elimination, but this may change or be made optional
1494 in future.  In particular, future implementations may use different
1495 dualization algorithms or skip the elimination step.
1496
1497         __isl_give isl_basic_set *isl_basic_set_coefficients(
1498                 __isl_take isl_basic_set *bset);
1499         __isl_give isl_basic_set *isl_set_coefficients(
1500                 __isl_take isl_set *set);
1501         __isl_give isl_union_set *isl_union_set_coefficients(
1502                 __isl_take isl_union_set *bset);
1503         __isl_give isl_basic_set *isl_basic_set_solutions(
1504                 __isl_take isl_basic_set *bset);
1505         __isl_give isl_basic_set *isl_set_solutions(
1506                 __isl_take isl_set *set);
1507         __isl_give isl_union_set *isl_union_set_solutions(
1508                 __isl_take isl_union_set *bset);
1509
1510 =item * Power
1511
1512         __isl_give isl_map *isl_map_power(__isl_take isl_map *map,
1513                 int *exact);
1514         __isl_give isl_union_map *isl_union_map_power(
1515                 __isl_take isl_union_map *umap, int *exact);
1516
1517 Compute a parametric representation for all positive powers I<k> of C<map>.
1518 The result maps I<k> to a nested relation corresponding to the
1519 I<k>th power of C<map>.
1520 The result may be an overapproximation.  If the result is known to be exact,
1521 then C<*exact> is set to C<1>.
1522
1523 =item * Transitive closure
1524
1525         __isl_give isl_map *isl_map_transitive_closure(
1526                 __isl_take isl_map *map, int *exact);
1527         __isl_give isl_union_map *isl_union_map_transitive_closure(
1528                 __isl_take isl_union_map *umap, int *exact);
1529
1530 Compute the transitive closure of C<map>.
1531 The result may be an overapproximation.  If the result is known to be exact,
1532 then C<*exact> is set to C<1>.
1533
1534 =item * Reaching path lengths
1535
1536         __isl_give isl_map *isl_map_reaching_path_lengths(
1537                 __isl_take isl_map *map, int *exact);
1538
1539 Compute a relation that maps each element in the range of C<map>
1540 to the lengths of all paths composed of edges in C<map> that
1541 end up in the given element.
1542 The result may be an overapproximation.  If the result is known to be exact,
1543 then C<*exact> is set to C<1>.
1544 To compute the I<maximal> path length, the resulting relation
1545 should be postprocessed by C<isl_map_lexmax>.
1546 In particular, if the input relation is a dependence relation
1547 (mapping sources to sinks), then the maximal path length corresponds
1548 to the free schedule.
1549 Note, however, that C<isl_map_lexmax> expects the maximum to be
1550 finite, so if the path lengths are unbounded (possibly due to
1551 the overapproximation), then you will get an error message.
1552
1553 =item * Wrapping
1554
1555         __isl_give isl_basic_set *isl_basic_map_wrap(
1556                 __isl_take isl_basic_map *bmap);
1557         __isl_give isl_set *isl_map_wrap(
1558                 __isl_take isl_map *map);
1559         __isl_give isl_union_set *isl_union_map_wrap(
1560                 __isl_take isl_union_map *umap);
1561         __isl_give isl_basic_map *isl_basic_set_unwrap(
1562                 __isl_take isl_basic_set *bset);
1563         __isl_give isl_map *isl_set_unwrap(
1564                 __isl_take isl_set *set);
1565         __isl_give isl_union_map *isl_union_set_unwrap(
1566                 __isl_take isl_union_set *uset);
1567
1568 =item * Flattening
1569
1570 Remove any internal structure of domain (and range) of the given
1571 set or relation.  If there is any such internal structure in the input,
1572 then the name of the space is also removed.
1573
1574         __isl_give isl_basic_set *isl_basic_set_flatten(
1575                 __isl_take isl_basic_set *bset);
1576         __isl_give isl_set *isl_set_flatten(
1577                 __isl_take isl_set *set);
1578         __isl_give isl_basic_map *isl_basic_map_flatten(
1579                 __isl_take isl_basic_map *bmap);
1580         __isl_give isl_map *isl_map_flatten(
1581                 __isl_take isl_map *map);
1582
1583         __isl_give isl_map *isl_set_flatten_map(
1584                 __isl_take isl_set *set);
1585
1586 The function above constructs a relation
1587 that maps the input set to a flattened version of the set.
1588
1589 =item * Lifting
1590
1591 Lift the input set to a space with extra dimensions corresponding
1592 to the existentially quantified variables in the input.
1593 In particular, the result lives in a wrapped map where the domain
1594 is the original space and the range corresponds to the original
1595 existentially quantified variables.
1596
1597         __isl_give isl_basic_set *isl_basic_set_lift(
1598                 __isl_take isl_basic_set *bset);
1599         __isl_give isl_set *isl_set_lift(
1600                 __isl_take isl_set *set);
1601         __isl_give isl_union_set *isl_union_set_lift(
1602                 __isl_take isl_union_set *uset);
1603
1604 =item * Internal Product
1605
1606         __isl_give isl_basic_map *isl_basic_map_zip(
1607                 __isl_take isl_basic_map *bmap);
1608         __isl_give isl_map *isl_map_zip(
1609                 __isl_take isl_map *map);
1610         __isl_give isl_union_map *isl_union_map_zip(
1611                 __isl_take isl_union_map *umap);
1612
1613 Given a relation with nested relations for domain and range,
1614 interchange the range of the domain with the domain of the range.
1615
1616 =item * Aligning parameters
1617
1618         __isl_give isl_set *isl_set_align_params(
1619                 __isl_take isl_set *set,
1620                 __isl_take isl_dim *model);
1621         __isl_give isl_map *isl_map_align_params(
1622                 __isl_take isl_map *map,
1623                 __isl_take isl_dim *model);
1624
1625 Change the order of the parameters of the given set or relation
1626 such that the first parameters match those of C<model>.
1627 This may involve the introduction of extra parameters.
1628 All parameters need to be named.
1629
1630 =item * Dimension manipulation
1631
1632         __isl_give isl_set *isl_set_add_dims(
1633                 __isl_take isl_set *set,
1634                 enum isl_dim_type type, unsigned n);
1635         __isl_give isl_map *isl_map_add_dims(
1636                 __isl_take isl_map *map,
1637                 enum isl_dim_type type, unsigned n);
1638
1639 It is usually not advisable to directly change the (input or output)
1640 space of a set or a relation as this removes the name and the internal
1641 structure of the space.  However, the above functions can be useful
1642 to add new parameters, assuming
1643 C<isl_set_align_params> and C<isl_map_align_params>
1644 are not sufficient.
1645
1646 =back
1647
1648 =head2 Binary Operations
1649
1650 The two arguments of a binary operation not only need to live
1651 in the same C<isl_ctx>, they currently also need to have
1652 the same (number of) parameters.
1653
1654 =head3 Basic Operations
1655
1656 =over
1657
1658 =item * Intersection
1659
1660         __isl_give isl_basic_set *isl_basic_set_intersect(
1661                 __isl_take isl_basic_set *bset1,
1662                 __isl_take isl_basic_set *bset2);
1663         __isl_give isl_set *isl_set_intersect(
1664                 __isl_take isl_set *set1,
1665                 __isl_take isl_set *set2);
1666         __isl_give isl_union_set *isl_union_set_intersect(
1667                 __isl_take isl_union_set *uset1,
1668                 __isl_take isl_union_set *uset2);
1669         __isl_give isl_basic_map *isl_basic_map_intersect_domain(
1670                 __isl_take isl_basic_map *bmap,
1671                 __isl_take isl_basic_set *bset);
1672         __isl_give isl_basic_map *isl_basic_map_intersect_range(
1673                 __isl_take isl_basic_map *bmap,
1674                 __isl_take isl_basic_set *bset);
1675         __isl_give isl_basic_map *isl_basic_map_intersect(
1676                 __isl_take isl_basic_map *bmap1,
1677                 __isl_take isl_basic_map *bmap2);
1678         __isl_give isl_map *isl_map_intersect_domain(
1679                 __isl_take isl_map *map,
1680                 __isl_take isl_set *set);
1681         __isl_give isl_map *isl_map_intersect_range(
1682                 __isl_take isl_map *map,
1683                 __isl_take isl_set *set);
1684         __isl_give isl_map *isl_map_intersect(
1685                 __isl_take isl_map *map1,
1686                 __isl_take isl_map *map2);
1687         __isl_give isl_union_map *isl_union_map_intersect_domain(
1688                 __isl_take isl_union_map *umap,
1689                 __isl_take isl_union_set *uset);
1690         __isl_give isl_union_map *isl_union_map_intersect_range(
1691                 __isl_take isl_union_map *umap,
1692                 __isl_take isl_union_set *uset);
1693         __isl_give isl_union_map *isl_union_map_intersect(
1694                 __isl_take isl_union_map *umap1,
1695                 __isl_take isl_union_map *umap2);
1696
1697 =item * Union
1698
1699         __isl_give isl_set *isl_basic_set_union(
1700                 __isl_take isl_basic_set *bset1,
1701                 __isl_take isl_basic_set *bset2);
1702         __isl_give isl_map *isl_basic_map_union(
1703                 __isl_take isl_basic_map *bmap1,
1704                 __isl_take isl_basic_map *bmap2);
1705         __isl_give isl_set *isl_set_union(
1706                 __isl_take isl_set *set1,
1707                 __isl_take isl_set *set2);
1708         __isl_give isl_map *isl_map_union(
1709                 __isl_take isl_map *map1,
1710                 __isl_take isl_map *map2);
1711         __isl_give isl_union_set *isl_union_set_union(
1712                 __isl_take isl_union_set *uset1,
1713                 __isl_take isl_union_set *uset2);
1714         __isl_give isl_union_map *isl_union_map_union(
1715                 __isl_take isl_union_map *umap1,
1716                 __isl_take isl_union_map *umap2);
1717
1718 =item * Set difference
1719
1720         __isl_give isl_set *isl_set_subtract(
1721                 __isl_take isl_set *set1,
1722                 __isl_take isl_set *set2);
1723         __isl_give isl_map *isl_map_subtract(
1724                 __isl_take isl_map *map1,
1725                 __isl_take isl_map *map2);
1726         __isl_give isl_union_set *isl_union_set_subtract(
1727                 __isl_take isl_union_set *uset1,
1728                 __isl_take isl_union_set *uset2);
1729         __isl_give isl_union_map *isl_union_map_subtract(
1730                 __isl_take isl_union_map *umap1,
1731                 __isl_take isl_union_map *umap2);
1732
1733 =item * Application
1734
1735         __isl_give isl_basic_set *isl_basic_set_apply(
1736                 __isl_take isl_basic_set *bset,
1737                 __isl_take isl_basic_map *bmap);
1738         __isl_give isl_set *isl_set_apply(
1739                 __isl_take isl_set *set,
1740                 __isl_take isl_map *map);
1741         __isl_give isl_union_set *isl_union_set_apply(
1742                 __isl_take isl_union_set *uset,
1743                 __isl_take isl_union_map *umap);
1744         __isl_give isl_basic_map *isl_basic_map_apply_domain(
1745                 __isl_take isl_basic_map *bmap1,
1746                 __isl_take isl_basic_map *bmap2);
1747         __isl_give isl_basic_map *isl_basic_map_apply_range(
1748                 __isl_take isl_basic_map *bmap1,
1749                 __isl_take isl_basic_map *bmap2);
1750         __isl_give isl_map *isl_map_apply_domain(
1751                 __isl_take isl_map *map1,
1752                 __isl_take isl_map *map2);
1753         __isl_give isl_union_map *isl_union_map_apply_domain(
1754                 __isl_take isl_union_map *umap1,
1755                 __isl_take isl_union_map *umap2);
1756         __isl_give isl_map *isl_map_apply_range(
1757                 __isl_take isl_map *map1,
1758                 __isl_take isl_map *map2);
1759         __isl_give isl_union_map *isl_union_map_apply_range(
1760                 __isl_take isl_union_map *umap1,
1761                 __isl_take isl_union_map *umap2);
1762
1763 =item * Cartesian Product
1764
1765         __isl_give isl_set *isl_set_product(
1766                 __isl_take isl_set *set1,
1767                 __isl_take isl_set *set2);
1768         __isl_give isl_union_set *isl_union_set_product(
1769                 __isl_take isl_union_set *uset1,
1770                 __isl_take isl_union_set *uset2);
1771         __isl_give isl_basic_map *isl_basic_map_range_product(
1772                 __isl_take isl_basic_map *bmap1,
1773                 __isl_take isl_basic_map *bmap2);
1774         __isl_give isl_map *isl_map_range_product(
1775                 __isl_take isl_map *map1,
1776                 __isl_take isl_map *map2);
1777         __isl_give isl_union_map *isl_union_map_range_product(
1778                 __isl_take isl_union_map *umap1,
1779                 __isl_take isl_union_map *umap2);
1780         __isl_give isl_map *isl_map_product(
1781                 __isl_take isl_map *map1,
1782                 __isl_take isl_map *map2);
1783         __isl_give isl_union_map *isl_union_map_product(
1784                 __isl_take isl_union_map *umap1,
1785                 __isl_take isl_union_map *umap2);
1786
1787 The above functions compute the cross product of the given
1788 sets or relations.  The domains and ranges of the results
1789 are wrapped maps between domains and ranges of the inputs.
1790 To obtain a ``flat'' product, use the following functions
1791 instead.
1792
1793         __isl_give isl_basic_set *isl_basic_set_flat_product(
1794                 __isl_take isl_basic_set *bset1,
1795                 __isl_take isl_basic_set *bset2);
1796         __isl_give isl_set *isl_set_flat_product(
1797                 __isl_take isl_set *set1,
1798                 __isl_take isl_set *set2);
1799         __isl_give isl_basic_map *isl_basic_map_flat_product(
1800                 __isl_take isl_basic_map *bmap1,
1801                 __isl_take isl_basic_map *bmap2);
1802         __isl_give isl_map *isl_map_flat_product(
1803                 __isl_take isl_map *map1,
1804                 __isl_take isl_map *map2);
1805
1806 =item * Simplification
1807
1808         __isl_give isl_basic_set *isl_basic_set_gist(
1809                 __isl_take isl_basic_set *bset,
1810                 __isl_take isl_basic_set *context);
1811         __isl_give isl_set *isl_set_gist(__isl_take isl_set *set,
1812                 __isl_take isl_set *context);
1813         __isl_give isl_union_set *isl_union_set_gist(
1814                 __isl_take isl_union_set *uset,
1815                 __isl_take isl_union_set *context);
1816         __isl_give isl_basic_map *isl_basic_map_gist(
1817                 __isl_take isl_basic_map *bmap,
1818                 __isl_take isl_basic_map *context);
1819         __isl_give isl_map *isl_map_gist(__isl_take isl_map *map,
1820                 __isl_take isl_map *context);
1821         __isl_give isl_union_map *isl_union_map_gist(
1822                 __isl_take isl_union_map *umap,
1823                 __isl_take isl_union_map *context);
1824
1825 The gist operation returns a set or relation that has the
1826 same intersection with the context as the input set or relation.
1827 Any implicit equality in the intersection is made explicit in the result,
1828 while all inequalities that are redundant with respect to the intersection
1829 are removed.
1830 In case of union sets and relations, the gist operation is performed
1831 per space.
1832
1833 =back
1834
1835 =head3 Lexicographic Optimization
1836
1837 Given a (basic) set C<set> (or C<bset>) and a zero-dimensional domain C<dom>,
1838 the following functions
1839 compute a set that contains the lexicographic minimum or maximum
1840 of the elements in C<set> (or C<bset>) for those values of the parameters
1841 that satisfy C<dom>.
1842 If C<empty> is not C<NULL>, then C<*empty> is assigned a set
1843 that contains the parameter values in C<dom> for which C<set> (or C<bset>)
1844 has no elements.
1845 In other words, the union of the parameter values
1846 for which the result is non-empty and of C<*empty>
1847 is equal to C<dom>.
1848
1849         __isl_give isl_set *isl_basic_set_partial_lexmin(
1850                 __isl_take isl_basic_set *bset,
1851                 __isl_take isl_basic_set *dom,
1852                 __isl_give isl_set **empty);
1853         __isl_give isl_set *isl_basic_set_partial_lexmax(
1854                 __isl_take isl_basic_set *bset,
1855                 __isl_take isl_basic_set *dom,
1856                 __isl_give isl_set **empty);
1857         __isl_give isl_set *isl_set_partial_lexmin(
1858                 __isl_take isl_set *set, __isl_take isl_set *dom,
1859                 __isl_give isl_set **empty);
1860         __isl_give isl_set *isl_set_partial_lexmax(
1861                 __isl_take isl_set *set, __isl_take isl_set *dom,
1862                 __isl_give isl_set **empty);
1863
1864 Given a (basic) set C<set> (or C<bset>), the following functions simply
1865 return a set containing the lexicographic minimum or maximum
1866 of the elements in C<set> (or C<bset>).
1867 In case of union sets, the optimum is computed per space.
1868
1869         __isl_give isl_set *isl_basic_set_lexmin(
1870                 __isl_take isl_basic_set *bset);
1871         __isl_give isl_set *isl_basic_set_lexmax(
1872                 __isl_take isl_basic_set *bset);
1873         __isl_give isl_set *isl_set_lexmin(
1874                 __isl_take isl_set *set);
1875         __isl_give isl_set *isl_set_lexmax(
1876                 __isl_take isl_set *set);
1877         __isl_give isl_union_set *isl_union_set_lexmin(
1878                 __isl_take isl_union_set *uset);
1879         __isl_give isl_union_set *isl_union_set_lexmax(
1880                 __isl_take isl_union_set *uset);
1881
1882 Given a (basic) relation C<map> (or C<bmap>) and a domain C<dom>,
1883 the following functions
1884 compute a relation that maps each element of C<dom>
1885 to the single lexicographic minimum or maximum
1886 of the elements that are associated to that same
1887 element in C<map> (or C<bmap>).
1888 If C<empty> is not C<NULL>, then C<*empty> is assigned a set
1889 that contains the elements in C<dom> that do not map
1890 to any elements in C<map> (or C<bmap>).
1891 In other words, the union of the domain of the result and of C<*empty>
1892 is equal to C<dom>.
1893
1894         __isl_give isl_map *isl_basic_map_partial_lexmax(
1895                 __isl_take isl_basic_map *bmap,
1896                 __isl_take isl_basic_set *dom,
1897                 __isl_give isl_set **empty);
1898         __isl_give isl_map *isl_basic_map_partial_lexmin(
1899                 __isl_take isl_basic_map *bmap,
1900                 __isl_take isl_basic_set *dom,
1901                 __isl_give isl_set **empty);
1902         __isl_give isl_map *isl_map_partial_lexmax(
1903                 __isl_take isl_map *map, __isl_take isl_set *dom,
1904                 __isl_give isl_set **empty);
1905         __isl_give isl_map *isl_map_partial_lexmin(
1906                 __isl_take isl_map *map, __isl_take isl_set *dom,
1907                 __isl_give isl_set **empty);
1908
1909 Given a (basic) map C<map> (or C<bmap>), the following functions simply
1910 return a map mapping each element in the domain of
1911 C<map> (or C<bmap>) to the lexicographic minimum or maximum
1912 of all elements associated to that element.
1913 In case of union relations, the optimum is computed per space.
1914
1915         __isl_give isl_map *isl_basic_map_lexmin(
1916                 __isl_take isl_basic_map *bmap);
1917         __isl_give isl_map *isl_basic_map_lexmax(
1918                 __isl_take isl_basic_map *bmap);
1919         __isl_give isl_map *isl_map_lexmin(
1920                 __isl_take isl_map *map);
1921         __isl_give isl_map *isl_map_lexmax(
1922                 __isl_take isl_map *map);
1923         __isl_give isl_union_map *isl_union_map_lexmin(
1924                 __isl_take isl_union_map *umap);
1925         __isl_give isl_union_map *isl_union_map_lexmax(
1926                 __isl_take isl_union_map *umap);
1927
1928 =head2 Matrices
1929
1930 Matrices can be created, copied and freed using the following functions.
1931
1932         #include <isl/mat.h>
1933         __isl_give isl_mat *isl_mat_alloc(struct isl_ctx *ctx,
1934                 unsigned n_row, unsigned n_col);
1935         __isl_give isl_mat *isl_mat_copy(__isl_keep isl_mat *mat);
1936         void isl_mat_free(__isl_take isl_mat *mat);
1937
1938 Note that the elements of a newly created matrix may have arbitrary values.
1939 The elements can be changed and inspected using the following functions.
1940
1941         isl_ctx *isl_mat_get_ctx(__isl_keep isl_mat *mat);
1942         int isl_mat_rows(__isl_keep isl_mat *mat);
1943         int isl_mat_cols(__isl_keep isl_mat *mat);
1944         int isl_mat_get_element(__isl_keep isl_mat *mat,
1945                 int row, int col, isl_int *v);
1946         __isl_give isl_mat *isl_mat_set_element(__isl_take isl_mat *mat,
1947                 int row, int col, isl_int v);
1948         __isl_give isl_mat *isl_mat_set_element_si(__isl_take isl_mat *mat,
1949                 int row, int col, int v);
1950
1951 C<isl_mat_get_element> will return a negative value if anything went wrong.
1952 In that case, the value of C<*v> is undefined.
1953
1954 The following function can be used to compute the (right) inverse
1955 of a matrix, i.e., a matrix such that the product of the original
1956 and the inverse (in that order) is a multiple of the identity matrix.
1957 The input matrix is assumed to be of full row-rank.
1958
1959         __isl_give isl_mat *isl_mat_right_inverse(__isl_take isl_mat *mat);
1960
1961 The following function can be used to compute the (right) kernel
1962 (or null space) of a matrix, i.e., a matrix such that the product of
1963 the original and the kernel (in that order) is the zero matrix.
1964
1965         __isl_give isl_mat *isl_mat_right_kernel(__isl_take isl_mat *mat);
1966
1967 =head2 Points
1968
1969 Points are elements of a set.  They can be used to construct
1970 simple sets (boxes) or they can be used to represent the
1971 individual elements of a set.
1972 The zero point (the origin) can be created using
1973
1974         __isl_give isl_point *isl_point_zero(__isl_take isl_dim *dim);
1975
1976 The coordinates of a point can be inspected, set and changed
1977 using
1978
1979         void isl_point_get_coordinate(__isl_keep isl_point *pnt,
1980                 enum isl_dim_type type, int pos, isl_int *v);
1981         __isl_give isl_point *isl_point_set_coordinate(
1982                 __isl_take isl_point *pnt,
1983                 enum isl_dim_type type, int pos, isl_int v);
1984
1985         __isl_give isl_point *isl_point_add_ui(
1986                 __isl_take isl_point *pnt,
1987                 enum isl_dim_type type, int pos, unsigned val);
1988         __isl_give isl_point *isl_point_sub_ui(
1989                 __isl_take isl_point *pnt,
1990                 enum isl_dim_type type, int pos, unsigned val);
1991
1992 Points can be copied or freed using
1993
1994         __isl_give isl_point *isl_point_copy(
1995                 __isl_keep isl_point *pnt);
1996         void isl_point_free(__isl_take isl_point *pnt);
1997
1998 A singleton set can be created from a point using
1999
2000         __isl_give isl_basic_set *isl_basic_set_from_point(
2001                 __isl_take isl_point *pnt);
2002         __isl_give isl_set *isl_set_from_point(
2003                 __isl_take isl_point *pnt);
2004
2005 and a box can be created from two opposite extremal points using
2006
2007         __isl_give isl_basic_set *isl_basic_set_box_from_points(
2008                 __isl_take isl_point *pnt1,
2009                 __isl_take isl_point *pnt2);
2010         __isl_give isl_set *isl_set_box_from_points(
2011                 __isl_take isl_point *pnt1,
2012                 __isl_take isl_point *pnt2);
2013
2014 All elements of a B<bounded> (union) set can be enumerated using
2015 the following functions.
2016
2017         int isl_set_foreach_point(__isl_keep isl_set *set,
2018                 int (*fn)(__isl_take isl_point *pnt, void *user),
2019                 void *user);
2020         int isl_union_set_foreach_point(__isl_keep isl_union_set *uset,
2021                 int (*fn)(__isl_take isl_point *pnt, void *user),
2022                 void *user);
2023
2024 The function C<fn> is called for each integer point in
2025 C<set> with as second argument the last argument of
2026 the C<isl_set_foreach_point> call.  The function C<fn>
2027 should return C<0> on success and C<-1> on failure.
2028 In the latter case, C<isl_set_foreach_point> will stop
2029 enumerating and return C<-1> as well.
2030 If the enumeration is performed successfully and to completion,
2031 then C<isl_set_foreach_point> returns C<0>.
2032
2033 To obtain a single point of a (basic) set, use
2034
2035         __isl_give isl_point *isl_basic_set_sample_point(
2036                 __isl_take isl_basic_set *bset);
2037         __isl_give isl_point *isl_set_sample_point(
2038                 __isl_take isl_set *set);
2039
2040 If C<set> does not contain any (integer) points, then the
2041 resulting point will be ``void'', a property that can be
2042 tested using
2043
2044         int isl_point_is_void(__isl_keep isl_point *pnt);
2045
2046 =head2 Piecewise Quasipolynomials
2047
2048 A piecewise quasipolynomial is a particular kind of function that maps
2049 a parametric point to a rational value.
2050 More specifically, a quasipolynomial is a polynomial expression in greatest
2051 integer parts of affine expressions of parameters and variables.
2052 A piecewise quasipolynomial is a subdivision of a given parametric
2053 domain into disjoint cells with a quasipolynomial associated to
2054 each cell.  The value of the piecewise quasipolynomial at a given
2055 point is the value of the quasipolynomial associated to the cell
2056 that contains the point.  Outside of the union of cells,
2057 the value is assumed to be zero.
2058 For example, the piecewise quasipolynomial
2059
2060         [n] -> { [x] -> ((1 + n) - x) : x <= n and x >= 0 }
2061
2062 maps C<x> to C<1 + n - x> for values of C<x> between C<0> and C<n>.
2063 A given piecewise quasipolynomial has a fixed domain dimension.
2064 Union piecewise quasipolynomials are used to contain piecewise quasipolynomials
2065 defined over different domains.
2066 Piecewise quasipolynomials are mainly used by the C<barvinok>
2067 library for representing the number of elements in a parametric set or map.
2068 For example, the piecewise quasipolynomial above represents
2069 the number of points in the map
2070
2071         [n] -> { [x] -> [y] : x,y >= 0 and 0 <= x + y <= n }
2072
2073 =head3 Printing (Piecewise) Quasipolynomials
2074
2075 Quasipolynomials and piecewise quasipolynomials can be printed
2076 using the following functions.
2077
2078         __isl_give isl_printer *isl_printer_print_qpolynomial(
2079                 __isl_take isl_printer *p,
2080                 __isl_keep isl_qpolynomial *qp);
2081
2082         __isl_give isl_printer *isl_printer_print_pw_qpolynomial(
2083                 __isl_take isl_printer *p,
2084                 __isl_keep isl_pw_qpolynomial *pwqp);
2085
2086         __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial(
2087                 __isl_take isl_printer *p,
2088                 __isl_keep isl_union_pw_qpolynomial *upwqp);
2089
2090 The output format of the printer
2091 needs to be set to either C<ISL_FORMAT_ISL> or C<ISL_FORMAT_C>.
2092 For C<isl_printer_print_union_pw_qpolynomial>, only C<ISL_FORMAT_ISL>
2093 is supported.
2094 In case of printing in C<ISL_FORMAT_C>, the user may want
2095 to set the names of all dimensions
2096
2097         __isl_give isl_qpolynomial *isl_qpolynomial_set_dim_name(
2098                 __isl_take isl_qpolynomial *qp,
2099                 enum isl_dim_type type, unsigned pos,
2100                 const char *s);
2101         __isl_give isl_pw_qpolynomial *
2102         isl_pw_qpolynomial_set_dim_name(
2103                 __isl_take isl_pw_qpolynomial *pwqp,
2104                 enum isl_dim_type type, unsigned pos,
2105                 const char *s);
2106
2107 =head3 Creating New (Piecewise) Quasipolynomials
2108
2109 Some simple quasipolynomials can be created using the following functions.
2110 More complicated quasipolynomials can be created by applying
2111 operations such as addition and multiplication
2112 on the resulting quasipolynomials
2113
2114         __isl_give isl_qpolynomial *isl_qpolynomial_zero(
2115                 __isl_take isl_dim *dim);
2116         __isl_give isl_qpolynomial *isl_qpolynomial_one(
2117                 __isl_take isl_dim *dim);
2118         __isl_give isl_qpolynomial *isl_qpolynomial_infty(
2119                 __isl_take isl_dim *dim);
2120         __isl_give isl_qpolynomial *isl_qpolynomial_neginfty(
2121                 __isl_take isl_dim *dim);
2122         __isl_give isl_qpolynomial *isl_qpolynomial_nan(
2123                 __isl_take isl_dim *dim);
2124         __isl_give isl_qpolynomial *isl_qpolynomial_rat_cst(
2125                 __isl_take isl_dim *dim,
2126                 const isl_int n, const isl_int d);
2127         __isl_give isl_qpolynomial *isl_qpolynomial_div(
2128                 __isl_take isl_div *div);
2129         __isl_give isl_qpolynomial *isl_qpolynomial_var(
2130                 __isl_take isl_dim *dim,
2131                 enum isl_dim_type type, unsigned pos);
2132
2133 The zero piecewise quasipolynomial or a piecewise quasipolynomial
2134 with a single cell can be created using the following functions.
2135 Multiple of these single cell piecewise quasipolynomials can
2136 be combined to create more complicated piecewise quasipolynomials.
2137
2138         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_zero(
2139                 __isl_take isl_dim *dim);
2140         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_alloc(
2141                 __isl_take isl_set *set,
2142                 __isl_take isl_qpolynomial *qp);
2143
2144         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_zero(
2145                 __isl_take isl_dim *dim);
2146         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_from_pw_qpolynomial(
2147                 __isl_take isl_pw_qpolynomial *pwqp);
2148         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add_pw_qpolynomial(
2149                 __isl_take isl_union_pw_qpolynomial *upwqp,
2150                 __isl_take isl_pw_qpolynomial *pwqp);
2151
2152 Quasipolynomials can be copied and freed again using the following
2153 functions.
2154
2155         __isl_give isl_qpolynomial *isl_qpolynomial_copy(
2156                 __isl_keep isl_qpolynomial *qp);
2157         void isl_qpolynomial_free(__isl_take isl_qpolynomial *qp);
2158
2159         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_copy(
2160                 __isl_keep isl_pw_qpolynomial *pwqp);
2161         void isl_pw_qpolynomial_free(
2162                 __isl_take isl_pw_qpolynomial *pwqp);
2163
2164         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_copy(
2165                 __isl_keep isl_union_pw_qpolynomial *upwqp);
2166         void isl_union_pw_qpolynomial_free(
2167                 __isl_take isl_union_pw_qpolynomial *upwqp);
2168
2169 =head3 Inspecting (Piecewise) Quasipolynomials
2170
2171 To iterate over all piecewise quasipolynomials in a union
2172 piecewise quasipolynomial, use the following function
2173
2174         int isl_union_pw_qpolynomial_foreach_pw_qpolynomial(
2175                 __isl_keep isl_union_pw_qpolynomial *upwqp,
2176                 int (*fn)(__isl_take isl_pw_qpolynomial *pwqp, void *user),
2177                 void *user);
2178
2179 To extract the piecewise quasipolynomial from a union with a given dimension
2180 specification, use
2181
2182         __isl_give isl_pw_qpolynomial *
2183         isl_union_pw_qpolynomial_extract_pw_qpolynomial(
2184                 __isl_keep isl_union_pw_qpolynomial *upwqp,
2185                 __isl_take isl_dim *dim);
2186
2187 To iterate over the cells in a piecewise quasipolynomial,
2188 use either of the following two functions
2189
2190         int isl_pw_qpolynomial_foreach_piece(
2191                 __isl_keep isl_pw_qpolynomial *pwqp,
2192                 int (*fn)(__isl_take isl_set *set,
2193                           __isl_take isl_qpolynomial *qp,
2194                           void *user), void *user);
2195         int isl_pw_qpolynomial_foreach_lifted_piece(
2196                 __isl_keep isl_pw_qpolynomial *pwqp,
2197                 int (*fn)(__isl_take isl_set *set,
2198                           __isl_take isl_qpolynomial *qp,
2199                           void *user), void *user);
2200
2201 As usual, the function C<fn> should return C<0> on success
2202 and C<-1> on failure.  The difference between
2203 C<isl_pw_qpolynomial_foreach_piece> and
2204 C<isl_pw_qpolynomial_foreach_lifted_piece> is that
2205 C<isl_pw_qpolynomial_foreach_lifted_piece> will first
2206 compute unique representations for all existentially quantified
2207 variables and then turn these existentially quantified variables
2208 into extra set variables, adapting the associated quasipolynomial
2209 accordingly.  This means that the C<set> passed to C<fn>
2210 will not have any existentially quantified variables, but that
2211 the dimensions of the sets may be different for different
2212 invocations of C<fn>.
2213
2214 To iterate over all terms in a quasipolynomial,
2215 use
2216
2217         int isl_qpolynomial_foreach_term(
2218                 __isl_keep isl_qpolynomial *qp,
2219                 int (*fn)(__isl_take isl_term *term,
2220                           void *user), void *user);
2221
2222 The terms themselves can be inspected and freed using
2223 these functions
2224
2225         unsigned isl_term_dim(__isl_keep isl_term *term,
2226                 enum isl_dim_type type);
2227         void isl_term_get_num(__isl_keep isl_term *term,
2228                 isl_int *n);
2229         void isl_term_get_den(__isl_keep isl_term *term,
2230                 isl_int *d);
2231         int isl_term_get_exp(__isl_keep isl_term *term,
2232                 enum isl_dim_type type, unsigned pos);
2233         __isl_give isl_div *isl_term_get_div(
2234                 __isl_keep isl_term *term, unsigned pos);
2235         void isl_term_free(__isl_take isl_term *term);
2236
2237 Each term is a product of parameters, set variables and
2238 integer divisions.  The function C<isl_term_get_exp>
2239 returns the exponent of a given dimensions in the given term.
2240 The C<isl_int>s in the arguments of C<isl_term_get_num>
2241 and C<isl_term_get_den> need to have been initialized
2242 using C<isl_int_init> before calling these functions.
2243
2244 =head3 Properties of (Piecewise) Quasipolynomials
2245
2246 To check whether a quasipolynomial is actually a constant,
2247 use the following function.
2248
2249         int isl_qpolynomial_is_cst(__isl_keep isl_qpolynomial *qp,
2250                 isl_int *n, isl_int *d);
2251
2252 If C<qp> is a constant and if C<n> and C<d> are not C<NULL>
2253 then the numerator and denominator of the constant
2254 are returned in C<*n> and C<*d>, respectively.
2255
2256 =head3 Operations on (Piecewise) Quasipolynomials
2257
2258         __isl_give isl_qpolynomial *isl_qpolynomial_neg(
2259                 __isl_take isl_qpolynomial *qp);
2260         __isl_give isl_qpolynomial *isl_qpolynomial_add(
2261                 __isl_take isl_qpolynomial *qp1,
2262                 __isl_take isl_qpolynomial *qp2);
2263         __isl_give isl_qpolynomial *isl_qpolynomial_sub(
2264                 __isl_take isl_qpolynomial *qp1,
2265                 __isl_take isl_qpolynomial *qp2);
2266         __isl_give isl_qpolynomial *isl_qpolynomial_mul(
2267                 __isl_take isl_qpolynomial *qp1,
2268                 __isl_take isl_qpolynomial *qp2);
2269         __isl_give isl_qpolynomial *isl_qpolynomial_pow(
2270                 __isl_take isl_qpolynomial *qp, unsigned exponent);
2271
2272         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add(
2273                 __isl_take isl_pw_qpolynomial *pwqp1,
2274                 __isl_take isl_pw_qpolynomial *pwqp2);
2275         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_sub(
2276                 __isl_take isl_pw_qpolynomial *pwqp1,
2277                 __isl_take isl_pw_qpolynomial *pwqp2);
2278         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add_disjoint(
2279                 __isl_take isl_pw_qpolynomial *pwqp1,
2280                 __isl_take isl_pw_qpolynomial *pwqp2);
2281         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_neg(
2282                 __isl_take isl_pw_qpolynomial *pwqp);
2283         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_mul(
2284                 __isl_take isl_pw_qpolynomial *pwqp1,
2285                 __isl_take isl_pw_qpolynomial *pwqp2);
2286
2287         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add(
2288                 __isl_take isl_union_pw_qpolynomial *upwqp1,
2289                 __isl_take isl_union_pw_qpolynomial *upwqp2);
2290         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_sub(
2291                 __isl_take isl_union_pw_qpolynomial *upwqp1,
2292                 __isl_take isl_union_pw_qpolynomial *upwqp2);
2293         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_mul(
2294                 __isl_take isl_union_pw_qpolynomial *upwqp1,
2295                 __isl_take isl_union_pw_qpolynomial *upwqp2);
2296
2297         __isl_give isl_qpolynomial *isl_pw_qpolynomial_eval(
2298                 __isl_take isl_pw_qpolynomial *pwqp,
2299                 __isl_take isl_point *pnt);
2300
2301         __isl_give isl_qpolynomial *isl_union_pw_qpolynomial_eval(
2302                 __isl_take isl_union_pw_qpolynomial *upwqp,
2303                 __isl_take isl_point *pnt);
2304
2305         __isl_give isl_set *isl_pw_qpolynomial_domain(
2306                 __isl_take isl_pw_qpolynomial *pwqp);
2307         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_intersect_domain(
2308                 __isl_take isl_pw_qpolynomial *pwpq,
2309                 __isl_take isl_set *set);
2310
2311         __isl_give isl_union_set *isl_union_pw_qpolynomial_domain(
2312                 __isl_take isl_union_pw_qpolynomial *upwqp);
2313         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_intersect_domain(
2314                 __isl_take isl_union_pw_qpolynomial *upwpq,
2315                 __isl_take isl_union_set *uset);
2316
2317         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_coalesce(
2318                 __isl_take isl_union_pw_qpolynomial *upwqp);
2319
2320         __isl_give isl_qpolynomial *isl_qpolynomial_gist(
2321                 __isl_take isl_qpolynomial *qp,
2322                 __isl_take isl_set *context);
2323
2324         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist(
2325                 __isl_take isl_pw_qpolynomial *pwqp,
2326                 __isl_take isl_set *context);
2327
2328         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_gist(
2329                 __isl_take isl_union_pw_qpolynomial *upwqp,
2330                 __isl_take isl_union_set *context);
2331
2332 The gist operation applies the gist operation to each of
2333 the cells in the domain of the input piecewise quasipolynomial.
2334 The context is also exploited
2335 to simplify the quasipolynomials associated to each cell.
2336
2337         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_to_polynomial(
2338                 __isl_take isl_pw_qpolynomial *pwqp, int sign);
2339         __isl_give isl_union_pw_qpolynomial *
2340         isl_union_pw_qpolynomial_to_polynomial(
2341                 __isl_take isl_union_pw_qpolynomial *upwqp, int sign);
2342
2343 Approximate each quasipolynomial by a polynomial.  If C<sign> is positive,
2344 the polynomial will be an overapproximation.  If C<sign> is negative,
2345 it will be an underapproximation.  If C<sign> is zero, the approximation
2346 will lie somewhere in between.
2347
2348 =head2 Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions
2349
2350 A piecewise quasipolynomial reduction is a piecewise
2351 reduction (or fold) of quasipolynomials.
2352 In particular, the reduction can be maximum or a minimum.
2353 The objects are mainly used to represent the result of
2354 an upper or lower bound on a quasipolynomial over its domain,
2355 i.e., as the result of the following function.
2356
2357         __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_bound(
2358                 __isl_take isl_pw_qpolynomial *pwqp,
2359                 enum isl_fold type, int *tight);
2360
2361         __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_bound(
2362                 __isl_take isl_union_pw_qpolynomial *upwqp,
2363                 enum isl_fold type, int *tight);
2364
2365 The C<type> argument may be either C<isl_fold_min> or C<isl_fold_max>.
2366 If C<tight> is not C<NULL>, then C<*tight> is set to C<1>
2367 is the returned bound is known be tight, i.e., for each value
2368 of the parameters there is at least
2369 one element in the domain that reaches the bound.
2370 If the domain of C<pwqp> is not wrapping, then the bound is computed
2371 over all elements in that domain and the result has a purely parametric
2372 domain.  If the domain of C<pwqp> is wrapping, then the bound is
2373 computed over the range of the wrapped relation.  The domain of the
2374 wrapped relation becomes the domain of the result.
2375
2376 A (piecewise) quasipolynomial reduction can be copied or freed using the
2377 following functions.
2378
2379         __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_copy(
2380                 __isl_keep isl_qpolynomial_fold *fold);
2381         __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_copy(
2382                 __isl_keep isl_pw_qpolynomial_fold *pwf);
2383         __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_copy(
2384                 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
2385         void isl_qpolynomial_fold_free(
2386                 __isl_take isl_qpolynomial_fold *fold);
2387         void isl_pw_qpolynomial_fold_free(
2388                 __isl_take isl_pw_qpolynomial_fold *pwf);
2389         void isl_union_pw_qpolynomial_fold_free(
2390                 __isl_take isl_union_pw_qpolynomial_fold *upwf);
2391
2392 =head3 Printing Piecewise Quasipolynomial Reductions
2393
2394 Piecewise quasipolynomial reductions can be printed
2395 using the following function.
2396
2397         __isl_give isl_printer *isl_printer_print_pw_qpolynomial_fold(
2398                 __isl_take isl_printer *p,
2399                 __isl_keep isl_pw_qpolynomial_fold *pwf);
2400         __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial_fold(
2401                 __isl_take isl_printer *p,
2402                 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
2403
2404 For C<isl_printer_print_pw_qpolynomial_fold>,
2405 output format of the printer
2406 needs to be set to either C<ISL_FORMAT_ISL> or C<ISL_FORMAT_C>.
2407 For C<isl_printer_print_union_pw_qpolynomial_fold>,
2408 output format of the printer
2409 needs to be set to C<ISL_FORMAT_ISL>.
2410 In case of printing in C<ISL_FORMAT_C>, the user may want
2411 to set the names of all dimensions
2412
2413         __isl_give isl_pw_qpolynomial_fold *
2414         isl_pw_qpolynomial_fold_set_dim_name(
2415                 __isl_take isl_pw_qpolynomial_fold *pwf,
2416                 enum isl_dim_type type, unsigned pos,
2417                 const char *s);
2418
2419 =head3 Inspecting (Piecewise) Quasipolynomial Reductions
2420
2421 To iterate over all piecewise quasipolynomial reductions in a union
2422 piecewise quasipolynomial reduction, use the following function
2423
2424         int isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(
2425                 __isl_keep isl_union_pw_qpolynomial_fold *upwf,
2426                 int (*fn)(__isl_take isl_pw_qpolynomial_fold *pwf,
2427                             void *user), void *user);
2428
2429 To iterate over the cells in a piecewise quasipolynomial reduction,
2430 use either of the following two functions
2431
2432         int isl_pw_qpolynomial_fold_foreach_piece(
2433                 __isl_keep isl_pw_qpolynomial_fold *pwf,
2434                 int (*fn)(__isl_take isl_set *set,
2435                           __isl_take isl_qpolynomial_fold *fold,
2436                           void *user), void *user);
2437         int isl_pw_qpolynomial_fold_foreach_lifted_piece(
2438                 __isl_keep isl_pw_qpolynomial_fold *pwf,
2439                 int (*fn)(__isl_take isl_set *set,
2440                           __isl_take isl_qpolynomial_fold *fold,
2441                           void *user), void *user);
2442
2443 See L<Inspecting (Piecewise) Quasipolynomials> for an explanation
2444 of the difference between these two functions.
2445
2446 To iterate over all quasipolynomials in a reduction, use
2447
2448         int isl_qpolynomial_fold_foreach_qpolynomial(
2449                 __isl_keep isl_qpolynomial_fold *fold,
2450                 int (*fn)(__isl_take isl_qpolynomial *qp,
2451                           void *user), void *user);
2452
2453 =head3 Operations on Piecewise Quasipolynomial Reductions
2454
2455         __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_add(
2456                 __isl_take isl_pw_qpolynomial_fold *pwf1,
2457                 __isl_take isl_pw_qpolynomial_fold *pwf2);
2458
2459         __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_fold(
2460                 __isl_take isl_pw_qpolynomial_fold *pwf1,
2461                 __isl_take isl_pw_qpolynomial_fold *pwf2);
2462
2463         __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_fold(
2464                 __isl_take isl_union_pw_qpolynomial_fold *upwf1,
2465                 __isl_take isl_union_pw_qpolynomial_fold *upwf2);
2466
2467         __isl_give isl_qpolynomial *isl_pw_qpolynomial_fold_eval(
2468                 __isl_take isl_pw_qpolynomial_fold *pwf,
2469                 __isl_take isl_point *pnt);
2470
2471         __isl_give isl_qpolynomial *isl_union_pw_qpolynomial_fold_eval(
2472                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
2473                 __isl_take isl_point *pnt);
2474
2475         __isl_give isl_union_set *isl_union_pw_qpolynomial_fold_domain(
2476                 __isl_take isl_union_pw_qpolynomial_fold *upwf);
2477         __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_intersect_domain(
2478                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
2479                 __isl_take isl_union_set *uset);
2480
2481         __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_coalesce(
2482                 __isl_take isl_pw_qpolynomial_fold *pwf);
2483
2484         __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_coalesce(
2485                 __isl_take isl_union_pw_qpolynomial_fold *upwf);
2486
2487         __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_gist(
2488                 __isl_take isl_pw_qpolynomial_fold *pwf,
2489                 __isl_take isl_set *context);
2490
2491         __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_gist(
2492                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
2493                 __isl_take isl_union_set *context);
2494
2495 The gist operation applies the gist operation to each of
2496 the cells in the domain of the input piecewise quasipolynomial reduction.
2497 In future, the operation will also exploit the context
2498 to simplify the quasipolynomial reductions associated to each cell.
2499
2500         __isl_give isl_pw_qpolynomial_fold *
2501         isl_set_apply_pw_qpolynomial_fold(
2502                 __isl_take isl_set *set,
2503                 __isl_take isl_pw_qpolynomial_fold *pwf,
2504                 int *tight);
2505         __isl_give isl_pw_qpolynomial_fold *
2506         isl_map_apply_pw_qpolynomial_fold(
2507                 __isl_take isl_map *map,
2508                 __isl_take isl_pw_qpolynomial_fold *pwf,
2509                 int *tight);
2510         __isl_give isl_union_pw_qpolynomial_fold *
2511         isl_union_set_apply_union_pw_qpolynomial_fold(
2512                 __isl_take isl_union_set *uset,
2513                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
2514                 int *tight);
2515         __isl_give isl_union_pw_qpolynomial_fold *
2516         isl_union_map_apply_union_pw_qpolynomial_fold(
2517                 __isl_take isl_union_map *umap,
2518                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
2519                 int *tight);
2520
2521 The functions taking a map
2522 compose the given map with the given piecewise quasipolynomial reduction.
2523 That is, compute a bound (of the same type as C<pwf> or C<upwf> itself)
2524 over all elements in the intersection of the range of the map
2525 and the domain of the piecewise quasipolynomial reduction
2526 as a function of an element in the domain of the map.
2527 The functions taking a set compute a bound over all elements in the
2528 intersection of the set and the domain of the
2529 piecewise quasipolynomial reduction.
2530
2531 =head2 Dependence Analysis
2532
2533 C<isl> contains specialized functionality for performing
2534 array dataflow analysis.  That is, given a I<sink> access relation
2535 and a collection of possible I<source> access relations,
2536 C<isl> can compute relations that describe
2537 for each iteration of the sink access, which iteration
2538 of which of the source access relations was the last
2539 to access the same data element before the given iteration
2540 of the sink access.
2541 To compute standard flow dependences, the sink should be
2542 a read, while the sources should be writes.
2543 If any of the source accesses are marked as being I<may>
2544 accesses, then there will be a dependence to the last
2545 I<must> access B<and> to any I<may> access that follows
2546 this last I<must> access.
2547 In particular, if I<all> sources are I<may> accesses,
2548 then memory based dependence analysis is performed.
2549 If, on the other hand, all sources are I<must> accesses,
2550 then value based dependence analysis is performed.
2551
2552         #include <isl/flow.h>
2553
2554         typedef int (*isl_access_level_before)(void *first, void *second);
2555
2556         __isl_give isl_access_info *isl_access_info_alloc(
2557                 __isl_take isl_map *sink,
2558                 void *sink_user, isl_access_level_before fn,
2559                 int max_source);
2560         __isl_give isl_access_info *isl_access_info_add_source(
2561                 __isl_take isl_access_info *acc,
2562                 __isl_take isl_map *source, int must,
2563                 void *source_user);
2564         void isl_access_info_free(__isl_take isl_access_info *acc);
2565
2566         __isl_give isl_flow *isl_access_info_compute_flow(
2567                 __isl_take isl_access_info *acc);
2568
2569         int isl_flow_foreach(__isl_keep isl_flow *deps,
2570                 int (*fn)(__isl_take isl_map *dep, int must,
2571                           void *dep_user, void *user),
2572                 void *user);
2573         __isl_give isl_map *isl_flow_get_no_source(
2574                 __isl_keep isl_flow *deps, int must);
2575         void isl_flow_free(__isl_take isl_flow *deps);
2576
2577 The function C<isl_access_info_compute_flow> performs the actual
2578 dependence analysis.  The other functions are used to construct
2579 the input for this function or to read off the output.
2580
2581 The input is collected in an C<isl_access_info>, which can
2582 be created through a call to C<isl_access_info_alloc>.
2583 The arguments to this functions are the sink access relation
2584 C<sink>, a token C<sink_user> used to identify the sink
2585 access to the user, a callback function for specifying the
2586 relative order of source and sink accesses, and the number
2587 of source access relations that will be added.
2588 The callback function has type C<int (*)(void *first, void *second)>.
2589 The function is called with two user supplied tokens identifying
2590 either a source or the sink and it should return the shared nesting
2591 level and the relative order of the two accesses.
2592 In particular, let I<n> be the number of loops shared by
2593 the two accesses.  If C<first> precedes C<second> textually,
2594 then the function should return I<2 * n + 1>; otherwise,
2595 it should return I<2 * n>.
2596 The sources can be added to the C<isl_access_info> by performing
2597 (at most) C<max_source> calls to C<isl_access_info_add_source>.
2598 C<must> indicates whether the source is a I<must> access
2599 or a I<may> access.  Note that a multi-valued access relation
2600 should only be marked I<must> if every iteration in the domain
2601 of the relation accesses I<all> elements in its image.
2602 The C<source_user> token is again used to identify
2603 the source access.  The range of the source access relation
2604 C<source> should have the same dimension as the range
2605 of the sink access relation.
2606 The C<isl_access_info_free> function should usually not be
2607 called explicitly, because it is called implicitly by
2608 C<isl_access_info_compute_flow>.
2609
2610 The result of the dependence analysis is collected in an
2611 C<isl_flow>.  There may be elements of
2612 the sink access for which no preceding source access could be
2613 found or for which all preceding sources are I<may> accesses.
2614 The relations containing these elements can be obtained through
2615 calls to C<isl_flow_get_no_source>, the first with C<must> set
2616 and the second with C<must> unset.
2617 In the case of standard flow dependence analysis,
2618 with the sink a read and the sources I<must> writes,
2619 the first relation corresponds to the reads from uninitialized
2620 array elements and the second relation is empty.
2621 The actual flow dependences can be extracted using
2622 C<isl_flow_foreach>.  This function will call the user-specified
2623 callback function C<fn> for each B<non-empty> dependence between
2624 a source and the sink.  The callback function is called
2625 with four arguments, the actual flow dependence relation
2626 mapping source iterations to sink iterations, a boolean that
2627 indicates whether it is a I<must> or I<may> dependence, a token
2628 identifying the source and an additional C<void *> with value
2629 equal to the third argument of the C<isl_flow_foreach> call.
2630 A dependence is marked I<must> if it originates from a I<must>
2631 source and if it is not followed by any I<may> sources.
2632
2633 After finishing with an C<isl_flow>, the user should call
2634 C<isl_flow_free> to free all associated memory.
2635
2636 A higher-level interface to dependence analysis is provided
2637 by the following function.
2638
2639         #include <isl/flow.h>
2640
2641         int isl_union_map_compute_flow(__isl_take isl_union_map *sink,
2642                 __isl_take isl_union_map *must_source,
2643                 __isl_take isl_union_map *may_source,
2644                 __isl_take isl_union_map *schedule,
2645                 __isl_give isl_union_map **must_dep,
2646                 __isl_give isl_union_map **may_dep,
2647                 __isl_give isl_union_map **must_no_source,
2648                 __isl_give isl_union_map **may_no_source);
2649
2650 The arrays are identified by the tuple names of the ranges
2651 of the accesses.  The iteration domains by the tuple names
2652 of the domains of the accesses and of the schedule.
2653 The relative order of the iteration domains is given by the
2654 schedule.  The relations returned through C<must_no_source>
2655 and C<may_no_source> are subsets of C<sink>.
2656 Any of C<must_dep>, C<may_dep>, C<must_no_source>
2657 or C<may_no_source> may be C<NULL>, but a C<NULL> value for
2658 any of the other arguments is treated as an error.
2659
2660 =head2 Scheduling
2661
2662 B<The functionality described in this section is fairly new
2663 and may be subject to change.>
2664
2665 The following function can be used to compute a schedule
2666 for a union of domains.  The generated schedule respects
2667 all C<validity> dependences.  That is, all dependence distances
2668 over these dependences in the scheduled space are lexicographically
2669 positive.  The generated schedule schedule also tries to minimize
2670 the dependence distances over C<proximity> dependences.
2671 Moreover, it tries to obtain sequences (bands) of schedule dimensions
2672 for groups of domains where the dependence distances have only
2673 non-negative values.
2674 The algorithm used to construct the schedule is similar to that
2675 of C<Pluto>.
2676
2677         #include <isl/schedule.h>
2678         __isl_give isl_schedule *isl_union_set_compute_schedule(
2679                 __isl_take isl_union_set *domain,
2680                 __isl_take isl_union_map *validity,
2681                 __isl_take isl_union_map *proximity);
2682         void *isl_schedule_free(__isl_take isl_schedule *sched);
2683
2684 A mapping from the domains to the scheduled space can be obtained
2685 from an C<isl_schedule> using the following function.
2686
2687         __isl_give isl_union_map *isl_schedule_get_map(
2688                 __isl_keep isl_schedule *sched);
2689
2690 This mapping can also be obtained in pieces using the following functions.
2691
2692         int isl_schedule_n_band(__isl_keep isl_schedule *sched);
2693         __isl_give isl_union_map *isl_schedule_get_band(
2694                 __isl_keep isl_schedule *sched, unsigned band);
2695
2696 C<isl_schedule_n_band> returns the maximal number of bands.
2697 C<isl_schedule_get_band> returns a union of mappings from a domain to
2698 the band of consecutive schedule dimensions with the given sequence
2699 number for that domain.  Bands with the same sequence number but for
2700 different domains may be completely unrelated.
2701 Within a band, the corresponding coordinates of the distance vectors
2702 are all non-negative, assuming that the coordinates for all previous
2703 bands are all zero.
2704
2705 =head2 Parametric Vertex Enumeration
2706
2707 The parametric vertex enumeration described in this section
2708 is mainly intended to be used internally and by the C<barvinok>
2709 library.
2710
2711         #include <isl/vertices.h>
2712         __isl_give isl_vertices *isl_basic_set_compute_vertices(
2713                 __isl_keep isl_basic_set *bset);
2714
2715 The function C<isl_basic_set_compute_vertices> performs the
2716 actual computation of the parametric vertices and the chamber
2717 decomposition and store the result in an C<isl_vertices> object.
2718 This information can be queried by either iterating over all
2719 the vertices or iterating over all the chambers or cells
2720 and then iterating over all vertices that are active on the chamber.
2721
2722         int isl_vertices_foreach_vertex(
2723                 __isl_keep isl_vertices *vertices,
2724                 int (*fn)(__isl_take isl_vertex *vertex, void *user),
2725                 void *user);
2726
2727         int isl_vertices_foreach_cell(
2728                 __isl_keep isl_vertices *vertices,
2729                 int (*fn)(__isl_take isl_cell *cell, void *user),
2730                 void *user);
2731         int isl_cell_foreach_vertex(__isl_keep isl_cell *cell,
2732                 int (*fn)(__isl_take isl_vertex *vertex, void *user),
2733                 void *user);
2734
2735 Other operations that can be performed on an C<isl_vertices> object are
2736 the following.
2737
2738         isl_ctx *isl_vertices_get_ctx(
2739                 __isl_keep isl_vertices *vertices);
2740         int isl_vertices_get_n_vertices(
2741                 __isl_keep isl_vertices *vertices);
2742         void isl_vertices_free(__isl_take isl_vertices *vertices);
2743
2744 Vertices can be inspected and destroyed using the following functions.
2745
2746         isl_ctx *isl_vertex_get_ctx(__isl_keep isl_vertex *vertex);
2747         int isl_vertex_get_id(__isl_keep isl_vertex *vertex);
2748         __isl_give isl_basic_set *isl_vertex_get_domain(
2749                 __isl_keep isl_vertex *vertex);
2750         __isl_give isl_basic_set *isl_vertex_get_expr(
2751                 __isl_keep isl_vertex *vertex);
2752         void isl_vertex_free(__isl_take isl_vertex *vertex);
2753
2754 C<isl_vertex_get_expr> returns a singleton parametric set describing
2755 the vertex, while C<isl_vertex_get_domain> returns the activity domain
2756 of the vertex.
2757 Note that C<isl_vertex_get_domain> and C<isl_vertex_get_expr> return
2758 B<rational> basic sets, so they should mainly be used for inspection
2759 and should not be mixed with integer sets.
2760
2761 Chambers can be inspected and destroyed using the following functions.
2762
2763         isl_ctx *isl_cell_get_ctx(__isl_keep isl_cell *cell);
2764         __isl_give isl_basic_set *isl_cell_get_domain(
2765                 __isl_keep isl_cell *cell);
2766         void isl_cell_free(__isl_take isl_cell *cell);
2767
2768 =head1 Applications
2769
2770 Although C<isl> is mainly meant to be used as a library,
2771 it also contains some basic applications that use some
2772 of the functionality of C<isl>.
2773 The input may be specified in either the L<isl format>
2774 or the L<PolyLib format>.
2775
2776 =head2 C<isl_polyhedron_sample>
2777
2778 C<isl_polyhedron_sample> takes a polyhedron as input and prints
2779 an integer element of the polyhedron, if there is any.
2780 The first column in the output is the denominator and is always
2781 equal to 1.  If the polyhedron contains no integer points,
2782 then a vector of length zero is printed.
2783
2784 =head2 C<isl_pip>
2785
2786 C<isl_pip> takes the same input as the C<example> program
2787 from the C<piplib> distribution, i.e., a set of constraints
2788 on the parameters, a line containing only -1 and finally a set
2789 of constraints on a parametric polyhedron.
2790 The coefficients of the parameters appear in the last columns
2791 (but before the final constant column).
2792 The output is the lexicographic minimum of the parametric polyhedron.
2793 As C<isl> currently does not have its own output format, the output
2794 is just a dump of the internal state.
2795
2796 =head2 C<isl_polyhedron_minimize>
2797
2798 C<isl_polyhedron_minimize> computes the minimum of some linear
2799 or affine objective function over the integer points in a polyhedron.
2800 If an affine objective function
2801 is given, then the constant should appear in the last column.
2802
2803 =head2 C<isl_polytope_scan>
2804
2805 Given a polytope, C<isl_polytope_scan> prints
2806 all integer points in the polytope.