c9e997a955b12ebcc60b68b9e1546f8ee0ce4f6c
[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 a B<map> space as input.  An old call
72 C<isl_map_identity(space)> can be rewritten to
73 C<isl_map_identity(isl_space_map_from_set(space))>.
74
75 =item * The function C<isl_map_power> no longer takes
76 a parameter position as input.  Instead, the exponent
77 is now expressed as the domain of the resulting relation.
78
79 =back
80
81 =head3 Changes since isl-0.06
82
83 =over
84
85 =item * The format of C<isl_printer_print_qpolynomial>'s
86 C<ISL_FORMAT_ISL> output has changed.
87 Use C<ISL_FORMAT_C> to obtain the old output.
88
89 =item * The C<*_fast_*> functions have been renamed to C<*_plain_*>.
90 Some of the old names have been kept for backward compatibility,
91 but they will be removed in the future.
92
93 =back
94
95 =head3 Changes since isl-0.07
96
97 =over
98
99 =item * The function C<isl_pw_aff_max> has been renamed to
100 C<isl_pw_aff_union_max>.
101 Similarly, the function C<isl_pw_aff_add> has been renamed to
102 C<isl_pw_aff_union_add>.
103
104 =item * The C<isl_dim> type has been renamed to C<isl_space>
105 along with the associated functions.
106 Some of the old names have been kept for backward compatibility,
107 but they will be removed in the future.
108
109 =item * Spaces of maps, sets and parameter domains are now
110 treated differently.  The distinction between map spaces and set spaces
111 has always been made on a conceptual level, but proper use of such spaces
112 was never checked.  Furthermore, up until isl-0.07 there was no way
113 of explicitly creating a parameter space.  These can now be created
114 directly using C<isl_space_params_alloc> or from other spaces using
115 C<isl_space_params>.
116
117 =item * The space in which C<isl_aff>, C<isl_pw_aff>, C<isl_qpolynomial>,
118 C<isl_pw_qpolynomial>, C<isl_qpolynomial_fold> and C<isl_pw_qpolynomial_fold>
119 objects live is now a map space
120 instead of a set space.  This means, for example, that the dimensions
121 of the domain of an C<isl_aff> are now considered to be of type
122 C<isl_dim_in> instead of C<isl_dim_set>.  Extra functions have been
123 added to obtain the domain space.  Some of the constructors still
124 take a domain space and have therefore been renamed.
125
126 =item * The functions C<isl_equality_alloc> and C<isl_inequality_alloc>
127 now take an C<isl_local_space> instead of an C<isl_space>.
128 An C<isl_local_space> can be created from an C<isl_space>
129 using C<isl_local_space_from_space>.
130
131 =item * The C<isl_div> type has been removed.  Functions that used
132 to return an C<isl_div> now return an C<isl_aff>.
133 Note that the space of an C<isl_aff> is that of relation.
134 When replacing a call to C<isl_div_get_coefficient> by a call to
135 C<isl_aff_get_coefficient> any C<isl_dim_set> argument needs
136 to be replaced by C<isl_dim_in>.
137 A call to C<isl_aff_from_div> can be replaced by a call
138 to C<isl_aff_floor>.
139 A call to C<isl_qpolynomial_div(div)> call be replaced by
140 the nested call
141
142         isl_qpolynomial_from_aff(isl_aff_floor(div))
143
144 The function C<isl_constraint_div> has also been renamed
145 to C<isl_constraint_get_div>.
146
147 =item * The C<nparam> argument has been removed from
148 C<isl_map_read_from_str> and similar functions.
149 When reading input in the original PolyLib format,
150 the result will have no parameters.
151 If parameters are expected, the caller may want to perform
152 dimension manipulation on the result.
153
154 =back
155
156 =head1 Installation
157
158 The source of C<isl> can be obtained either as a tarball
159 or from the git repository.  Both are available from
160 L<http://freshmeat.net/projects/isl/>.
161 The installation process depends on how you obtained
162 the source.
163
164 =head2 Installation from the git repository
165
166 =over
167
168 =item 1 Clone or update the repository
169
170 The first time the source is obtained, you need to clone
171 the repository.
172
173         git clone git://repo.or.cz/isl.git
174
175 To obtain updates, you need to pull in the latest changes
176
177         git pull
178
179 =item 2 Generate C<configure>
180
181         ./autogen.sh
182
183 =back
184
185 After performing the above steps, continue
186 with the L<Common installation instructions>.
187
188 =head2 Common installation instructions
189
190 =over
191
192 =item 1 Obtain C<GMP>
193
194 Building C<isl> requires C<GMP>, including its headers files.
195 Your distribution may not provide these header files by default
196 and you may need to install a package called C<gmp-devel> or something
197 similar.  Alternatively, C<GMP> can be built from
198 source, available from L<http://gmplib.org/>.
199
200 =item 2 Configure
201
202 C<isl> uses the standard C<autoconf> C<configure> script.
203 To run it, just type
204
205         ./configure
206
207 optionally followed by some configure options.
208 A complete list of options can be obtained by running
209
210         ./configure --help
211
212 Below we discuss some of the more common options.
213
214 C<isl> can optionally use C<piplib>, but no
215 C<piplib> functionality is currently used by default.
216 The C<--with-piplib> option can
217 be used to specify which C<piplib>
218 library to use, either an installed version (C<system>),
219 an externally built version (C<build>)
220 or no version (C<no>).  The option C<build> is mostly useful
221 in C<configure> scripts of larger projects that bundle both C<isl>
222 and C<piplib>.
223
224 =over
225
226 =item C<--prefix>
227
228 Installation prefix for C<isl>
229
230 =item C<--with-gmp-prefix>
231
232 Installation prefix for C<GMP> (architecture-independent files).
233
234 =item C<--with-gmp-exec-prefix>
235
236 Installation prefix for C<GMP> (architecture-dependent files).
237
238 =item C<--with-piplib>
239
240 Which copy of C<piplib> to use, either C<no> (default), C<system> or C<build>.
241
242 =item C<--with-piplib-prefix>
243
244 Installation prefix for C<system> C<piplib> (architecture-independent files).
245
246 =item C<--with-piplib-exec-prefix>
247
248 Installation prefix for C<system> C<piplib> (architecture-dependent files).
249
250 =item C<--with-piplib-builddir>
251
252 Location where C<build> C<piplib> was built.
253
254 =back
255
256 =item 3 Compile
257
258         make
259
260 =item 4 Install (optional)
261
262         make install
263
264 =back
265
266 =head1 Library
267
268 =head2 Initialization
269
270 All manipulations of integer sets and relations occur within
271 the context of an C<isl_ctx>.
272 A given C<isl_ctx> can only be used within a single thread.
273 All arguments of a function are required to have been allocated
274 within the same context.
275 There are currently no functions available for moving an object
276 from one C<isl_ctx> to another C<isl_ctx>.  This means that
277 there is currently no way of safely moving an object from one
278 thread to another, unless the whole C<isl_ctx> is moved.
279
280 An C<isl_ctx> can be allocated using C<isl_ctx_alloc> and
281 freed using C<isl_ctx_free>.
282 All objects allocated within an C<isl_ctx> should be freed
283 before the C<isl_ctx> itself is freed.
284
285         isl_ctx *isl_ctx_alloc();
286         void isl_ctx_free(isl_ctx *ctx);
287
288 =head2 Integers
289
290 All operations on integers, mainly the coefficients
291 of the constraints describing the sets and relations,
292 are performed in exact integer arithmetic using C<GMP>.
293 However, to allow future versions of C<isl> to optionally
294 support fixed integer arithmetic, all calls to C<GMP>
295 are wrapped inside C<isl> specific macros.
296 The basic type is C<isl_int> and the operations below
297 are available on this type.
298 The meanings of these operations are essentially the same
299 as their C<GMP> C<mpz_> counterparts.
300 As always with C<GMP> types, C<isl_int>s need to be
301 initialized with C<isl_int_init> before they can be used
302 and they need to be released with C<isl_int_clear>
303 after the last use.
304 The user should not assume that an C<isl_int> is represented
305 as a C<mpz_t>, but should instead explicitly convert between
306 C<mpz_t>s and C<isl_int>s using C<isl_int_set_gmp> and
307 C<isl_int_get_gmp> whenever a C<mpz_t> is required.
308
309 =over
310
311 =item isl_int_init(i)
312
313 =item isl_int_clear(i)
314
315 =item isl_int_set(r,i)
316
317 =item isl_int_set_si(r,i)
318
319 =item isl_int_set_gmp(r,g)
320
321 =item isl_int_get_gmp(i,g)
322
323 =item isl_int_abs(r,i)
324
325 =item isl_int_neg(r,i)
326
327 =item isl_int_swap(i,j)
328
329 =item isl_int_swap_or_set(i,j)
330
331 =item isl_int_add_ui(r,i,j)
332
333 =item isl_int_sub_ui(r,i,j)
334
335 =item isl_int_add(r,i,j)
336
337 =item isl_int_sub(r,i,j)
338
339 =item isl_int_mul(r,i,j)
340
341 =item isl_int_mul_ui(r,i,j)
342
343 =item isl_int_addmul(r,i,j)
344
345 =item isl_int_submul(r,i,j)
346
347 =item isl_int_gcd(r,i,j)
348
349 =item isl_int_lcm(r,i,j)
350
351 =item isl_int_divexact(r,i,j)
352
353 =item isl_int_cdiv_q(r,i,j)
354
355 =item isl_int_fdiv_q(r,i,j)
356
357 =item isl_int_fdiv_r(r,i,j)
358
359 =item isl_int_fdiv_q_ui(r,i,j)
360
361 =item isl_int_read(r,s)
362
363 =item isl_int_print(out,i,width)
364
365 =item isl_int_sgn(i)
366
367 =item isl_int_cmp(i,j)
368
369 =item isl_int_cmp_si(i,si)
370
371 =item isl_int_eq(i,j)
372
373 =item isl_int_ne(i,j)
374
375 =item isl_int_lt(i,j)
376
377 =item isl_int_le(i,j)
378
379 =item isl_int_gt(i,j)
380
381 =item isl_int_ge(i,j)
382
383 =item isl_int_abs_eq(i,j)
384
385 =item isl_int_abs_ne(i,j)
386
387 =item isl_int_abs_lt(i,j)
388
389 =item isl_int_abs_gt(i,j)
390
391 =item isl_int_abs_ge(i,j)
392
393 =item isl_int_is_zero(i)
394
395 =item isl_int_is_one(i)
396
397 =item isl_int_is_negone(i)
398
399 =item isl_int_is_pos(i)
400
401 =item isl_int_is_neg(i)
402
403 =item isl_int_is_nonpos(i)
404
405 =item isl_int_is_nonneg(i)
406
407 =item isl_int_is_divisible_by(i,j)
408
409 =back
410
411 =head2 Sets and Relations
412
413 C<isl> uses six types of objects for representing sets and relations,
414 C<isl_basic_set>, C<isl_basic_map>, C<isl_set>, C<isl_map>,
415 C<isl_union_set> and C<isl_union_map>.
416 C<isl_basic_set> and C<isl_basic_map> represent sets and relations that
417 can be described as a conjunction of affine constraints, while
418 C<isl_set> and C<isl_map> represent unions of
419 C<isl_basic_set>s and C<isl_basic_map>s, respectively.
420 However, all C<isl_basic_set>s or C<isl_basic_map>s in the union need
421 to live in the same space.  C<isl_union_set>s and C<isl_union_map>s
422 represent unions of C<isl_set>s or C<isl_map>s in I<different> spaces,
423 where spaces are considered different if they have a different number
424 of dimensions and/or different names (see L<"Spaces">).
425 The difference between sets and relations (maps) is that sets have
426 one set of variables, while relations have two sets of variables,
427 input variables and output variables.
428
429 =head2 Memory Management
430
431 Since a high-level operation on sets and/or relations usually involves
432 several substeps and since the user is usually not interested in
433 the intermediate results, most functions that return a new object
434 will also release all the objects passed as arguments.
435 If the user still wants to use one or more of these arguments
436 after the function call, she should pass along a copy of the
437 object rather than the object itself.
438 The user is then responsible for making sure that the original
439 object gets used somewhere else or is explicitly freed.
440
441 The arguments and return values of all documented functions are
442 annotated to make clear which arguments are released and which
443 arguments are preserved.  In particular, the following annotations
444 are used
445
446 =over
447
448 =item C<__isl_give>
449
450 C<__isl_give> means that a new object is returned.
451 The user should make sure that the returned pointer is
452 used exactly once as a value for an C<__isl_take> argument.
453 In between, it can be used as a value for as many
454 C<__isl_keep> arguments as the user likes.
455 There is one exception, and that is the case where the
456 pointer returned is C<NULL>.  Is this case, the user
457 is free to use it as an C<__isl_take> argument or not.
458
459 =item C<__isl_take>
460
461 C<__isl_take> means that the object the argument points to
462 is taken over by the function and may no longer be used
463 by the user as an argument to any other function.
464 The pointer value must be one returned by a function
465 returning an C<__isl_give> pointer.
466 If the user passes in a C<NULL> value, then this will
467 be treated as an error in the sense that the function will
468 not perform its usual operation.  However, it will still
469 make sure that all the other C<__isl_take> arguments
470 are released.
471
472 =item C<__isl_keep>
473
474 C<__isl_keep> means that the function will only use the object
475 temporarily.  After the function has finished, the user
476 can still use it as an argument to other functions.
477 A C<NULL> value will be treated in the same way as
478 a C<NULL> value for an C<__isl_take> argument.
479
480 =back
481
482 =head2 Error Handling
483
484 C<isl> supports different ways to react in case a runtime error is triggered.
485 Runtime errors arise, e.g., if a function such as C<isl_map_intersect> is called
486 with two maps that have incompatible spaces. There are three possible ways
487 to react on error: to warn, to continue or to abort.
488
489 The default behavior is to warn. In this mode, C<isl> prints a warning, stores
490 the last error in the corresponding C<isl_ctx> and the function in which the
491 error was triggered returns C<NULL>. An error does not corrupt internal state,
492 such that isl can continue to be used. C<isl> also provides functions to
493 read the last error and to reset the memory that stores the last error. The
494 last error is only stored for information purposes. Its presence does not
495 change the behavior of C<isl>. Hence, resetting an error is not required to
496 continue to use isl, but only to observe new errors.
497
498         #include <isl/ctx.h>
499         enum isl_error isl_ctx_last_error(isl_ctx *ctx);
500         void isl_ctx_reset_error(isl_ctx *ctx);
501
502 Another option is to continue on error. This is similar to warn on error mode,
503 except that C<isl> does not print any warning. This allows a program to
504 implement its own error reporting.
505
506 The last option is to directly abort the execution of the program from within
507 the isl library. This makes it obviously impossible to recover from an error,
508 but it allows to directly spot the error location. By aborting on error,
509 debuggers break at the location the error occurred and can provide a stack
510 trace. Other tools that automatically provide stack traces on abort or that do
511 not want to continue execution after an error was triggered may also prefer to
512 abort on error.
513
514 The on error behavior of isl can be specified by calling
515 C<isl_options_set_on_error> or by setting the command line option
516 C<--isl-on-error>. Valid arguments for the function call are
517 C<ISL_ON_ERROR_WARN>, C<ISL_ON_ERROR_CONTINUE> and C<ISL_ON_ERROR_ABORT>. The
518 choices for the command line option are C<warn>, C<continue> and C<abort>.
519 It is also possible to query the current error mode.
520
521         #include <isl/options.h>
522         int isl_options_set_on_error(isl_ctx *ctx, int val);
523         int isl_options_get_on_error(isl_ctx *ctx);
524
525 =head2 Identifiers
526
527 Identifiers are used to identify both individual dimensions
528 and tuples of dimensions.  They consist of a name and an optional
529 pointer.  Identifiers with the same name but different pointer values
530 are considered to be distinct.
531 Identifiers can be constructed, copied, freed, inspected and printed
532 using the following functions.
533
534         #include <isl/id.h>
535         __isl_give isl_id *isl_id_alloc(isl_ctx *ctx,
536                 __isl_keep const char *name, void *user);
537         __isl_give isl_id *isl_id_copy(isl_id *id);
538         void *isl_id_free(__isl_take isl_id *id);
539
540         isl_ctx *isl_id_get_ctx(__isl_keep isl_id *id);
541         void *isl_id_get_user(__isl_keep isl_id *id);
542         __isl_keep const char *isl_id_get_name(__isl_keep isl_id *id);
543
544         __isl_give isl_printer *isl_printer_print_id(
545                 __isl_take isl_printer *p, __isl_keep isl_id *id);
546
547 Note that C<isl_id_get_name> returns a pointer to some internal
548 data structure, so the result can only be used while the
549 corresponding C<isl_id> is alive.
550
551 =head2 Spaces
552
553 Whenever a new set or relation is created from scratch,
554 the space in which it lives needs to be specified using an C<isl_space>.
555
556         #include <isl/space.h>
557         __isl_give isl_space *isl_space_alloc(isl_ctx *ctx,
558                 unsigned nparam, unsigned n_in, unsigned n_out);
559         __isl_give isl_space *isl_space_params_alloc(isl_ctx *ctx,
560                 unsigned nparam);
561         __isl_give isl_space *isl_space_set_alloc(isl_ctx *ctx,
562                 unsigned nparam, unsigned dim);
563         __isl_give isl_space *isl_space_copy(__isl_keep isl_space *space);
564         void isl_space_free(__isl_take isl_space *space);
565         unsigned isl_space_dim(__isl_keep isl_space *space,
566                 enum isl_dim_type type);
567
568 The space used for creating a parameter domain
569 needs to be created using C<isl_space_params_alloc>.
570 For other sets, the space
571 needs to be created using C<isl_space_set_alloc>, while
572 for a relation, the space
573 needs to be created using C<isl_space_alloc>.
574 C<isl_space_dim> can be used
575 to find out the number of dimensions of each type in
576 a space, where type may be
577 C<isl_dim_param>, C<isl_dim_in> (only for relations),
578 C<isl_dim_out> (only for relations), C<isl_dim_set>
579 (only for sets) or C<isl_dim_all>.
580
581 To check whether a given space is that of a set or a map
582 or whether it is a parameter space, use these functions:
583
584         #include <isl/space.h>
585         int isl_space_is_params(__isl_keep isl_space *space);
586         int isl_space_is_set(__isl_keep isl_space *space);
587
588 It is often useful to create objects that live in the
589 same space as some other object.  This can be accomplished
590 by creating the new objects
591 (see L<Creating New Sets and Relations> or
592 L<Creating New (Piecewise) Quasipolynomials>) based on the space
593 of the original object.
594
595         #include <isl/set.h>
596         __isl_give isl_space *isl_basic_set_get_space(
597                 __isl_keep isl_basic_set *bset);
598         __isl_give isl_space *isl_set_get_space(__isl_keep isl_set *set);
599
600         #include <isl/union_set.h>
601         __isl_give isl_space *isl_union_set_get_space(
602                 __isl_keep isl_union_set *uset);
603
604         #include <isl/map.h>
605         __isl_give isl_space *isl_basic_map_get_space(
606                 __isl_keep isl_basic_map *bmap);
607         __isl_give isl_space *isl_map_get_space(__isl_keep isl_map *map);
608
609         #include <isl/union_map.h>
610         __isl_give isl_space *isl_union_map_get_space(
611                 __isl_keep isl_union_map *umap);
612
613         #include <isl/constraint.h>
614         __isl_give isl_space *isl_constraint_get_space(
615                 __isl_keep isl_constraint *constraint);
616
617         #include <isl/polynomial.h>
618         __isl_give isl_space *isl_qpolynomial_get_domain_space(
619                 __isl_keep isl_qpolynomial *qp);
620         __isl_give isl_space *isl_qpolynomial_get_space(
621                 __isl_keep isl_qpolynomial *qp);
622         __isl_give isl_space *isl_qpolynomial_fold_get_space(
623                 __isl_keep isl_qpolynomial_fold *fold);
624         __isl_give isl_space *isl_pw_qpolynomial_get_domain_space(
625                 __isl_keep isl_pw_qpolynomial *pwqp);
626         __isl_give isl_space *isl_pw_qpolynomial_get_space(
627                 __isl_keep isl_pw_qpolynomial *pwqp);
628         __isl_give isl_space *isl_pw_qpolynomial_fold_get_domain_space(
629                 __isl_keep isl_pw_qpolynomial_fold *pwf);
630         __isl_give isl_space *isl_pw_qpolynomial_fold_get_space(
631                 __isl_keep isl_pw_qpolynomial_fold *pwf);
632         __isl_give isl_space *isl_union_pw_qpolynomial_get_space(
633                 __isl_keep isl_union_pw_qpolynomial *upwqp);
634         __isl_give isl_space *isl_union_pw_qpolynomial_fold_get_space(
635                 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
636
637         #include <isl/aff.h>
638         __isl_give isl_space *isl_aff_get_domain_space(
639                 __isl_keep isl_aff *aff);
640         __isl_give isl_space *isl_aff_get_space(
641                 __isl_keep isl_aff *aff);
642         __isl_give isl_space *isl_pw_aff_get_domain_space(
643                 __isl_keep isl_pw_aff *pwaff);
644         __isl_give isl_space *isl_pw_aff_get_space(
645                 __isl_keep isl_pw_aff *pwaff);
646         __isl_give isl_space *isl_multi_aff_get_space(
647                 __isl_keep isl_multi_aff *maff);
648         __isl_give isl_space *isl_pw_multi_aff_get_domain_space(
649                 __isl_keep isl_pw_multi_aff *pma);
650         __isl_give isl_space *isl_pw_multi_aff_get_space(
651                 __isl_keep isl_pw_multi_aff *pma);
652
653         #include <isl/point.h>
654         __isl_give isl_space *isl_point_get_space(
655                 __isl_keep isl_point *pnt);
656
657 The identifiers or names of the individual dimensions may be set or read off
658 using the following functions.
659
660         #include <isl/space.h>
661         __isl_give isl_space *isl_space_set_dim_id(
662                 __isl_take isl_space *space,
663                 enum isl_dim_type type, unsigned pos,
664                 __isl_take isl_id *id);
665         int isl_space_has_dim_id(__isl_keep isl_space *space,
666                 enum isl_dim_type type, unsigned pos);
667         __isl_give isl_id *isl_space_get_dim_id(
668                 __isl_keep isl_space *space,
669                 enum isl_dim_type type, unsigned pos);
670         __isl_give isl_space *isl_space_set_dim_name(__isl_take isl_space *space,
671                                  enum isl_dim_type type, unsigned pos,
672                                  __isl_keep const char *name);
673         __isl_keep const char *isl_space_get_dim_name(__isl_keep isl_space *space,
674                                  enum isl_dim_type type, unsigned pos);
675
676 Note that C<isl_space_get_name> returns a pointer to some internal
677 data structure, so the result can only be used while the
678 corresponding C<isl_space> is alive.
679 Also note that every function that operates on two sets or relations
680 requires that both arguments have the same parameters.  This also
681 means that if one of the arguments has named parameters, then the
682 other needs to have named parameters too and the names need to match.
683 Pairs of C<isl_set>, C<isl_map>, C<isl_union_set> and/or C<isl_union_map>
684 arguments may have different parameters (as long as they are named),
685 in which case the result will have as parameters the union of the parameters of
686 the arguments.
687
688 Given the identifier or name of a dimension (typically a parameter),
689 its position can be obtained from the following function.
690
691         #include <isl/space.h>
692         int isl_space_find_dim_by_id(__isl_keep isl_space *space,
693                 enum isl_dim_type type, __isl_keep isl_id *id);
694         int isl_space_find_dim_by_name(__isl_keep isl_space *space,
695                 enum isl_dim_type type, const char *name);
696
697 The identifiers or names of entire spaces may be set or read off
698 using the following functions.
699
700         #include <isl/space.h>
701         __isl_give isl_space *isl_space_set_tuple_id(
702                 __isl_take isl_space *space,
703                 enum isl_dim_type type, __isl_take isl_id *id);
704         __isl_give isl_space *isl_space_reset_tuple_id(
705                 __isl_take isl_space *space, enum isl_dim_type type);
706         int isl_space_has_tuple_id(__isl_keep isl_space *space,
707                 enum isl_dim_type type);
708         __isl_give isl_id *isl_space_get_tuple_id(
709                 __isl_keep isl_space *space, enum isl_dim_type type);
710         __isl_give isl_space *isl_space_set_tuple_name(
711                 __isl_take isl_space *space,
712                 enum isl_dim_type type, const char *s);
713         const char *isl_space_get_tuple_name(__isl_keep isl_space *space,
714                 enum isl_dim_type type);
715
716 The C<type> argument needs to be one of C<isl_dim_in>, C<isl_dim_out>
717 or C<isl_dim_set>.  As with C<isl_space_get_name>,
718 the C<isl_space_get_tuple_name> function returns a pointer to some internal
719 data structure.
720 Binary operations require the corresponding spaces of their arguments
721 to have the same name.
722
723 Spaces can be nested.  In particular, the domain of a set or
724 the domain or range of a relation can be a nested relation.
725 The following functions can be used to construct and deconstruct
726 such nested spaces.
727
728         #include <isl/space.h>
729         int isl_space_is_wrapping(__isl_keep isl_space *space);
730         __isl_give isl_space *isl_space_wrap(__isl_take isl_space *space);
731         __isl_give isl_space *isl_space_unwrap(__isl_take isl_space *space);
732
733 The input to C<isl_space_is_wrapping> and C<isl_space_unwrap> should
734 be the space of a set, while that of
735 C<isl_space_wrap> should be the space of a relation.
736 Conversely, the output of C<isl_space_unwrap> is the space
737 of a relation, while that of C<isl_space_wrap> is the space of a set.
738
739 Spaces can be created from other spaces
740 using the following functions.
741
742         __isl_give isl_space *isl_space_domain(__isl_take isl_space *space);
743         __isl_give isl_space *isl_space_from_domain(__isl_take isl_space *space);
744         __isl_give isl_space *isl_space_range(__isl_take isl_space *space);
745         __isl_give isl_space *isl_space_from_range(__isl_take isl_space *space);
746         __isl_give isl_space *isl_space_params(
747                 __isl_take isl_space *space);
748         __isl_give isl_space *isl_space_set_from_params(
749                 __isl_take isl_space *space);
750         __isl_give isl_space *isl_space_reverse(__isl_take isl_space *space);
751         __isl_give isl_space *isl_space_join(__isl_take isl_space *left,
752                 __isl_take isl_space *right);
753         __isl_give isl_space *isl_space_align_params(
754                 __isl_take isl_space *space1, __isl_take isl_space *space2)
755         __isl_give isl_space *isl_space_insert_dims(__isl_take isl_space *space,
756                 enum isl_dim_type type, unsigned pos, unsigned n);
757         __isl_give isl_space *isl_space_add_dims(__isl_take isl_space *space,
758                 enum isl_dim_type type, unsigned n);
759         __isl_give isl_space *isl_space_drop_dims(__isl_take isl_space *space,
760                 enum isl_dim_type type, unsigned first, unsigned n);
761         __isl_give isl_space *isl_space_move_dims(__isl_take isl_space *space,
762                 enum isl_dim_type dst_type, unsigned dst_pos,
763                 enum isl_dim_type src_type, unsigned src_pos,
764                 unsigned n);
765         __isl_give isl_space *isl_space_map_from_set(
766                 __isl_take isl_space *space);
767         __isl_give isl_space *isl_space_map_from_domain_and_range(
768                 __isl_take isl_space *domain,
769                 __isl_take isl_space *range);
770         __isl_give isl_space *isl_space_zip(__isl_take isl_space *space);
771
772 Note that if dimensions are added or removed from a space, then
773 the name and the internal structure are lost.
774
775 =head2 Local Spaces
776
777 A local space is essentially a space with
778 zero or more existentially quantified variables.
779 The local space of a basic set or relation can be obtained
780 using the following functions.
781
782         #include <isl/set.h>
783         __isl_give isl_local_space *isl_basic_set_get_local_space(
784                 __isl_keep isl_basic_set *bset);
785
786         #include <isl/map.h>
787         __isl_give isl_local_space *isl_basic_map_get_local_space(
788                 __isl_keep isl_basic_map *bmap);
789
790 A new local space can be created from a space using
791
792         #include <isl/local_space.h>
793         __isl_give isl_local_space *isl_local_space_from_space(
794                 __isl_take isl_space *space);
795
796 They can be inspected, modified, copied and freed using the following functions.
797
798         #include <isl/local_space.h>
799         isl_ctx *isl_local_space_get_ctx(
800                 __isl_keep isl_local_space *ls);
801         int isl_local_space_is_set(__isl_keep isl_local_space *ls);
802         int isl_local_space_dim(__isl_keep isl_local_space *ls,
803                 enum isl_dim_type type);
804         const char *isl_local_space_get_dim_name(
805                 __isl_keep isl_local_space *ls,
806                 enum isl_dim_type type, unsigned pos);
807         __isl_give isl_local_space *isl_local_space_set_dim_name(
808                 __isl_take isl_local_space *ls,
809                 enum isl_dim_type type, unsigned pos, const char *s);
810         __isl_give isl_local_space *isl_local_space_set_dim_id(
811                 __isl_take isl_local_space *ls,
812                 enum isl_dim_type type, unsigned pos,
813                 __isl_take isl_id *id);
814         __isl_give isl_space *isl_local_space_get_space(
815                 __isl_keep isl_local_space *ls);
816         __isl_give isl_aff *isl_local_space_get_div(
817                 __isl_keep isl_local_space *ls, int pos);
818         __isl_give isl_local_space *isl_local_space_copy(
819                 __isl_keep isl_local_space *ls);
820         void *isl_local_space_free(__isl_take isl_local_space *ls);
821
822 Two local spaces can be compared using
823
824         int isl_local_space_is_equal(__isl_keep isl_local_space *ls1,
825                 __isl_keep isl_local_space *ls2);
826
827 Local spaces can be created from other local spaces
828 using the following functions.
829
830         __isl_give isl_local_space *isl_local_space_domain(
831                 __isl_take isl_local_space *ls);
832         __isl_give isl_local_space *isl_local_space_range(
833                 __isl_take isl_local_space *ls);
834         __isl_give isl_local_space *isl_local_space_from_domain(
835                 __isl_take isl_local_space *ls);
836         __isl_give isl_local_space *isl_local_space_intersect(
837                 __isl_take isl_local_space *ls1,
838                 __isl_take isl_local_space *ls2);
839         __isl_give isl_local_space *isl_local_space_add_dims(
840                 __isl_take isl_local_space *ls,
841                 enum isl_dim_type type, unsigned n);
842         __isl_give isl_local_space *isl_local_space_insert_dims(
843                 __isl_take isl_local_space *ls,
844                 enum isl_dim_type type, unsigned first, unsigned n);
845         __isl_give isl_local_space *isl_local_space_drop_dims(
846                 __isl_take isl_local_space *ls,
847                 enum isl_dim_type type, unsigned first, unsigned n);
848
849 =head2 Input and Output
850
851 C<isl> supports its own input/output format, which is similar
852 to the C<Omega> format, but also supports the C<PolyLib> format
853 in some cases.
854
855 =head3 C<isl> format
856
857 The C<isl> format is similar to that of C<Omega>, but has a different
858 syntax for describing the parameters and allows for the definition
859 of an existentially quantified variable as the integer division
860 of an affine expression.
861 For example, the set of integers C<i> between C<0> and C<n>
862 such that C<i % 10 <= 6> can be described as
863
864         [n] -> { [i] : exists (a = [i/10] : 0 <= i and i <= n and
865                                 i - 10 a <= 6) }
866
867 A set or relation can have several disjuncts, separated
868 by the keyword C<or>.  Each disjunct is either a conjunction
869 of constraints or a projection (C<exists>) of a conjunction
870 of constraints.  The constraints are separated by the keyword
871 C<and>.
872
873 =head3 C<PolyLib> format
874
875 If the represented set is a union, then the first line
876 contains a single number representing the number of disjuncts.
877 Otherwise, a line containing the number C<1> is optional.
878
879 Each disjunct is represented by a matrix of constraints.
880 The first line contains two numbers representing
881 the number of rows and columns,
882 where the number of rows is equal to the number of constraints
883 and the number of columns is equal to two plus the number of variables.
884 The following lines contain the actual rows of the constraint matrix.
885 In each row, the first column indicates whether the constraint
886 is an equality (C<0>) or inequality (C<1>).  The final column
887 corresponds to the constant term.
888
889 If the set is parametric, then the coefficients of the parameters
890 appear in the last columns before the constant column.
891 The coefficients of any existentially quantified variables appear
892 between those of the set variables and those of the parameters.
893
894 =head3 Extended C<PolyLib> format
895
896 The extended C<PolyLib> format is nearly identical to the
897 C<PolyLib> format.  The only difference is that the line
898 containing the number of rows and columns of a constraint matrix
899 also contains four additional numbers:
900 the number of output dimensions, the number of input dimensions,
901 the number of local dimensions (i.e., the number of existentially
902 quantified variables) and the number of parameters.
903 For sets, the number of ``output'' dimensions is equal
904 to the number of set dimensions, while the number of ``input''
905 dimensions is zero.
906
907 =head3 Input
908
909         #include <isl/set.h>
910         __isl_give isl_basic_set *isl_basic_set_read_from_file(
911                 isl_ctx *ctx, FILE *input);
912         __isl_give isl_basic_set *isl_basic_set_read_from_str(
913                 isl_ctx *ctx, const char *str);
914         __isl_give isl_set *isl_set_read_from_file(isl_ctx *ctx,
915                 FILE *input);
916         __isl_give isl_set *isl_set_read_from_str(isl_ctx *ctx,
917                 const char *str);
918
919         #include <isl/map.h>
920         __isl_give isl_basic_map *isl_basic_map_read_from_file(
921                 isl_ctx *ctx, FILE *input);
922         __isl_give isl_basic_map *isl_basic_map_read_from_str(
923                 isl_ctx *ctx, const char *str);
924         __isl_give isl_map *isl_map_read_from_file(
925                 isl_ctx *ctx, FILE *input);
926         __isl_give isl_map *isl_map_read_from_str(isl_ctx *ctx,
927                 const char *str);
928
929         #include <isl/union_set.h>
930         __isl_give isl_union_set *isl_union_set_read_from_file(
931                 isl_ctx *ctx, FILE *input);
932         __isl_give isl_union_set *isl_union_set_read_from_str(
933                 isl_ctx *ctx, const char *str);
934
935         #include <isl/union_map.h>
936         __isl_give isl_union_map *isl_union_map_read_from_file(
937                 isl_ctx *ctx, FILE *input);
938         __isl_give isl_union_map *isl_union_map_read_from_str(
939                 isl_ctx *ctx, const char *str);
940
941 The input format is autodetected and may be either the C<PolyLib> format
942 or the C<isl> format.
943
944 =head3 Output
945
946 Before anything can be printed, an C<isl_printer> needs to
947 be created.
948
949         __isl_give isl_printer *isl_printer_to_file(isl_ctx *ctx,
950                 FILE *file);
951         __isl_give isl_printer *isl_printer_to_str(isl_ctx *ctx);
952         void isl_printer_free(__isl_take isl_printer *printer);
953         __isl_give char *isl_printer_get_str(
954                 __isl_keep isl_printer *printer);
955
956 The behavior of the printer can be modified in various ways
957
958         __isl_give isl_printer *isl_printer_set_output_format(
959                 __isl_take isl_printer *p, int output_format);
960         __isl_give isl_printer *isl_printer_set_indent(
961                 __isl_take isl_printer *p, int indent);
962         __isl_give isl_printer *isl_printer_indent(
963                 __isl_take isl_printer *p, int indent);
964         __isl_give isl_printer *isl_printer_set_prefix(
965                 __isl_take isl_printer *p, const char *prefix);
966         __isl_give isl_printer *isl_printer_set_suffix(
967                 __isl_take isl_printer *p, const char *suffix);
968
969 The C<output_format> may be either C<ISL_FORMAT_ISL>, C<ISL_FORMAT_OMEGA>,
970 C<ISL_FORMAT_POLYLIB>, C<ISL_FORMAT_EXT_POLYLIB> or C<ISL_FORMAT_LATEX>
971 and defaults to C<ISL_FORMAT_ISL>.
972 Each line in the output is indented by C<indent> (set by
973 C<isl_printer_set_indent>) spaces
974 (default: 0), prefixed by C<prefix> and suffixed by C<suffix>.
975 In the C<PolyLib> format output,
976 the coefficients of the existentially quantified variables
977 appear between those of the set variables and those
978 of the parameters.
979 The function C<isl_printer_indent> increases the indentation
980 by the specified amount (which may be negative).
981
982 To actually print something, use
983
984         #include <isl/set.h>
985         __isl_give isl_printer *isl_printer_print_basic_set(
986                 __isl_take isl_printer *printer,
987                 __isl_keep isl_basic_set *bset);
988         __isl_give isl_printer *isl_printer_print_set(
989                 __isl_take isl_printer *printer,
990                 __isl_keep isl_set *set);
991
992         #include <isl/map.h>
993         __isl_give isl_printer *isl_printer_print_basic_map(
994                 __isl_take isl_printer *printer,
995                 __isl_keep isl_basic_map *bmap);
996         __isl_give isl_printer *isl_printer_print_map(
997                 __isl_take isl_printer *printer,
998                 __isl_keep isl_map *map);
999
1000         #include <isl/union_set.h>
1001         __isl_give isl_printer *isl_printer_print_union_set(
1002                 __isl_take isl_printer *p,
1003                 __isl_keep isl_union_set *uset);
1004
1005         #include <isl/union_map.h>
1006         __isl_give isl_printer *isl_printer_print_union_map(
1007                 __isl_take isl_printer *p,
1008                 __isl_keep isl_union_map *umap);
1009
1010 When called on a file printer, the following function flushes
1011 the file.  When called on a string printer, the buffer is cleared.
1012
1013         __isl_give isl_printer *isl_printer_flush(
1014                 __isl_take isl_printer *p);
1015
1016 =head2 Creating New Sets and Relations
1017
1018 C<isl> has functions for creating some standard sets and relations.
1019
1020 =over
1021
1022 =item * Empty sets and relations
1023
1024         __isl_give isl_basic_set *isl_basic_set_empty(
1025                 __isl_take isl_space *space);
1026         __isl_give isl_basic_map *isl_basic_map_empty(
1027                 __isl_take isl_space *space);
1028         __isl_give isl_set *isl_set_empty(
1029                 __isl_take isl_space *space);
1030         __isl_give isl_map *isl_map_empty(
1031                 __isl_take isl_space *space);
1032         __isl_give isl_union_set *isl_union_set_empty(
1033                 __isl_take isl_space *space);
1034         __isl_give isl_union_map *isl_union_map_empty(
1035                 __isl_take isl_space *space);
1036
1037 For C<isl_union_set>s and C<isl_union_map>s, the space
1038 is only used to specify the parameters.
1039
1040 =item * Universe sets and relations
1041
1042         __isl_give isl_basic_set *isl_basic_set_universe(
1043                 __isl_take isl_space *space);
1044         __isl_give isl_basic_map *isl_basic_map_universe(
1045                 __isl_take isl_space *space);
1046         __isl_give isl_set *isl_set_universe(
1047                 __isl_take isl_space *space);
1048         __isl_give isl_map *isl_map_universe(
1049                 __isl_take isl_space *space);
1050         __isl_give isl_union_set *isl_union_set_universe(
1051                 __isl_take isl_union_set *uset);
1052         __isl_give isl_union_map *isl_union_map_universe(
1053                 __isl_take isl_union_map *umap);
1054
1055 The sets and relations constructed by the functions above
1056 contain all integer values, while those constructed by the
1057 functions below only contain non-negative values.
1058
1059         __isl_give isl_basic_set *isl_basic_set_nat_universe(
1060                 __isl_take isl_space *space);
1061         __isl_give isl_basic_map *isl_basic_map_nat_universe(
1062                 __isl_take isl_space *space);
1063         __isl_give isl_set *isl_set_nat_universe(
1064                 __isl_take isl_space *space);
1065         __isl_give isl_map *isl_map_nat_universe(
1066                 __isl_take isl_space *space);
1067
1068 =item * Identity relations
1069
1070         __isl_give isl_basic_map *isl_basic_map_identity(
1071                 __isl_take isl_space *space);
1072         __isl_give isl_map *isl_map_identity(
1073                 __isl_take isl_space *space);
1074
1075 The number of input and output dimensions in C<space> needs
1076 to be the same.
1077
1078 =item * Lexicographic order
1079
1080         __isl_give isl_map *isl_map_lex_lt(
1081                 __isl_take isl_space *set_space);
1082         __isl_give isl_map *isl_map_lex_le(
1083                 __isl_take isl_space *set_space);
1084         __isl_give isl_map *isl_map_lex_gt(
1085                 __isl_take isl_space *set_space);
1086         __isl_give isl_map *isl_map_lex_ge(
1087                 __isl_take isl_space *set_space);
1088         __isl_give isl_map *isl_map_lex_lt_first(
1089                 __isl_take isl_space *space, unsigned n);
1090         __isl_give isl_map *isl_map_lex_le_first(
1091                 __isl_take isl_space *space, unsigned n);
1092         __isl_give isl_map *isl_map_lex_gt_first(
1093                 __isl_take isl_space *space, unsigned n);
1094         __isl_give isl_map *isl_map_lex_ge_first(
1095                 __isl_take isl_space *space, unsigned n);
1096
1097 The first four functions take a space for a B<set>
1098 and return relations that express that the elements in the domain
1099 are lexicographically less
1100 (C<isl_map_lex_lt>), less or equal (C<isl_map_lex_le>),
1101 greater (C<isl_map_lex_gt>) or greater or equal (C<isl_map_lex_ge>)
1102 than the elements in the range.
1103 The last four functions take a space for a map
1104 and return relations that express that the first C<n> dimensions
1105 in the domain are lexicographically less
1106 (C<isl_map_lex_lt_first>), less or equal (C<isl_map_lex_le_first>),
1107 greater (C<isl_map_lex_gt_first>) or greater or equal (C<isl_map_lex_ge_first>)
1108 than the first C<n> dimensions in the range.
1109
1110 =back
1111
1112 A basic set or relation can be converted to a set or relation
1113 using the following functions.
1114
1115         __isl_give isl_set *isl_set_from_basic_set(
1116                 __isl_take isl_basic_set *bset);
1117         __isl_give isl_map *isl_map_from_basic_map(
1118                 __isl_take isl_basic_map *bmap);
1119
1120 Sets and relations can be converted to union sets and relations
1121 using the following functions.
1122
1123         __isl_give isl_union_map *isl_union_map_from_map(
1124                 __isl_take isl_map *map);
1125         __isl_give isl_union_set *isl_union_set_from_set(
1126                 __isl_take isl_set *set);
1127
1128 The inverse conversions below can only be used if the input
1129 union set or relation is known to contain elements in exactly one
1130 space.
1131
1132         __isl_give isl_set *isl_set_from_union_set(
1133                 __isl_take isl_union_set *uset);
1134         __isl_give isl_map *isl_map_from_union_map(
1135                 __isl_take isl_union_map *umap);
1136
1137 A zero-dimensional set can be constructed on a given parameter domain
1138 using the following function.
1139
1140         __isl_give isl_set *isl_set_from_params(
1141                 __isl_take isl_set *set);
1142
1143 Sets and relations can be copied and freed again using the following
1144 functions.
1145
1146         __isl_give isl_basic_set *isl_basic_set_copy(
1147                 __isl_keep isl_basic_set *bset);
1148         __isl_give isl_set *isl_set_copy(__isl_keep isl_set *set);
1149         __isl_give isl_union_set *isl_union_set_copy(
1150                 __isl_keep isl_union_set *uset);
1151         __isl_give isl_basic_map *isl_basic_map_copy(
1152                 __isl_keep isl_basic_map *bmap);
1153         __isl_give isl_map *isl_map_copy(__isl_keep isl_map *map);
1154         __isl_give isl_union_map *isl_union_map_copy(
1155                 __isl_keep isl_union_map *umap);
1156         void isl_basic_set_free(__isl_take isl_basic_set *bset);
1157         void isl_set_free(__isl_take isl_set *set);
1158         void *isl_union_set_free(__isl_take isl_union_set *uset);
1159         void isl_basic_map_free(__isl_take isl_basic_map *bmap);
1160         void isl_map_free(__isl_take isl_map *map);
1161         void *isl_union_map_free(__isl_take isl_union_map *umap);
1162
1163 Other sets and relations can be constructed by starting
1164 from a universe set or relation, adding equality and/or
1165 inequality constraints and then projecting out the
1166 existentially quantified variables, if any.
1167 Constraints can be constructed, manipulated and
1168 added to (or removed from) (basic) sets and relations
1169 using the following functions.
1170
1171         #include <isl/constraint.h>
1172         __isl_give isl_constraint *isl_equality_alloc(
1173                 __isl_take isl_local_space *ls);
1174         __isl_give isl_constraint *isl_inequality_alloc(
1175                 __isl_take isl_local_space *ls);
1176         __isl_give isl_constraint *isl_constraint_set_constant(
1177                 __isl_take isl_constraint *constraint, isl_int v);
1178         __isl_give isl_constraint *isl_constraint_set_constant_si(
1179                 __isl_take isl_constraint *constraint, int v);
1180         __isl_give isl_constraint *isl_constraint_set_coefficient(
1181                 __isl_take isl_constraint *constraint,
1182                 enum isl_dim_type type, int pos, isl_int v);
1183         __isl_give isl_constraint *isl_constraint_set_coefficient_si(
1184                 __isl_take isl_constraint *constraint,
1185                 enum isl_dim_type type, int pos, int v);
1186         __isl_give isl_basic_map *isl_basic_map_add_constraint(
1187                 __isl_take isl_basic_map *bmap,
1188                 __isl_take isl_constraint *constraint);
1189         __isl_give isl_basic_set *isl_basic_set_add_constraint(
1190                 __isl_take isl_basic_set *bset,
1191                 __isl_take isl_constraint *constraint);
1192         __isl_give isl_map *isl_map_add_constraint(
1193                 __isl_take isl_map *map,
1194                 __isl_take isl_constraint *constraint);
1195         __isl_give isl_set *isl_set_add_constraint(
1196                 __isl_take isl_set *set,
1197                 __isl_take isl_constraint *constraint);
1198         __isl_give isl_basic_set *isl_basic_set_drop_constraint(
1199                 __isl_take isl_basic_set *bset,
1200                 __isl_take isl_constraint *constraint);
1201
1202 For example, to create a set containing the even integers
1203 between 10 and 42, you would use the following code.
1204
1205         isl_space *space;
1206         isl_local_space *ls;
1207         isl_constraint *c;
1208         isl_basic_set *bset;
1209
1210         space = isl_space_set_alloc(ctx, 0, 2);
1211         bset = isl_basic_set_universe(isl_space_copy(space));
1212         ls = isl_local_space_from_space(space);
1213
1214         c = isl_equality_alloc(isl_local_space_copy(ls));
1215         c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
1216         c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 2);
1217         bset = isl_basic_set_add_constraint(bset, c);
1218
1219         c = isl_inequality_alloc(isl_local_space_copy(ls));
1220         c = isl_constraint_set_constant_si(c, -10);
1221         c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
1222         bset = isl_basic_set_add_constraint(bset, c);
1223
1224         c = isl_inequality_alloc(ls);
1225         c = isl_constraint_set_constant_si(c, 42);
1226         c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
1227         bset = isl_basic_set_add_constraint(bset, c);
1228
1229         bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 1);
1230
1231 Or, alternatively,
1232
1233         isl_basic_set *bset;
1234         bset = isl_basic_set_read_from_str(ctx,
1235                 "{[i] : exists (a : i = 2a and i >= 10 and i <= 42)}");
1236
1237 A basic set or relation can also be constructed from two matrices
1238 describing the equalities and the inequalities.
1239
1240         __isl_give isl_basic_set *isl_basic_set_from_constraint_matrices(
1241                 __isl_take isl_space *space,
1242                 __isl_take isl_mat *eq, __isl_take isl_mat *ineq,
1243                 enum isl_dim_type c1,
1244                 enum isl_dim_type c2, enum isl_dim_type c3,
1245                 enum isl_dim_type c4);
1246         __isl_give isl_basic_map *isl_basic_map_from_constraint_matrices(
1247                 __isl_take isl_space *space,
1248                 __isl_take isl_mat *eq, __isl_take isl_mat *ineq,
1249                 enum isl_dim_type c1,
1250                 enum isl_dim_type c2, enum isl_dim_type c3,
1251                 enum isl_dim_type c4, enum isl_dim_type c5);
1252
1253 The C<isl_dim_type> arguments indicate the order in which
1254 different kinds of variables appear in the input matrices
1255 and should be a permutation of C<isl_dim_cst>, C<isl_dim_param>,
1256 C<isl_dim_set> and C<isl_dim_div> for sets and
1257 of C<isl_dim_cst>, C<isl_dim_param>,
1258 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div> for relations.
1259
1260 A (basic) set or relation can also be constructed from a (piecewise)
1261 (multiple) affine expression
1262 or a list of affine expressions
1263 (See L<"Piecewise Quasi Affine Expressions"> and
1264 L<"Piecewise Multiple Quasi Affine Expressions">).
1265
1266         __isl_give isl_basic_map *isl_basic_map_from_aff(
1267                 __isl_take isl_aff *aff);
1268         __isl_give isl_set *isl_set_from_pw_aff(
1269                 __isl_take isl_pw_aff *pwaff);
1270         __isl_give isl_map *isl_map_from_pw_aff(
1271                 __isl_take isl_pw_aff *pwaff);
1272         __isl_give isl_basic_map *isl_basic_map_from_aff_list(
1273                 __isl_take isl_space *domain_space,
1274                 __isl_take isl_aff_list *list);
1275         __isl_give isl_basic_map *isl_basic_map_from_multi_aff(
1276                 __isl_take isl_multi_aff *maff)
1277         __isl_give isl_set *isl_set_from_pw_multi_aff(
1278                 __isl_take isl_pw_multi_aff *pma);
1279         __isl_give isl_map *isl_map_from_pw_multi_aff(
1280                 __isl_take isl_pw_multi_aff *pma);
1281
1282 The C<domain_dim> argument describes the domain of the resulting
1283 basic relation.  It is required because the C<list> may consist
1284 of zero affine expressions.
1285
1286 =head2 Inspecting Sets and Relations
1287
1288 Usually, the user should not have to care about the actual constraints
1289 of the sets and maps, but should instead apply the abstract operations
1290 explained in the following sections.
1291 Occasionally, however, it may be required to inspect the individual
1292 coefficients of the constraints.  This section explains how to do so.
1293 In these cases, it may also be useful to have C<isl> compute
1294 an explicit representation of the existentially quantified variables.
1295
1296         __isl_give isl_set *isl_set_compute_divs(
1297                 __isl_take isl_set *set);
1298         __isl_give isl_map *isl_map_compute_divs(
1299                 __isl_take isl_map *map);
1300         __isl_give isl_union_set *isl_union_set_compute_divs(
1301                 __isl_take isl_union_set *uset);
1302         __isl_give isl_union_map *isl_union_map_compute_divs(
1303                 __isl_take isl_union_map *umap);
1304
1305 This explicit representation defines the existentially quantified
1306 variables as integer divisions of the other variables, possibly
1307 including earlier existentially quantified variables.
1308 An explicitly represented existentially quantified variable therefore
1309 has a unique value when the values of the other variables are known.
1310 If, furthermore, the same existentials, i.e., existentials
1311 with the same explicit representations, should appear in the
1312 same order in each of the disjuncts of a set or map, then the user should call
1313 either of the following functions.
1314
1315         __isl_give isl_set *isl_set_align_divs(
1316                 __isl_take isl_set *set);
1317         __isl_give isl_map *isl_map_align_divs(
1318                 __isl_take isl_map *map);
1319
1320 Alternatively, the existentially quantified variables can be removed
1321 using the following functions, which compute an overapproximation.
1322
1323         __isl_give isl_basic_set *isl_basic_set_remove_divs(
1324                 __isl_take isl_basic_set *bset);
1325         __isl_give isl_basic_map *isl_basic_map_remove_divs(
1326                 __isl_take isl_basic_map *bmap);
1327         __isl_give isl_set *isl_set_remove_divs(
1328                 __isl_take isl_set *set);
1329         __isl_give isl_map *isl_map_remove_divs(
1330                 __isl_take isl_map *map);
1331
1332 To iterate over all the sets or maps in a union set or map, use
1333
1334         int isl_union_set_foreach_set(__isl_keep isl_union_set *uset,
1335                 int (*fn)(__isl_take isl_set *set, void *user),
1336                 void *user);
1337         int isl_union_map_foreach_map(__isl_keep isl_union_map *umap,
1338                 int (*fn)(__isl_take isl_map *map, void *user),
1339                 void *user);
1340
1341 The number of sets or maps in a union set or map can be obtained
1342 from
1343
1344         int isl_union_set_n_set(__isl_keep isl_union_set *uset);
1345         int isl_union_map_n_map(__isl_keep isl_union_map *umap);
1346
1347 To extract the set or map in a given space from a union, use
1348
1349         __isl_give isl_set *isl_union_set_extract_set(
1350                 __isl_keep isl_union_set *uset,
1351                 __isl_take isl_space *space);
1352         __isl_give isl_map *isl_union_map_extract_map(
1353                 __isl_keep isl_union_map *umap,
1354                 __isl_take isl_space *space);
1355
1356 To iterate over all the basic sets or maps in a set or map, use
1357
1358         int isl_set_foreach_basic_set(__isl_keep isl_set *set,
1359                 int (*fn)(__isl_take isl_basic_set *bset, void *user),
1360                 void *user);
1361         int isl_map_foreach_basic_map(__isl_keep isl_map *map,
1362                 int (*fn)(__isl_take isl_basic_map *bmap, void *user),
1363                 void *user);
1364
1365 The callback function C<fn> should return 0 if successful and
1366 -1 if an error occurs.  In the latter case, or if any other error
1367 occurs, the above functions will return -1.
1368
1369 It should be noted that C<isl> does not guarantee that
1370 the basic sets or maps passed to C<fn> are disjoint.
1371 If this is required, then the user should call one of
1372 the following functions first.
1373
1374         __isl_give isl_set *isl_set_make_disjoint(
1375                 __isl_take isl_set *set);
1376         __isl_give isl_map *isl_map_make_disjoint(
1377                 __isl_take isl_map *map);
1378
1379 The number of basic sets in a set can be obtained
1380 from
1381
1382         int isl_set_n_basic_set(__isl_keep isl_set *set);
1383
1384 To iterate over the constraints of a basic set or map, use
1385
1386         #include <isl/constraint.h>
1387
1388         int isl_basic_map_foreach_constraint(
1389                 __isl_keep isl_basic_map *bmap,
1390                 int (*fn)(__isl_take isl_constraint *c, void *user),
1391                 void *user);
1392         void *isl_constraint_free(__isl_take isl_constraint *c);
1393
1394 Again, the callback function C<fn> should return 0 if successful and
1395 -1 if an error occurs.  In the latter case, or if any other error
1396 occurs, the above functions will return -1.
1397 The constraint C<c> represents either an equality or an inequality.
1398 Use the following function to find out whether a constraint
1399 represents an equality.  If not, it represents an inequality.
1400
1401         int isl_constraint_is_equality(
1402                 __isl_keep isl_constraint *constraint);
1403
1404 The coefficients of the constraints can be inspected using
1405 the following functions.
1406
1407         void isl_constraint_get_constant(
1408                 __isl_keep isl_constraint *constraint, isl_int *v);
1409         void isl_constraint_get_coefficient(
1410                 __isl_keep isl_constraint *constraint,
1411                 enum isl_dim_type type, int pos, isl_int *v);
1412         int isl_constraint_involves_dims(
1413                 __isl_keep isl_constraint *constraint,
1414                 enum isl_dim_type type, unsigned first, unsigned n);
1415
1416 The explicit representations of the existentially quantified
1417 variables can be inspected using the following function.
1418 Note that the user is only allowed to use this function
1419 if the inspected set or map is the result of a call
1420 to C<isl_set_compute_divs> or C<isl_map_compute_divs>.
1421 The existentially quantified variable is equal to the floor
1422 of the returned affine expression.  The affine expression
1423 itself can be inspected using the functions in
1424 L<"Piecewise Quasi Affine Expressions">.
1425
1426         __isl_give isl_aff *isl_constraint_get_div(
1427                 __isl_keep isl_constraint *constraint, int pos);
1428
1429 To obtain the constraints of a basic set or map in matrix
1430 form, use the following functions.
1431
1432         __isl_give isl_mat *isl_basic_set_equalities_matrix(
1433                 __isl_keep isl_basic_set *bset,
1434                 enum isl_dim_type c1, enum isl_dim_type c2,
1435                 enum isl_dim_type c3, enum isl_dim_type c4);
1436         __isl_give isl_mat *isl_basic_set_inequalities_matrix(
1437                 __isl_keep isl_basic_set *bset,
1438                 enum isl_dim_type c1, enum isl_dim_type c2,
1439                 enum isl_dim_type c3, enum isl_dim_type c4);
1440         __isl_give isl_mat *isl_basic_map_equalities_matrix(
1441                 __isl_keep isl_basic_map *bmap,
1442                 enum isl_dim_type c1,
1443                 enum isl_dim_type c2, enum isl_dim_type c3,
1444                 enum isl_dim_type c4, enum isl_dim_type c5);
1445         __isl_give isl_mat *isl_basic_map_inequalities_matrix(
1446                 __isl_keep isl_basic_map *bmap,
1447                 enum isl_dim_type c1,
1448                 enum isl_dim_type c2, enum isl_dim_type c3,
1449                 enum isl_dim_type c4, enum isl_dim_type c5);
1450
1451 The C<isl_dim_type> arguments dictate the order in which
1452 different kinds of variables appear in the resulting matrix
1453 and should be a permutation of C<isl_dim_cst>, C<isl_dim_param>,
1454 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div>.
1455
1456 The number of parameters, input, output or set dimensions can
1457 be obtained using the following functions.
1458
1459         unsigned isl_basic_set_dim(__isl_keep isl_basic_set *bset,
1460                 enum isl_dim_type type);
1461         unsigned isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
1462                 enum isl_dim_type type);
1463         unsigned isl_set_dim(__isl_keep isl_set *set,
1464                 enum isl_dim_type type);
1465         unsigned isl_map_dim(__isl_keep isl_map *map,
1466                 enum isl_dim_type type);
1467
1468 To check whether the description of a set or relation depends
1469 on one or more given dimensions, it is not necessary to iterate over all
1470 constraints.  Instead the following functions can be used.
1471
1472         int isl_basic_set_involves_dims(
1473                 __isl_keep isl_basic_set *bset,
1474                 enum isl_dim_type type, unsigned first, unsigned n);
1475         int isl_set_involves_dims(__isl_keep isl_set *set,
1476                 enum isl_dim_type type, unsigned first, unsigned n);
1477         int isl_basic_map_involves_dims(
1478                 __isl_keep isl_basic_map *bmap,
1479                 enum isl_dim_type type, unsigned first, unsigned n);
1480         int isl_map_involves_dims(__isl_keep isl_map *map,
1481                 enum isl_dim_type type, unsigned first, unsigned n);
1482
1483 Similarly, the following functions can be used to check whether
1484 a given dimension is involved in any lower or upper bound.
1485
1486         int isl_set_dim_has_lower_bound(__isl_keep isl_set *set,
1487                 enum isl_dim_type type, unsigned pos);
1488         int isl_set_dim_has_upper_bound(__isl_keep isl_set *set,
1489                 enum isl_dim_type type, unsigned pos);
1490
1491 The identifiers or names of the domain and range spaces of a set
1492 or relation can be read off or set using the following functions.
1493
1494         __isl_give isl_set *isl_set_set_tuple_id(
1495                 __isl_take isl_set *set, __isl_take isl_id *id);
1496         __isl_give isl_set *isl_set_reset_tuple_id(
1497                 __isl_take isl_set *set);
1498         int isl_set_has_tuple_id(__isl_keep isl_set *set);
1499         __isl_give isl_id *isl_set_get_tuple_id(
1500                 __isl_keep isl_set *set);
1501         __isl_give isl_map *isl_map_set_tuple_id(
1502                 __isl_take isl_map *map, enum isl_dim_type type,
1503                 __isl_take isl_id *id);
1504         __isl_give isl_map *isl_map_reset_tuple_id(
1505                 __isl_take isl_map *map, enum isl_dim_type type);
1506         int isl_map_has_tuple_id(__isl_keep isl_map *map,
1507                 enum isl_dim_type type);
1508         __isl_give isl_id *isl_map_get_tuple_id(
1509                 __isl_keep isl_map *map, enum isl_dim_type type);
1510
1511         const char *isl_basic_set_get_tuple_name(
1512                 __isl_keep isl_basic_set *bset);
1513         __isl_give isl_basic_set *isl_basic_set_set_tuple_name(
1514                 __isl_take isl_basic_set *set, const char *s);
1515         const char *isl_set_get_tuple_name(
1516                 __isl_keep isl_set *set);
1517         const char *isl_basic_map_get_tuple_name(
1518                 __isl_keep isl_basic_map *bmap,
1519                 enum isl_dim_type type);
1520         __isl_give isl_basic_map *isl_basic_map_set_tuple_name(
1521                 __isl_take isl_basic_map *bmap,
1522                 enum isl_dim_type type, const char *s);
1523         const char *isl_map_get_tuple_name(
1524                 __isl_keep isl_map *map,
1525                 enum isl_dim_type type);
1526
1527 As with C<isl_space_get_tuple_name>, the value returned points to
1528 an internal data structure.
1529 The identifiers, positions or names of individual dimensions can be
1530 read off using the following functions.
1531
1532         __isl_give isl_set *isl_set_set_dim_id(
1533                 __isl_take isl_set *set, enum isl_dim_type type,
1534                 unsigned pos, __isl_take isl_id *id);
1535         int isl_set_has_dim_id(__isl_keep isl_set *set,
1536                 enum isl_dim_type type, unsigned pos);
1537         __isl_give isl_id *isl_set_get_dim_id(
1538                 __isl_keep isl_set *set, enum isl_dim_type type,
1539                 unsigned pos);
1540         int isl_basic_map_has_dim_id(
1541                 __isl_keep isl_basic_map *bmap,
1542                 enum isl_dim_type type, unsigned pos);
1543         __isl_give isl_map *isl_map_set_dim_id(
1544                 __isl_take isl_map *map, enum isl_dim_type type,
1545                 unsigned pos, __isl_take isl_id *id);
1546         int isl_map_has_dim_id(__isl_keep isl_map *map,
1547                 enum isl_dim_type type, unsigned pos);
1548         __isl_give isl_id *isl_map_get_dim_id(
1549                 __isl_keep isl_map *map, enum isl_dim_type type,
1550                 unsigned pos);
1551
1552         int isl_set_find_dim_by_id(__isl_keep isl_set *set,
1553                 enum isl_dim_type type, __isl_keep isl_id *id);
1554         int isl_map_find_dim_by_id(__isl_keep isl_map *map,
1555                 enum isl_dim_type type, __isl_keep isl_id *id);
1556         int isl_set_find_dim_by_name(__isl_keep isl_set *set,
1557                 enum isl_dim_type type, const char *name);
1558         int isl_map_find_dim_by_name(__isl_keep isl_map *map,
1559                 enum isl_dim_type type, const char *name);
1560
1561         const char *isl_constraint_get_dim_name(
1562                 __isl_keep isl_constraint *constraint,
1563                 enum isl_dim_type type, unsigned pos);
1564         const char *isl_basic_set_get_dim_name(
1565                 __isl_keep isl_basic_set *bset,
1566                 enum isl_dim_type type, unsigned pos);
1567         const char *isl_set_get_dim_name(
1568                 __isl_keep isl_set *set,
1569                 enum isl_dim_type type, unsigned pos);
1570         const char *isl_basic_map_get_dim_name(
1571                 __isl_keep isl_basic_map *bmap,
1572                 enum isl_dim_type type, unsigned pos);
1573         const char *isl_map_get_dim_name(
1574                 __isl_keep isl_map *map,
1575                 enum isl_dim_type type, unsigned pos);
1576
1577 These functions are mostly useful to obtain the identifiers, positions
1578 or names of the parameters.  Identifiers of individual dimensions are
1579 essentially only useful for printing.  They are ignored by all other
1580 operations and may not be preserved across those operations.
1581
1582 =head2 Properties
1583
1584 =head3 Unary Properties
1585
1586 =over
1587
1588 =item * Emptiness
1589
1590 The following functions test whether the given set or relation
1591 contains any integer points.  The ``plain'' variants do not perform
1592 any computations, but simply check if the given set or relation
1593 is already known to be empty.
1594
1595         int isl_basic_set_plain_is_empty(__isl_keep isl_basic_set *bset);
1596         int isl_basic_set_is_empty(__isl_keep isl_basic_set *bset);
1597         int isl_set_plain_is_empty(__isl_keep isl_set *set);
1598         int isl_set_is_empty(__isl_keep isl_set *set);
1599         int isl_union_set_is_empty(__isl_keep isl_union_set *uset);
1600         int isl_basic_map_plain_is_empty(__isl_keep isl_basic_map *bmap);
1601         int isl_basic_map_is_empty(__isl_keep isl_basic_map *bmap);
1602         int isl_map_plain_is_empty(__isl_keep isl_map *map);
1603         int isl_map_is_empty(__isl_keep isl_map *map);
1604         int isl_union_map_is_empty(__isl_keep isl_union_map *umap);
1605
1606 =item * Universality
1607
1608         int isl_basic_set_is_universe(__isl_keep isl_basic_set *bset);
1609         int isl_basic_map_is_universe(__isl_keep isl_basic_map *bmap);
1610         int isl_set_plain_is_universe(__isl_keep isl_set *set);
1611
1612 =item * Single-valuedness
1613
1614         int isl_map_is_single_valued(__isl_keep isl_map *map);
1615         int isl_union_map_is_single_valued(__isl_keep isl_union_map *umap);
1616
1617 =item * Injectivity
1618
1619         int isl_map_plain_is_injective(__isl_keep isl_map *map);
1620         int isl_map_is_injective(__isl_keep isl_map *map);
1621         int isl_union_map_plain_is_injective(
1622                 __isl_keep isl_union_map *umap);
1623         int isl_union_map_is_injective(
1624                 __isl_keep isl_union_map *umap);
1625
1626 =item * Bijectivity
1627
1628         int isl_map_is_bijective(__isl_keep isl_map *map);
1629         int isl_union_map_is_bijective(__isl_keep isl_union_map *umap);
1630
1631 =item * Position
1632
1633         int isl_basic_map_plain_is_fixed(
1634                 __isl_keep isl_basic_map *bmap,
1635                 enum isl_dim_type type, unsigned pos,
1636                 isl_int *val);
1637         int isl_set_plain_is_fixed(__isl_keep isl_set *set,
1638                 enum isl_dim_type type, unsigned pos,
1639                 isl_int *val);
1640         int isl_map_plain_is_fixed(__isl_keep isl_map *map,
1641                 enum isl_dim_type type, unsigned pos,
1642                 isl_int *val);
1643
1644 Check if the relation obviously lies on a hyperplane where the given dimension
1645 has a fixed value and if so, return that value in C<*val>.
1646
1647 =item * Space
1648
1649 To check whether a set is a parameter domain, use this function:
1650
1651         int isl_set_is_params(__isl_keep isl_set *set);
1652         int isl_union_set_is_params(
1653                 __isl_keep isl_union_set *uset);
1654
1655 =item * Wrapping
1656
1657 The following functions check whether the domain of the given
1658 (basic) set is a wrapped relation.
1659
1660         int isl_basic_set_is_wrapping(
1661                 __isl_keep isl_basic_set *bset);
1662         int isl_set_is_wrapping(__isl_keep isl_set *set);
1663
1664 =item * Internal Product
1665
1666         int isl_basic_map_can_zip(
1667                 __isl_keep isl_basic_map *bmap);
1668         int isl_map_can_zip(__isl_keep isl_map *map);
1669
1670 Check whether the product of domain and range of the given relation
1671 can be computed,
1672 i.e., whether both domain and range are nested relations.
1673
1674 =back
1675
1676 =head3 Binary Properties
1677
1678 =over
1679
1680 =item * Equality
1681
1682         int isl_set_plain_is_equal(__isl_keep isl_set *set1,
1683                 __isl_keep isl_set *set2);
1684         int isl_set_is_equal(__isl_keep isl_set *set1,
1685                 __isl_keep isl_set *set2);
1686         int isl_union_set_is_equal(
1687                 __isl_keep isl_union_set *uset1,
1688                 __isl_keep isl_union_set *uset2);
1689         int isl_basic_map_is_equal(
1690                 __isl_keep isl_basic_map *bmap1,
1691                 __isl_keep isl_basic_map *bmap2);
1692         int isl_map_is_equal(__isl_keep isl_map *map1,
1693                 __isl_keep isl_map *map2);
1694         int isl_map_plain_is_equal(__isl_keep isl_map *map1,
1695                 __isl_keep isl_map *map2);
1696         int isl_union_map_is_equal(
1697                 __isl_keep isl_union_map *umap1,
1698                 __isl_keep isl_union_map *umap2);
1699
1700 =item * Disjointness
1701
1702         int isl_set_plain_is_disjoint(__isl_keep isl_set *set1,
1703                 __isl_keep isl_set *set2);
1704
1705 =item * Subset
1706
1707         int isl_set_is_subset(__isl_keep isl_set *set1,
1708                 __isl_keep isl_set *set2);
1709         int isl_set_is_strict_subset(
1710                 __isl_keep isl_set *set1,
1711                 __isl_keep isl_set *set2);
1712         int isl_union_set_is_subset(
1713                 __isl_keep isl_union_set *uset1,
1714                 __isl_keep isl_union_set *uset2);
1715         int isl_union_set_is_strict_subset(
1716                 __isl_keep isl_union_set *uset1,
1717                 __isl_keep isl_union_set *uset2);
1718         int isl_basic_map_is_subset(
1719                 __isl_keep isl_basic_map *bmap1,
1720                 __isl_keep isl_basic_map *bmap2);
1721         int isl_basic_map_is_strict_subset(
1722                 __isl_keep isl_basic_map *bmap1,
1723                 __isl_keep isl_basic_map *bmap2);
1724         int isl_map_is_subset(
1725                 __isl_keep isl_map *map1,
1726                 __isl_keep isl_map *map2);
1727         int isl_map_is_strict_subset(
1728                 __isl_keep isl_map *map1,
1729                 __isl_keep isl_map *map2);
1730         int isl_union_map_is_subset(
1731                 __isl_keep isl_union_map *umap1,
1732                 __isl_keep isl_union_map *umap2);
1733         int isl_union_map_is_strict_subset(
1734                 __isl_keep isl_union_map *umap1,
1735                 __isl_keep isl_union_map *umap2);
1736
1737 =back
1738
1739 =head2 Unary Operations
1740
1741 =over
1742
1743 =item * Complement
1744
1745         __isl_give isl_set *isl_set_complement(
1746                 __isl_take isl_set *set);
1747
1748 =item * Inverse map
1749
1750         __isl_give isl_basic_map *isl_basic_map_reverse(
1751                 __isl_take isl_basic_map *bmap);
1752         __isl_give isl_map *isl_map_reverse(
1753                 __isl_take isl_map *map);
1754         __isl_give isl_union_map *isl_union_map_reverse(
1755                 __isl_take isl_union_map *umap);
1756
1757 =item * Projection
1758
1759         __isl_give isl_basic_set *isl_basic_set_project_out(
1760                 __isl_take isl_basic_set *bset,
1761                 enum isl_dim_type type, unsigned first, unsigned n);
1762         __isl_give isl_basic_map *isl_basic_map_project_out(
1763                 __isl_take isl_basic_map *bmap,
1764                 enum isl_dim_type type, unsigned first, unsigned n);
1765         __isl_give isl_set *isl_set_project_out(__isl_take isl_set *set,
1766                 enum isl_dim_type type, unsigned first, unsigned n);
1767         __isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
1768                 enum isl_dim_type type, unsigned first, unsigned n);
1769         __isl_give isl_basic_set *isl_basic_set_params(
1770                 __isl_take isl_basic_set *bset);
1771         __isl_give isl_basic_set *isl_basic_map_domain(
1772                 __isl_take isl_basic_map *bmap);
1773         __isl_give isl_basic_set *isl_basic_map_range(
1774                 __isl_take isl_basic_map *bmap);
1775         __isl_give isl_set *isl_set_params(__isl_take isl_set *set);
1776         __isl_give isl_set *isl_map_params(__isl_take isl_map *map);
1777         __isl_give isl_set *isl_map_domain(
1778                 __isl_take isl_map *bmap);
1779         __isl_give isl_set *isl_map_range(
1780                 __isl_take isl_map *map);
1781         __isl_give isl_set *isl_union_set_params(
1782                 __isl_take isl_union_set *uset);
1783         __isl_give isl_set *isl_union_map_params(
1784                 __isl_take isl_union_map *umap);
1785         __isl_give isl_union_set *isl_union_map_domain(
1786                 __isl_take isl_union_map *umap);
1787         __isl_give isl_union_set *isl_union_map_range(
1788                 __isl_take isl_union_map *umap);
1789
1790         __isl_give isl_basic_map *isl_basic_map_domain_map(
1791                 __isl_take isl_basic_map *bmap);
1792         __isl_give isl_basic_map *isl_basic_map_range_map(
1793                 __isl_take isl_basic_map *bmap);
1794         __isl_give isl_map *isl_map_domain_map(__isl_take isl_map *map);
1795         __isl_give isl_map *isl_map_range_map(__isl_take isl_map *map);
1796         __isl_give isl_union_map *isl_union_map_domain_map(
1797                 __isl_take isl_union_map *umap);
1798         __isl_give isl_union_map *isl_union_map_range_map(
1799                 __isl_take isl_union_map *umap);
1800
1801 The functions above construct a (basic, regular or union) relation
1802 that maps (a wrapped version of) the input relation to its domain or range.
1803
1804 =item * Elimination
1805
1806         __isl_give isl_set *isl_set_eliminate(
1807                 __isl_take isl_set *set, enum isl_dim_type type,
1808                 unsigned first, unsigned n);
1809         __isl_give isl_basic_map *isl_basic_map_eliminate(
1810                 __isl_take isl_basic_map *bmap,
1811                 enum isl_dim_type type,
1812                 unsigned first, unsigned n);
1813         __isl_give isl_map *isl_map_eliminate(
1814                 __isl_take isl_map *map, enum isl_dim_type type,
1815                 unsigned first, unsigned n);
1816
1817 Eliminate the coefficients for the given dimensions from the constraints,
1818 without removing the dimensions.
1819
1820 =item * Slicing
1821
1822         __isl_give isl_basic_set *isl_basic_set_fix(
1823                 __isl_take isl_basic_set *bset,
1824                 enum isl_dim_type type, unsigned pos,
1825                 isl_int value);
1826         __isl_give isl_basic_set *isl_basic_set_fix_si(
1827                 __isl_take isl_basic_set *bset,
1828                 enum isl_dim_type type, unsigned pos, int value);
1829         __isl_give isl_set *isl_set_fix(__isl_take isl_set *set,
1830                 enum isl_dim_type type, unsigned pos,
1831                 isl_int value);
1832         __isl_give isl_set *isl_set_fix_si(__isl_take isl_set *set,
1833                 enum isl_dim_type type, unsigned pos, int value);
1834         __isl_give isl_basic_map *isl_basic_map_fix_si(
1835                 __isl_take isl_basic_map *bmap,
1836                 enum isl_dim_type type, unsigned pos, int value);
1837         __isl_give isl_map *isl_map_fix_si(__isl_take isl_map *map,
1838                 enum isl_dim_type type, unsigned pos, int value);
1839
1840 Intersect the set or relation with the hyperplane where the given
1841 dimension has the fixed given value.
1842
1843         __isl_give isl_basic_map *isl_basic_map_lower_bound_si(
1844                 __isl_take isl_basic_map *bmap,
1845                 enum isl_dim_type type, unsigned pos, int value);
1846         __isl_give isl_set *isl_set_lower_bound_si(
1847                 __isl_take isl_set *set,
1848                 enum isl_dim_type type, unsigned pos, int value);
1849         __isl_give isl_map *isl_map_lower_bound_si(
1850                 __isl_take isl_map *map,
1851                 enum isl_dim_type type, unsigned pos, int value);
1852         __isl_give isl_set *isl_set_upper_bound_si(
1853                 __isl_take isl_set *set,
1854                 enum isl_dim_type type, unsigned pos, int value);
1855         __isl_give isl_map *isl_map_upper_bound_si(
1856                 __isl_take isl_map *map,
1857                 enum isl_dim_type type, unsigned pos, int value);
1858
1859 Intersect the set or relation with the half-space where the given
1860 dimension has a value bounded the fixed given value.
1861
1862         __isl_give isl_set *isl_set_equate(__isl_take isl_set *set,
1863                 enum isl_dim_type type1, int pos1,
1864                 enum isl_dim_type type2, int pos2);
1865         __isl_give isl_map *isl_map_equate(__isl_take isl_map *map,
1866                 enum isl_dim_type type1, int pos1,
1867                 enum isl_dim_type type2, int pos2);
1868
1869 Intersect the set or relation with the hyperplane where the given
1870 dimensions are equal to each other.
1871
1872         __isl_give isl_map *isl_map_oppose(__isl_take isl_map *map,
1873                 enum isl_dim_type type1, int pos1,
1874                 enum isl_dim_type type2, int pos2);
1875
1876 Intersect the relation with the hyperplane where the given
1877 dimensions have opposite values.
1878
1879 =item * Identity
1880
1881         __isl_give isl_map *isl_set_identity(
1882                 __isl_take isl_set *set);
1883         __isl_give isl_union_map *isl_union_set_identity(
1884                 __isl_take isl_union_set *uset);
1885
1886 Construct an identity relation on the given (union) set.
1887
1888 =item * Deltas
1889
1890         __isl_give isl_basic_set *isl_basic_map_deltas(
1891                 __isl_take isl_basic_map *bmap);
1892         __isl_give isl_set *isl_map_deltas(__isl_take isl_map *map);
1893         __isl_give isl_union_set *isl_union_map_deltas(
1894                 __isl_take isl_union_map *umap);
1895
1896 These functions return a (basic) set containing the differences
1897 between image elements and corresponding domain elements in the input.
1898
1899         __isl_give isl_basic_map *isl_basic_map_deltas_map(
1900                 __isl_take isl_basic_map *bmap);
1901         __isl_give isl_map *isl_map_deltas_map(
1902                 __isl_take isl_map *map);
1903         __isl_give isl_union_map *isl_union_map_deltas_map(
1904                 __isl_take isl_union_map *umap);
1905
1906 The functions above construct a (basic, regular or union) relation
1907 that maps (a wrapped version of) the input relation to its delta set.
1908
1909 =item * Coalescing
1910
1911 Simplify the representation of a set or relation by trying
1912 to combine pairs of basic sets or relations into a single
1913 basic set or relation.
1914
1915         __isl_give isl_set *isl_set_coalesce(__isl_take isl_set *set);
1916         __isl_give isl_map *isl_map_coalesce(__isl_take isl_map *map);
1917         __isl_give isl_union_set *isl_union_set_coalesce(
1918                 __isl_take isl_union_set *uset);
1919         __isl_give isl_union_map *isl_union_map_coalesce(
1920                 __isl_take isl_union_map *umap);
1921
1922 =item * Detecting equalities
1923
1924         __isl_give isl_basic_set *isl_basic_set_detect_equalities(
1925                 __isl_take isl_basic_set *bset);
1926         __isl_give isl_basic_map *isl_basic_map_detect_equalities(
1927                 __isl_take isl_basic_map *bmap);
1928         __isl_give isl_set *isl_set_detect_equalities(
1929                 __isl_take isl_set *set);
1930         __isl_give isl_map *isl_map_detect_equalities(
1931                 __isl_take isl_map *map);
1932         __isl_give isl_union_set *isl_union_set_detect_equalities(
1933                 __isl_take isl_union_set *uset);
1934         __isl_give isl_union_map *isl_union_map_detect_equalities(
1935                 __isl_take isl_union_map *umap);
1936
1937 Simplify the representation of a set or relation by detecting implicit
1938 equalities.
1939
1940 =item * Removing redundant constraints
1941
1942         __isl_give isl_basic_set *isl_basic_set_remove_redundancies(
1943                 __isl_take isl_basic_set *bset);
1944         __isl_give isl_set *isl_set_remove_redundancies(
1945                 __isl_take isl_set *set);
1946         __isl_give isl_basic_map *isl_basic_map_remove_redundancies(
1947                 __isl_take isl_basic_map *bmap);
1948         __isl_give isl_map *isl_map_remove_redundancies(
1949                 __isl_take isl_map *map);
1950
1951 =item * Convex hull
1952
1953         __isl_give isl_basic_set *isl_set_convex_hull(
1954                 __isl_take isl_set *set);
1955         __isl_give isl_basic_map *isl_map_convex_hull(
1956                 __isl_take isl_map *map);
1957
1958 If the input set or relation has any existentially quantified
1959 variables, then the result of these operations is currently undefined.
1960
1961 =item * Simple hull
1962
1963         __isl_give isl_basic_set *isl_set_simple_hull(
1964                 __isl_take isl_set *set);
1965         __isl_give isl_basic_map *isl_map_simple_hull(
1966                 __isl_take isl_map *map);
1967         __isl_give isl_union_map *isl_union_map_simple_hull(
1968                 __isl_take isl_union_map *umap);
1969
1970 These functions compute a single basic set or relation
1971 that contains the whole input set or relation.
1972 In particular, the output is described by translates
1973 of the constraints describing the basic sets or relations in the input.
1974
1975 =begin latex
1976
1977 (See \autoref{s:simple hull}.)
1978
1979 =end latex
1980
1981 =item * Affine hull
1982
1983         __isl_give isl_basic_set *isl_basic_set_affine_hull(
1984                 __isl_take isl_basic_set *bset);
1985         __isl_give isl_basic_set *isl_set_affine_hull(
1986                 __isl_take isl_set *set);
1987         __isl_give isl_union_set *isl_union_set_affine_hull(
1988                 __isl_take isl_union_set *uset);
1989         __isl_give isl_basic_map *isl_basic_map_affine_hull(
1990                 __isl_take isl_basic_map *bmap);
1991         __isl_give isl_basic_map *isl_map_affine_hull(
1992                 __isl_take isl_map *map);
1993         __isl_give isl_union_map *isl_union_map_affine_hull(
1994                 __isl_take isl_union_map *umap);
1995
1996 In case of union sets and relations, the affine hull is computed
1997 per space.
1998
1999 =item * Polyhedral hull
2000
2001         __isl_give isl_basic_set *isl_set_polyhedral_hull(
2002                 __isl_take isl_set *set);
2003         __isl_give isl_basic_map *isl_map_polyhedral_hull(
2004                 __isl_take isl_map *map);
2005         __isl_give isl_union_set *isl_union_set_polyhedral_hull(
2006                 __isl_take isl_union_set *uset);
2007         __isl_give isl_union_map *isl_union_map_polyhedral_hull(
2008                 __isl_take isl_union_map *umap);
2009
2010 These functions compute a single basic set or relation
2011 not involving any existentially quantified variables
2012 that contains the whole input set or relation.
2013 In case of union sets and relations, the polyhedral hull is computed
2014 per space.
2015
2016 =item * Optimization
2017
2018         #include <isl/ilp.h>
2019         enum isl_lp_result isl_basic_set_max(
2020                 __isl_keep isl_basic_set *bset,
2021                 __isl_keep isl_aff *obj, isl_int *opt)
2022         enum isl_lp_result isl_set_min(__isl_keep isl_set *set,
2023                 __isl_keep isl_aff *obj, isl_int *opt);
2024         enum isl_lp_result isl_set_max(__isl_keep isl_set *set,
2025                 __isl_keep isl_aff *obj, isl_int *opt);
2026
2027 Compute the minimum or maximum of the integer affine expression C<obj>
2028 over the points in C<set>, returning the result in C<opt>.
2029 The return value may be one of C<isl_lp_error>,
2030 C<isl_lp_ok>, C<isl_lp_unbounded> or C<isl_lp_empty>.
2031
2032 =item * Parametric optimization
2033
2034         __isl_give isl_pw_aff *isl_set_dim_min(
2035                 __isl_take isl_set *set, int pos);
2036         __isl_give isl_pw_aff *isl_set_dim_max(
2037                 __isl_take isl_set *set, int pos);
2038         __isl_give isl_pw_aff *isl_map_dim_max(
2039                 __isl_take isl_map *map, int pos);
2040
2041 Compute the minimum or maximum of the given set or output dimension
2042 as a function of the parameters (and input dimensions), but independently
2043 of the other set or output dimensions.
2044 For lexicographic optimization, see L<"Lexicographic Optimization">.
2045
2046 =item * Dual
2047
2048 The following functions compute either the set of (rational) coefficient
2049 values of valid constraints for the given set or the set of (rational)
2050 values satisfying the constraints with coefficients from the given set.
2051 Internally, these two sets of functions perform essentially the
2052 same operations, except that the set of coefficients is assumed to
2053 be a cone, while the set of values may be any polyhedron.
2054 The current implementation is based on the Farkas lemma and
2055 Fourier-Motzkin elimination, but this may change or be made optional
2056 in future.  In particular, future implementations may use different
2057 dualization algorithms or skip the elimination step.
2058
2059         __isl_give isl_basic_set *isl_basic_set_coefficients(
2060                 __isl_take isl_basic_set *bset);
2061         __isl_give isl_basic_set *isl_set_coefficients(
2062                 __isl_take isl_set *set);
2063         __isl_give isl_union_set *isl_union_set_coefficients(
2064                 __isl_take isl_union_set *bset);
2065         __isl_give isl_basic_set *isl_basic_set_solutions(
2066                 __isl_take isl_basic_set *bset);
2067         __isl_give isl_basic_set *isl_set_solutions(
2068                 __isl_take isl_set *set);
2069         __isl_give isl_union_set *isl_union_set_solutions(
2070                 __isl_take isl_union_set *bset);
2071
2072 =item * Power
2073
2074         __isl_give isl_map *isl_map_power(__isl_take isl_map *map,
2075                 int *exact);
2076         __isl_give isl_union_map *isl_union_map_power(
2077                 __isl_take isl_union_map *umap, int *exact);
2078
2079 Compute a parametric representation for all positive powers I<k> of C<map>.
2080 The result maps I<k> to a nested relation corresponding to the
2081 I<k>th power of C<map>.
2082 The result may be an overapproximation.  If the result is known to be exact,
2083 then C<*exact> is set to C<1>.
2084
2085 =item * Transitive closure
2086
2087         __isl_give isl_map *isl_map_transitive_closure(
2088                 __isl_take isl_map *map, int *exact);
2089         __isl_give isl_union_map *isl_union_map_transitive_closure(
2090                 __isl_take isl_union_map *umap, int *exact);
2091
2092 Compute the transitive closure of C<map>.
2093 The result may be an overapproximation.  If the result is known to be exact,
2094 then C<*exact> is set to C<1>.
2095
2096 =item * Reaching path lengths
2097
2098         __isl_give isl_map *isl_map_reaching_path_lengths(
2099                 __isl_take isl_map *map, int *exact);
2100
2101 Compute a relation that maps each element in the range of C<map>
2102 to the lengths of all paths composed of edges in C<map> that
2103 end up in the given element.
2104 The result may be an overapproximation.  If the result is known to be exact,
2105 then C<*exact> is set to C<1>.
2106 To compute the I<maximal> path length, the resulting relation
2107 should be postprocessed by C<isl_map_lexmax>.
2108 In particular, if the input relation is a dependence relation
2109 (mapping sources to sinks), then the maximal path length corresponds
2110 to the free schedule.
2111 Note, however, that C<isl_map_lexmax> expects the maximum to be
2112 finite, so if the path lengths are unbounded (possibly due to
2113 the overapproximation), then you will get an error message.
2114
2115 =item * Wrapping
2116
2117         __isl_give isl_basic_set *isl_basic_map_wrap(
2118                 __isl_take isl_basic_map *bmap);
2119         __isl_give isl_set *isl_map_wrap(
2120                 __isl_take isl_map *map);
2121         __isl_give isl_union_set *isl_union_map_wrap(
2122                 __isl_take isl_union_map *umap);
2123         __isl_give isl_basic_map *isl_basic_set_unwrap(
2124                 __isl_take isl_basic_set *bset);
2125         __isl_give isl_map *isl_set_unwrap(
2126                 __isl_take isl_set *set);
2127         __isl_give isl_union_map *isl_union_set_unwrap(
2128                 __isl_take isl_union_set *uset);
2129
2130 =item * Flattening
2131
2132 Remove any internal structure of domain (and range) of the given
2133 set or relation.  If there is any such internal structure in the input,
2134 then the name of the space is also removed.
2135
2136         __isl_give isl_basic_set *isl_basic_set_flatten(
2137                 __isl_take isl_basic_set *bset);
2138         __isl_give isl_set *isl_set_flatten(
2139                 __isl_take isl_set *set);
2140         __isl_give isl_basic_map *isl_basic_map_flatten_domain(
2141                 __isl_take isl_basic_map *bmap);
2142         __isl_give isl_basic_map *isl_basic_map_flatten_range(
2143                 __isl_take isl_basic_map *bmap);
2144         __isl_give isl_map *isl_map_flatten_range(
2145                 __isl_take isl_map *map);
2146         __isl_give isl_map *isl_map_flatten_domain(
2147                 __isl_take isl_map *map);
2148         __isl_give isl_basic_map *isl_basic_map_flatten(
2149                 __isl_take isl_basic_map *bmap);
2150         __isl_give isl_map *isl_map_flatten(
2151                 __isl_take isl_map *map);
2152
2153         __isl_give isl_map *isl_set_flatten_map(
2154                 __isl_take isl_set *set);
2155
2156 The function above constructs a relation
2157 that maps the input set to a flattened version of the set.
2158
2159 =item * Lifting
2160
2161 Lift the input set to a space with extra dimensions corresponding
2162 to the existentially quantified variables in the input.
2163 In particular, the result lives in a wrapped map where the domain
2164 is the original space and the range corresponds to the original
2165 existentially quantified variables.
2166
2167         __isl_give isl_basic_set *isl_basic_set_lift(
2168                 __isl_take isl_basic_set *bset);
2169         __isl_give isl_set *isl_set_lift(
2170                 __isl_take isl_set *set);
2171         __isl_give isl_union_set *isl_union_set_lift(
2172                 __isl_take isl_union_set *uset);
2173
2174 Given a local space that contains the existentially quantified
2175 variables of a set, a basic relation that, when applied to
2176 a basic set, has essentially the same effect as C<isl_basic_set_lift>,
2177 can be constructed using the following function.
2178
2179         #include <isl/local_space.h>
2180         __isl_give isl_basic_map *isl_local_space_lifting(
2181                 __isl_take isl_local_space *ls);
2182
2183 =item * Internal Product
2184
2185         __isl_give isl_basic_map *isl_basic_map_zip(
2186                 __isl_take isl_basic_map *bmap);
2187         __isl_give isl_map *isl_map_zip(
2188                 __isl_take isl_map *map);
2189         __isl_give isl_union_map *isl_union_map_zip(
2190                 __isl_take isl_union_map *umap);
2191
2192 Given a relation with nested relations for domain and range,
2193 interchange the range of the domain with the domain of the range.
2194
2195 =item * Aligning parameters
2196
2197         __isl_give isl_set *isl_set_align_params(
2198                 __isl_take isl_set *set,
2199                 __isl_take isl_space *model);
2200         __isl_give isl_map *isl_map_align_params(
2201                 __isl_take isl_map *map,
2202                 __isl_take isl_space *model);
2203
2204 Change the order of the parameters of the given set or relation
2205 such that the first parameters match those of C<model>.
2206 This may involve the introduction of extra parameters.
2207 All parameters need to be named.
2208
2209 =item * Dimension manipulation
2210
2211         __isl_give isl_set *isl_set_add_dims(
2212                 __isl_take isl_set *set,
2213                 enum isl_dim_type type, unsigned n);
2214         __isl_give isl_map *isl_map_add_dims(
2215                 __isl_take isl_map *map,
2216                 enum isl_dim_type type, unsigned n);
2217         __isl_give isl_set *isl_set_insert_dims(
2218                 __isl_take isl_set *set,
2219                 enum isl_dim_type type, unsigned pos, unsigned n);
2220         __isl_give isl_map *isl_map_insert_dims(
2221                 __isl_take isl_map *map,
2222                 enum isl_dim_type type, unsigned pos, unsigned n);
2223         __isl_give isl_basic_set *isl_basic_set_move_dims(
2224                 __isl_take isl_basic_set *bset,
2225                 enum isl_dim_type dst_type, unsigned dst_pos,
2226                 enum isl_dim_type src_type, unsigned src_pos,
2227                 unsigned n);
2228         __isl_give isl_basic_map *isl_basic_map_move_dims(
2229                 __isl_take isl_basic_map *bmap,
2230                 enum isl_dim_type dst_type, unsigned dst_pos,
2231                 enum isl_dim_type src_type, unsigned src_pos,
2232                 unsigned n);
2233         __isl_give isl_set *isl_set_move_dims(
2234                 __isl_take isl_set *set,
2235                 enum isl_dim_type dst_type, unsigned dst_pos,
2236                 enum isl_dim_type src_type, unsigned src_pos,
2237                 unsigned n);
2238         __isl_give isl_map *isl_map_move_dims(
2239                 __isl_take isl_map *map,
2240                 enum isl_dim_type dst_type, unsigned dst_pos,
2241                 enum isl_dim_type src_type, unsigned src_pos,
2242                 unsigned n);
2243
2244 It is usually not advisable to directly change the (input or output)
2245 space of a set or a relation as this removes the name and the internal
2246 structure of the space.  However, the above functions can be useful
2247 to add new parameters, assuming
2248 C<isl_set_align_params> and C<isl_map_align_params>
2249 are not sufficient.
2250
2251 =back
2252
2253 =head2 Binary Operations
2254
2255 The two arguments of a binary operation not only need to live
2256 in the same C<isl_ctx>, they currently also need to have
2257 the same (number of) parameters.
2258
2259 =head3 Basic Operations
2260
2261 =over
2262
2263 =item * Intersection
2264
2265         __isl_give isl_basic_set *isl_basic_set_intersect_params(
2266                 __isl_take isl_basic_set *bset1,
2267                 __isl_take isl_basic_set *bset2);
2268         __isl_give isl_basic_set *isl_basic_set_intersect(
2269                 __isl_take isl_basic_set *bset1,
2270                 __isl_take isl_basic_set *bset2);
2271         __isl_give isl_set *isl_set_intersect_params(
2272                 __isl_take isl_set *set,
2273                 __isl_take isl_set *params);
2274         __isl_give isl_set *isl_set_intersect(
2275                 __isl_take isl_set *set1,
2276                 __isl_take isl_set *set2);
2277         __isl_give isl_union_set *isl_union_set_intersect_params(
2278                 __isl_take isl_union_set *uset,
2279                 __isl_take isl_set *set);
2280         __isl_give isl_union_map *isl_union_map_intersect_params(
2281                 __isl_take isl_union_map *umap,
2282                 __isl_take isl_set *set);
2283         __isl_give isl_union_set *isl_union_set_intersect(
2284                 __isl_take isl_union_set *uset1,
2285                 __isl_take isl_union_set *uset2);
2286         __isl_give isl_basic_map *isl_basic_map_intersect_domain(
2287                 __isl_take isl_basic_map *bmap,
2288                 __isl_take isl_basic_set *bset);
2289         __isl_give isl_basic_map *isl_basic_map_intersect_range(
2290                 __isl_take isl_basic_map *bmap,
2291                 __isl_take isl_basic_set *bset);
2292         __isl_give isl_basic_map *isl_basic_map_intersect(
2293                 __isl_take isl_basic_map *bmap1,
2294                 __isl_take isl_basic_map *bmap2);
2295         __isl_give isl_map *isl_map_intersect_params(
2296                 __isl_take isl_map *map,
2297                 __isl_take isl_set *params);
2298         __isl_give isl_map *isl_map_intersect_domain(
2299                 __isl_take isl_map *map,
2300                 __isl_take isl_set *set);
2301         __isl_give isl_map *isl_map_intersect_range(
2302                 __isl_take isl_map *map,
2303                 __isl_take isl_set *set);
2304         __isl_give isl_map *isl_map_intersect(
2305                 __isl_take isl_map *map1,
2306                 __isl_take isl_map *map2);
2307         __isl_give isl_union_map *isl_union_map_intersect_domain(
2308                 __isl_take isl_union_map *umap,
2309                 __isl_take isl_union_set *uset);
2310         __isl_give isl_union_map *isl_union_map_intersect_range(
2311                 __isl_take isl_union_map *umap,
2312                 __isl_take isl_union_set *uset);
2313         __isl_give isl_union_map *isl_union_map_intersect(
2314                 __isl_take isl_union_map *umap1,
2315                 __isl_take isl_union_map *umap2);
2316
2317 =item * Union
2318
2319         __isl_give isl_set *isl_basic_set_union(
2320                 __isl_take isl_basic_set *bset1,
2321                 __isl_take isl_basic_set *bset2);
2322         __isl_give isl_map *isl_basic_map_union(
2323                 __isl_take isl_basic_map *bmap1,
2324                 __isl_take isl_basic_map *bmap2);
2325         __isl_give isl_set *isl_set_union(
2326                 __isl_take isl_set *set1,
2327                 __isl_take isl_set *set2);
2328         __isl_give isl_map *isl_map_union(
2329                 __isl_take isl_map *map1,
2330                 __isl_take isl_map *map2);
2331         __isl_give isl_union_set *isl_union_set_union(
2332                 __isl_take isl_union_set *uset1,
2333                 __isl_take isl_union_set *uset2);
2334         __isl_give isl_union_map *isl_union_map_union(
2335                 __isl_take isl_union_map *umap1,
2336                 __isl_take isl_union_map *umap2);
2337
2338 =item * Set difference
2339
2340         __isl_give isl_set *isl_set_subtract(
2341                 __isl_take isl_set *set1,
2342                 __isl_take isl_set *set2);
2343         __isl_give isl_map *isl_map_subtract(
2344                 __isl_take isl_map *map1,
2345                 __isl_take isl_map *map2);
2346         __isl_give isl_map *isl_map_subtract_domain(
2347                 __isl_take isl_map *map,
2348                 __isl_take isl_set *dom);
2349         __isl_give isl_map *isl_map_subtract_range(
2350                 __isl_take isl_map *map,
2351                 __isl_take isl_set *dom);
2352         __isl_give isl_union_set *isl_union_set_subtract(
2353                 __isl_take isl_union_set *uset1,
2354                 __isl_take isl_union_set *uset2);
2355         __isl_give isl_union_map *isl_union_map_subtract(
2356                 __isl_take isl_union_map *umap1,
2357                 __isl_take isl_union_map *umap2);
2358
2359 =item * Application
2360
2361         __isl_give isl_basic_set *isl_basic_set_apply(
2362                 __isl_take isl_basic_set *bset,
2363                 __isl_take isl_basic_map *bmap);
2364         __isl_give isl_set *isl_set_apply(
2365                 __isl_take isl_set *set,
2366                 __isl_take isl_map *map);
2367         __isl_give isl_union_set *isl_union_set_apply(
2368                 __isl_take isl_union_set *uset,
2369                 __isl_take isl_union_map *umap);
2370         __isl_give isl_basic_map *isl_basic_map_apply_domain(
2371                 __isl_take isl_basic_map *bmap1,
2372                 __isl_take isl_basic_map *bmap2);
2373         __isl_give isl_basic_map *isl_basic_map_apply_range(
2374                 __isl_take isl_basic_map *bmap1,
2375                 __isl_take isl_basic_map *bmap2);
2376         __isl_give isl_map *isl_map_apply_domain(
2377                 __isl_take isl_map *map1,
2378                 __isl_take isl_map *map2);
2379         __isl_give isl_union_map *isl_union_map_apply_domain(
2380                 __isl_take isl_union_map *umap1,
2381                 __isl_take isl_union_map *umap2);
2382         __isl_give isl_map *isl_map_apply_range(
2383                 __isl_take isl_map *map1,
2384                 __isl_take isl_map *map2);
2385         __isl_give isl_union_map *isl_union_map_apply_range(
2386                 __isl_take isl_union_map *umap1,
2387                 __isl_take isl_union_map *umap2);
2388
2389 =item * Cartesian Product
2390
2391         __isl_give isl_set *isl_set_product(
2392                 __isl_take isl_set *set1,
2393                 __isl_take isl_set *set2);
2394         __isl_give isl_union_set *isl_union_set_product(
2395                 __isl_take isl_union_set *uset1,
2396                 __isl_take isl_union_set *uset2);
2397         __isl_give isl_basic_map *isl_basic_map_domain_product(
2398                 __isl_take isl_basic_map *bmap1,
2399                 __isl_take isl_basic_map *bmap2);
2400         __isl_give isl_basic_map *isl_basic_map_range_product(
2401                 __isl_take isl_basic_map *bmap1,
2402                 __isl_take isl_basic_map *bmap2);
2403         __isl_give isl_map *isl_map_domain_product(
2404                 __isl_take isl_map *map1,
2405                 __isl_take isl_map *map2);
2406         __isl_give isl_map *isl_map_range_product(
2407                 __isl_take isl_map *map1,
2408                 __isl_take isl_map *map2);
2409         __isl_give isl_union_map *isl_union_map_range_product(
2410                 __isl_take isl_union_map *umap1,
2411                 __isl_take isl_union_map *umap2);
2412         __isl_give isl_map *isl_map_product(
2413                 __isl_take isl_map *map1,
2414                 __isl_take isl_map *map2);
2415         __isl_give isl_union_map *isl_union_map_product(
2416                 __isl_take isl_union_map *umap1,
2417                 __isl_take isl_union_map *umap2);
2418
2419 The above functions compute the cross product of the given
2420 sets or relations.  The domains and ranges of the results
2421 are wrapped maps between domains and ranges of the inputs.
2422 To obtain a ``flat'' product, use the following functions
2423 instead.
2424
2425         __isl_give isl_basic_set *isl_basic_set_flat_product(
2426                 __isl_take isl_basic_set *bset1,
2427                 __isl_take isl_basic_set *bset2);
2428         __isl_give isl_set *isl_set_flat_product(
2429                 __isl_take isl_set *set1,
2430                 __isl_take isl_set *set2);
2431         __isl_give isl_basic_map *isl_basic_map_flat_range_product(
2432                 __isl_take isl_basic_map *bmap1,
2433                 __isl_take isl_basic_map *bmap2);
2434         __isl_give isl_map *isl_map_flat_domain_product(
2435                 __isl_take isl_map *map1,
2436                 __isl_take isl_map *map2);
2437         __isl_give isl_map *isl_map_flat_range_product(
2438                 __isl_take isl_map *map1,
2439                 __isl_take isl_map *map2);
2440         __isl_give isl_union_map *isl_union_map_flat_range_product(
2441                 __isl_take isl_union_map *umap1,
2442                 __isl_take isl_union_map *umap2);
2443         __isl_give isl_basic_map *isl_basic_map_flat_product(
2444                 __isl_take isl_basic_map *bmap1,
2445                 __isl_take isl_basic_map *bmap2);
2446         __isl_give isl_map *isl_map_flat_product(
2447                 __isl_take isl_map *map1,
2448                 __isl_take isl_map *map2);
2449
2450 =item * Simplification
2451
2452         __isl_give isl_basic_set *isl_basic_set_gist(
2453                 __isl_take isl_basic_set *bset,
2454                 __isl_take isl_basic_set *context);
2455         __isl_give isl_set *isl_set_gist(__isl_take isl_set *set,
2456                 __isl_take isl_set *context);
2457         __isl_give isl_set *isl_set_gist_params(
2458                 __isl_take isl_set *set,
2459                 __isl_take isl_set *context);
2460         __isl_give isl_union_set *isl_union_set_gist(
2461                 __isl_take isl_union_set *uset,
2462                 __isl_take isl_union_set *context);
2463         __isl_give isl_union_set *isl_union_set_gist_params(
2464                 __isl_take isl_union_set *uset,
2465                 __isl_take isl_set *set);
2466         __isl_give isl_basic_map *isl_basic_map_gist(
2467                 __isl_take isl_basic_map *bmap,
2468                 __isl_take isl_basic_map *context);
2469         __isl_give isl_map *isl_map_gist(__isl_take isl_map *map,
2470                 __isl_take isl_map *context);
2471         __isl_give isl_map *isl_map_gist_params(
2472                 __isl_take isl_map *map,
2473                 __isl_take isl_set *context);
2474         __isl_give isl_map *isl_map_gist_domain(
2475                 __isl_take isl_map *map,
2476                 __isl_take isl_set *context);
2477         __isl_give isl_map *isl_map_gist_range(
2478                 __isl_take isl_map *map,
2479                 __isl_take isl_set *context);
2480         __isl_give isl_union_map *isl_union_map_gist(
2481                 __isl_take isl_union_map *umap,
2482                 __isl_take isl_union_map *context);
2483         __isl_give isl_union_map *isl_union_map_gist_params(
2484                 __isl_take isl_union_map *umap,
2485                 __isl_take isl_set *set);
2486         __isl_give isl_union_map *isl_union_map_gist_domain(
2487                 __isl_take isl_union_map *umap,
2488                 __isl_take isl_union_set *uset);
2489
2490 The gist operation returns a set or relation that has the
2491 same intersection with the context as the input set or relation.
2492 Any implicit equality in the intersection is made explicit in the result,
2493 while all inequalities that are redundant with respect to the intersection
2494 are removed.
2495 In case of union sets and relations, the gist operation is performed
2496 per space.
2497
2498 =back
2499
2500 =head3 Lexicographic Optimization
2501
2502 Given a (basic) set C<set> (or C<bset>) and a zero-dimensional domain C<dom>,
2503 the following functions
2504 compute a set that contains the lexicographic minimum or maximum
2505 of the elements in C<set> (or C<bset>) for those values of the parameters
2506 that satisfy C<dom>.
2507 If C<empty> is not C<NULL>, then C<*empty> is assigned a set
2508 that contains the parameter values in C<dom> for which C<set> (or C<bset>)
2509 has no elements.
2510 In other words, the union of the parameter values
2511 for which the result is non-empty and of C<*empty>
2512 is equal to C<dom>.
2513
2514         __isl_give isl_set *isl_basic_set_partial_lexmin(
2515                 __isl_take isl_basic_set *bset,
2516                 __isl_take isl_basic_set *dom,
2517                 __isl_give isl_set **empty);
2518         __isl_give isl_set *isl_basic_set_partial_lexmax(
2519                 __isl_take isl_basic_set *bset,
2520                 __isl_take isl_basic_set *dom,
2521                 __isl_give isl_set **empty);
2522         __isl_give isl_set *isl_set_partial_lexmin(
2523                 __isl_take isl_set *set, __isl_take isl_set *dom,
2524                 __isl_give isl_set **empty);
2525         __isl_give isl_set *isl_set_partial_lexmax(
2526                 __isl_take isl_set *set, __isl_take isl_set *dom,
2527                 __isl_give isl_set **empty);
2528
2529 Given a (basic) set C<set> (or C<bset>), the following functions simply
2530 return a set containing the lexicographic minimum or maximum
2531 of the elements in C<set> (or C<bset>).
2532 In case of union sets, the optimum is computed per space.
2533
2534         __isl_give isl_set *isl_basic_set_lexmin(
2535                 __isl_take isl_basic_set *bset);
2536         __isl_give isl_set *isl_basic_set_lexmax(
2537                 __isl_take isl_basic_set *bset);
2538         __isl_give isl_set *isl_set_lexmin(
2539                 __isl_take isl_set *set);
2540         __isl_give isl_set *isl_set_lexmax(
2541                 __isl_take isl_set *set);
2542         __isl_give isl_union_set *isl_union_set_lexmin(
2543                 __isl_take isl_union_set *uset);
2544         __isl_give isl_union_set *isl_union_set_lexmax(
2545                 __isl_take isl_union_set *uset);
2546
2547 Given a (basic) relation C<map> (or C<bmap>) and a domain C<dom>,
2548 the following functions
2549 compute a relation that maps each element of C<dom>
2550 to the single lexicographic minimum or maximum
2551 of the elements that are associated to that same
2552 element in C<map> (or C<bmap>).
2553 If C<empty> is not C<NULL>, then C<*empty> is assigned a set
2554 that contains the elements in C<dom> that do not map
2555 to any elements in C<map> (or C<bmap>).
2556 In other words, the union of the domain of the result and of C<*empty>
2557 is equal to C<dom>.
2558
2559         __isl_give isl_map *isl_basic_map_partial_lexmax(
2560                 __isl_take isl_basic_map *bmap,
2561                 __isl_take isl_basic_set *dom,
2562                 __isl_give isl_set **empty);
2563         __isl_give isl_map *isl_basic_map_partial_lexmin(
2564                 __isl_take isl_basic_map *bmap,
2565                 __isl_take isl_basic_set *dom,
2566                 __isl_give isl_set **empty);
2567         __isl_give isl_map *isl_map_partial_lexmax(
2568                 __isl_take isl_map *map, __isl_take isl_set *dom,
2569                 __isl_give isl_set **empty);
2570         __isl_give isl_map *isl_map_partial_lexmin(
2571                 __isl_take isl_map *map, __isl_take isl_set *dom,
2572                 __isl_give isl_set **empty);
2573
2574 Given a (basic) map C<map> (or C<bmap>), the following functions simply
2575 return a map mapping each element in the domain of
2576 C<map> (or C<bmap>) to the lexicographic minimum or maximum
2577 of all elements associated to that element.
2578 In case of union relations, the optimum is computed per space.
2579
2580         __isl_give isl_map *isl_basic_map_lexmin(
2581                 __isl_take isl_basic_map *bmap);
2582         __isl_give isl_map *isl_basic_map_lexmax(
2583                 __isl_take isl_basic_map *bmap);
2584         __isl_give isl_map *isl_map_lexmin(
2585                 __isl_take isl_map *map);
2586         __isl_give isl_map *isl_map_lexmax(
2587                 __isl_take isl_map *map);
2588         __isl_give isl_union_map *isl_union_map_lexmin(
2589                 __isl_take isl_union_map *umap);
2590         __isl_give isl_union_map *isl_union_map_lexmax(
2591                 __isl_take isl_union_map *umap);
2592
2593 The following functions return their result in the form of
2594 a piecewise multi-affine expression
2595 (See L<"Piecewise Multiple Quasi Affine Expressions">),
2596 but are otherwise equivalent to the corresponding functions
2597 returning a basic set or relation.
2598
2599         __isl_give isl_pw_multi_aff *
2600         isl_basic_map_lexmin_pw_multi_aff(
2601                 __isl_take isl_basic_map *bmap);
2602         __isl_give isl_pw_multi_aff *
2603         isl_basic_set_partial_lexmin_pw_multi_aff(
2604                 __isl_take isl_basic_set *bset,
2605                 __isl_take isl_basic_set *dom,
2606                 __isl_give isl_set **empty);
2607         __isl_give isl_pw_multi_aff *
2608         isl_basic_set_partial_lexmax_pw_multi_aff(
2609                 __isl_take isl_basic_set *bset,
2610                 __isl_take isl_basic_set *dom,
2611                 __isl_give isl_set **empty);
2612         __isl_give isl_pw_multi_aff *
2613         isl_basic_map_partial_lexmin_pw_multi_aff(
2614                 __isl_take isl_basic_map *bmap,
2615                 __isl_take isl_basic_set *dom,
2616                 __isl_give isl_set **empty);
2617         __isl_give isl_pw_multi_aff *
2618         isl_basic_map_partial_lexmax_pw_multi_aff(
2619                 __isl_take isl_basic_map *bmap,
2620                 __isl_take isl_basic_set *dom,
2621                 __isl_give isl_set **empty);
2622
2623 =head2 Lists
2624
2625 Lists are defined over several element types, including
2626 C<isl_aff>, C<isl_pw_aff>, C<isl_basic_set> and C<isl_set>.
2627 Here we take lists of C<isl_set>s as an example.
2628 Lists can be created, copied and freed using the following functions.
2629
2630         #include <isl/list.h>
2631         __isl_give isl_set_list *isl_set_list_from_set(
2632                 __isl_take isl_set *el);
2633         __isl_give isl_set_list *isl_set_list_alloc(
2634                 isl_ctx *ctx, int n);
2635         __isl_give isl_set_list *isl_set_list_copy(
2636                 __isl_keep isl_set_list *list);
2637         __isl_give isl_set_list *isl_set_list_add(
2638                 __isl_take isl_set_list *list,
2639                 __isl_take isl_set *el);
2640         __isl_give isl_set_list *isl_set_list_concat(
2641                 __isl_take isl_set_list *list1,
2642                 __isl_take isl_set_list *list2);
2643         void *isl_set_list_free(__isl_take isl_set_list *list);
2644
2645 C<isl_set_list_alloc> creates an empty list with a capacity for
2646 C<n> elements.  C<isl_set_list_from_set> creates a list with a single
2647 element.
2648
2649 Lists can be inspected using the following functions.
2650
2651         #include <isl/list.h>
2652         isl_ctx *isl_set_list_get_ctx(__isl_keep isl_set_list *list);
2653         int isl_set_list_n_set(__isl_keep isl_set_list *list);
2654         __isl_give isl_set *isl_set_list_get_set(
2655                 __isl_keep isl_set_list *list, int index);
2656         int isl_set_list_foreach(__isl_keep isl_set_list *list,
2657                 int (*fn)(__isl_take isl_set *el, void *user),
2658                 void *user);
2659
2660 Lists can be printed using
2661
2662         #include <isl/list.h>
2663         __isl_give isl_printer *isl_printer_print_set_list(
2664                 __isl_take isl_printer *p,
2665                 __isl_keep isl_set_list *list);
2666
2667 =head2 Matrices
2668
2669 Matrices can be created, copied and freed using the following functions.
2670
2671         #include <isl/mat.h>
2672         __isl_give isl_mat *isl_mat_alloc(isl_ctx *ctx,
2673                 unsigned n_row, unsigned n_col);
2674         __isl_give isl_mat *isl_mat_copy(__isl_keep isl_mat *mat);
2675         void isl_mat_free(__isl_take isl_mat *mat);
2676
2677 Note that the elements of a newly created matrix may have arbitrary values.
2678 The elements can be changed and inspected using the following functions.
2679
2680         isl_ctx *isl_mat_get_ctx(__isl_keep isl_mat *mat);
2681         int isl_mat_rows(__isl_keep isl_mat *mat);
2682         int isl_mat_cols(__isl_keep isl_mat *mat);
2683         int isl_mat_get_element(__isl_keep isl_mat *mat,
2684                 int row, int col, isl_int *v);
2685         __isl_give isl_mat *isl_mat_set_element(__isl_take isl_mat *mat,
2686                 int row, int col, isl_int v);
2687         __isl_give isl_mat *isl_mat_set_element_si(__isl_take isl_mat *mat,
2688                 int row, int col, int v);
2689
2690 C<isl_mat_get_element> will return a negative value if anything went wrong.
2691 In that case, the value of C<*v> is undefined.
2692
2693 The following function can be used to compute the (right) inverse
2694 of a matrix, i.e., a matrix such that the product of the original
2695 and the inverse (in that order) is a multiple of the identity matrix.
2696 The input matrix is assumed to be of full row-rank.
2697
2698         __isl_give isl_mat *isl_mat_right_inverse(__isl_take isl_mat *mat);
2699
2700 The following function can be used to compute the (right) kernel
2701 (or null space) of a matrix, i.e., a matrix such that the product of
2702 the original and the kernel (in that order) is the zero matrix.
2703
2704         __isl_give isl_mat *isl_mat_right_kernel(__isl_take isl_mat *mat);
2705
2706 =head2 Piecewise Quasi Affine Expressions
2707
2708 The zero quasi affine expression on a given domain can be created using
2709
2710         __isl_give isl_aff *isl_aff_zero_on_domain(
2711                 __isl_take isl_local_space *ls);
2712
2713 Note that the space in which the resulting object lives is a map space
2714 with the given space as domain and a one-dimensional range.
2715
2716 An empty piecewise quasi affine expression (one with no cells)
2717 or a piecewise quasi affine expression with a single cell can
2718 be created using the following functions.
2719
2720         #include <isl/aff.h>
2721         __isl_give isl_pw_aff *isl_pw_aff_empty(
2722                 __isl_take isl_space *space);
2723         __isl_give isl_pw_aff *isl_pw_aff_alloc(
2724                 __isl_take isl_set *set, __isl_take isl_aff *aff);
2725         __isl_give isl_pw_aff *isl_pw_aff_from_aff(
2726                 __isl_take isl_aff *aff);
2727
2728 Quasi affine expressions can be copied and freed using
2729
2730         #include <isl/aff.h>
2731         __isl_give isl_aff *isl_aff_copy(__isl_keep isl_aff *aff);
2732         void *isl_aff_free(__isl_take isl_aff *aff);
2733
2734         __isl_give isl_pw_aff *isl_pw_aff_copy(
2735                 __isl_keep isl_pw_aff *pwaff);
2736         void *isl_pw_aff_free(__isl_take isl_pw_aff *pwaff);
2737
2738 A (rational) bound on a dimension can be extracted from an C<isl_constraint>
2739 using the following function.  The constraint is required to have
2740 a non-zero coefficient for the specified dimension.
2741
2742         #include <isl/constraint.h>
2743         __isl_give isl_aff *isl_constraint_get_bound(
2744                 __isl_keep isl_constraint *constraint,
2745                 enum isl_dim_type type, int pos);
2746
2747 The entire affine expression of the constraint can also be extracted
2748 using the following function.
2749
2750         #include <isl/constraint.h>
2751         __isl_give isl_aff *isl_constraint_get_aff(
2752                 __isl_keep isl_constraint *constraint);
2753
2754 Conversely, an equality constraint equating
2755 the affine expression to zero or an inequality constraint enforcing
2756 the affine expression to be non-negative, can be constructed using
2757
2758         __isl_give isl_constraint *isl_equality_from_aff(
2759                 __isl_take isl_aff *aff);
2760         __isl_give isl_constraint *isl_inequality_from_aff(
2761                 __isl_take isl_aff *aff);
2762
2763 The expression can be inspected using
2764
2765         #include <isl/aff.h>
2766         isl_ctx *isl_aff_get_ctx(__isl_keep isl_aff *aff);
2767         int isl_aff_dim(__isl_keep isl_aff *aff,
2768                 enum isl_dim_type type);
2769         __isl_give isl_local_space *isl_aff_get_domain_local_space(
2770                 __isl_keep isl_aff *aff);
2771         __isl_give isl_local_space *isl_aff_get_local_space(
2772                 __isl_keep isl_aff *aff);
2773         const char *isl_aff_get_dim_name(__isl_keep isl_aff *aff,
2774                 enum isl_dim_type type, unsigned pos);
2775         const char *isl_pw_aff_get_dim_name(
2776                 __isl_keep isl_pw_aff *pa,
2777                 enum isl_dim_type type, unsigned pos);
2778         int isl_pw_aff_has_dim_id(__isl_keep isl_pw_aff *pa,
2779                 enum isl_dim_type type, unsigned pos);
2780         __isl_give isl_id *isl_pw_aff_get_dim_id(
2781                 __isl_keep isl_pw_aff *pa,
2782                 enum isl_dim_type type, unsigned pos);
2783         int isl_aff_get_constant(__isl_keep isl_aff *aff,
2784                 isl_int *v);
2785         int isl_aff_get_coefficient(__isl_keep isl_aff *aff,
2786                 enum isl_dim_type type, int pos, isl_int *v);
2787         int isl_aff_get_denominator(__isl_keep isl_aff *aff,
2788                 isl_int *v);
2789         __isl_give isl_aff *isl_aff_get_div(
2790                 __isl_keep isl_aff *aff, int pos);
2791
2792         int isl_pw_aff_foreach_piece(__isl_keep isl_pw_aff *pwaff,
2793                 int (*fn)(__isl_take isl_set *set,
2794                           __isl_take isl_aff *aff,
2795                           void *user), void *user);
2796
2797         int isl_aff_is_cst(__isl_keep isl_aff *aff);
2798         int isl_pw_aff_is_cst(__isl_keep isl_pw_aff *pwaff);
2799
2800         int isl_aff_involves_dims(__isl_keep isl_aff *aff,
2801                 enum isl_dim_type type, unsigned first, unsigned n);
2802         int isl_pw_aff_involves_dims(__isl_keep isl_pw_aff *pwaff,
2803                 enum isl_dim_type type, unsigned first, unsigned n);
2804
2805         isl_ctx *isl_pw_aff_get_ctx(__isl_keep isl_pw_aff *pwaff);
2806         unsigned isl_pw_aff_dim(__isl_keep isl_pw_aff *pwaff,
2807                 enum isl_dim_type type);
2808         int isl_pw_aff_is_empty(__isl_keep isl_pw_aff *pwaff);
2809
2810 It can be modified using
2811
2812         #include <isl/aff.h>
2813         __isl_give isl_pw_aff *isl_pw_aff_set_tuple_id(
2814                 __isl_take isl_pw_aff *pwaff,
2815                 enum isl_dim_type type, __isl_take isl_id *id);
2816         __isl_give isl_aff *isl_aff_set_dim_name(
2817                 __isl_take isl_aff *aff, enum isl_dim_type type,
2818                 unsigned pos, const char *s);
2819         __isl_give isl_aff *isl_aff_set_dim_id(
2820                 __isl_take isl_aff *aff, enum isl_dim_type type,
2821                 unsigned pos, __isl_take isl_id *id);
2822         __isl_give isl_pw_aff *isl_pw_aff_set_dim_id(
2823                 __isl_take isl_pw_aff *pma,
2824                 enum isl_dim_type type, unsigned pos,
2825                 __isl_take isl_id *id);
2826         __isl_give isl_aff *isl_aff_set_constant(
2827                 __isl_take isl_aff *aff, isl_int v);
2828         __isl_give isl_aff *isl_aff_set_constant_si(
2829                 __isl_take isl_aff *aff, int v);
2830         __isl_give isl_aff *isl_aff_set_coefficient(
2831                 __isl_take isl_aff *aff,
2832                 enum isl_dim_type type, int pos, isl_int v);
2833         __isl_give isl_aff *isl_aff_set_coefficient_si(
2834                 __isl_take isl_aff *aff,
2835                 enum isl_dim_type type, int pos, int v);
2836         __isl_give isl_aff *isl_aff_set_denominator(
2837                 __isl_take isl_aff *aff, isl_int v);
2838
2839         __isl_give isl_aff *isl_aff_add_constant(
2840                 __isl_take isl_aff *aff, isl_int v);
2841         __isl_give isl_aff *isl_aff_add_constant_si(
2842                 __isl_take isl_aff *aff, int v);
2843         __isl_give isl_aff *isl_aff_add_coefficient(
2844                 __isl_take isl_aff *aff,
2845                 enum isl_dim_type type, int pos, isl_int v);
2846         __isl_give isl_aff *isl_aff_add_coefficient_si(
2847                 __isl_take isl_aff *aff,
2848                 enum isl_dim_type type, int pos, int v);
2849
2850         __isl_give isl_aff *isl_aff_insert_dims(
2851                 __isl_take isl_aff *aff,
2852                 enum isl_dim_type type, unsigned first, unsigned n);
2853         __isl_give isl_pw_aff *isl_pw_aff_insert_dims(
2854                 __isl_take isl_pw_aff *pwaff,
2855                 enum isl_dim_type type, unsigned first, unsigned n);
2856         __isl_give isl_aff *isl_aff_add_dims(
2857                 __isl_take isl_aff *aff,
2858                 enum isl_dim_type type, unsigned n);
2859         __isl_give isl_pw_aff *isl_pw_aff_add_dims(
2860                 __isl_take isl_pw_aff *pwaff,
2861                 enum isl_dim_type type, unsigned n);
2862         __isl_give isl_aff *isl_aff_drop_dims(
2863                 __isl_take isl_aff *aff,
2864                 enum isl_dim_type type, unsigned first, unsigned n);
2865         __isl_give isl_pw_aff *isl_pw_aff_drop_dims(
2866                 __isl_take isl_pw_aff *pwaff,
2867                 enum isl_dim_type type, unsigned first, unsigned n);
2868
2869 Note that the C<set_constant> and C<set_coefficient> functions
2870 set the I<numerator> of the constant or coefficient, while
2871 C<add_constant> and C<add_coefficient> add an integer value to
2872 the possibly rational constant or coefficient.
2873
2874 To check whether an affine expressions is obviously zero
2875 or obviously equal to some other affine expression, use
2876
2877         #include <isl/aff.h>
2878         int isl_aff_plain_is_zero(__isl_keep isl_aff *aff);
2879         int isl_aff_plain_is_equal(__isl_keep isl_aff *aff1,
2880                 __isl_keep isl_aff *aff2);
2881         int isl_pw_aff_plain_is_equal(
2882                 __isl_keep isl_pw_aff *pwaff1,
2883                 __isl_keep isl_pw_aff *pwaff2);
2884
2885 Operations include
2886
2887         #include <isl/aff.h>
2888         __isl_give isl_aff *isl_aff_add(__isl_take isl_aff *aff1,
2889                 __isl_take isl_aff *aff2);
2890         __isl_give isl_pw_aff *isl_pw_aff_add(
2891                 __isl_take isl_pw_aff *pwaff1,
2892                 __isl_take isl_pw_aff *pwaff2);
2893         __isl_give isl_pw_aff *isl_pw_aff_min(
2894                 __isl_take isl_pw_aff *pwaff1,
2895                 __isl_take isl_pw_aff *pwaff2);
2896         __isl_give isl_pw_aff *isl_pw_aff_max(
2897                 __isl_take isl_pw_aff *pwaff1,
2898                 __isl_take isl_pw_aff *pwaff2);
2899         __isl_give isl_aff *isl_aff_sub(__isl_take isl_aff *aff1,
2900                 __isl_take isl_aff *aff2);
2901         __isl_give isl_pw_aff *isl_pw_aff_sub(
2902                 __isl_take isl_pw_aff *pwaff1,
2903                 __isl_take isl_pw_aff *pwaff2);
2904         __isl_give isl_aff *isl_aff_neg(__isl_take isl_aff *aff);
2905         __isl_give isl_pw_aff *isl_pw_aff_neg(
2906                 __isl_take isl_pw_aff *pwaff);
2907         __isl_give isl_aff *isl_aff_ceil(__isl_take isl_aff *aff);
2908         __isl_give isl_pw_aff *isl_pw_aff_ceil(
2909                 __isl_take isl_pw_aff *pwaff);
2910         __isl_give isl_aff *isl_aff_floor(__isl_take isl_aff *aff);
2911         __isl_give isl_pw_aff *isl_pw_aff_floor(
2912                 __isl_take isl_pw_aff *pwaff);
2913         __isl_give isl_aff *isl_aff_mod(__isl_take isl_aff *aff,
2914                 isl_int mod);
2915         __isl_give isl_pw_aff *isl_pw_aff_mod(
2916                 __isl_take isl_pw_aff *pwaff, isl_int mod);
2917         __isl_give isl_aff *isl_aff_scale(__isl_take isl_aff *aff,
2918                 isl_int f);
2919         __isl_give isl_pw_aff *isl_pw_aff_scale(
2920                 __isl_take isl_pw_aff *pwaff, isl_int f);
2921         __isl_give isl_aff *isl_aff_scale_down(__isl_take isl_aff *aff,
2922                 isl_int f);
2923         __isl_give isl_aff *isl_aff_scale_down_ui(
2924                 __isl_take isl_aff *aff, unsigned f);
2925         __isl_give isl_pw_aff *isl_pw_aff_scale_down(
2926                 __isl_take isl_pw_aff *pwaff, isl_int f);
2927
2928         __isl_give isl_pw_aff *isl_pw_aff_list_min(
2929                 __isl_take isl_pw_aff_list *list);
2930         __isl_give isl_pw_aff *isl_pw_aff_list_max(
2931                 __isl_take isl_pw_aff_list *list);
2932
2933         __isl_give isl_pw_aff *isl_pw_aff_coalesce(
2934                 __isl_take isl_pw_aff *pwqp);
2935
2936         __isl_give isl_pw_aff *isl_pw_aff_align_params(
2937                 __isl_take isl_pw_aff *pwaff,
2938                 __isl_take isl_space *model);
2939
2940         __isl_give isl_aff *isl_aff_gist_params(
2941                 __isl_take isl_aff *aff,
2942                 __isl_take isl_set *context);
2943         __isl_give isl_aff *isl_aff_gist(__isl_take isl_aff *aff,
2944                 __isl_take isl_set *context);
2945         __isl_give isl_pw_aff *isl_pw_aff_gist_params(
2946                 __isl_take isl_pw_aff *pwaff,
2947                 __isl_take isl_set *context);
2948         __isl_give isl_pw_aff *isl_pw_aff_gist(
2949                 __isl_take isl_pw_aff *pwaff,
2950                 __isl_take isl_set *context);
2951
2952         __isl_give isl_set *isl_pw_aff_domain(
2953                 __isl_take isl_pw_aff *pwaff);
2954         __isl_give isl_pw_aff *isl_pw_aff_intersect_domain(
2955                 __isl_take isl_pw_aff *pa,
2956                 __isl_take isl_set *set);
2957         __isl_give isl_pw_aff *isl_pw_aff_intersect_params(
2958                 __isl_take isl_pw_aff *pa,
2959                 __isl_take isl_set *set);
2960
2961         __isl_give isl_aff *isl_aff_mul(__isl_take isl_aff *aff1,
2962                 __isl_take isl_aff *aff2);
2963         __isl_give isl_pw_aff *isl_pw_aff_mul(
2964                 __isl_take isl_pw_aff *pwaff1,
2965                 __isl_take isl_pw_aff *pwaff2);
2966
2967 When multiplying two affine expressions, at least one of the two needs
2968 to be a constant.
2969
2970         #include <isl/aff.h>
2971         __isl_give isl_basic_set *isl_aff_le_basic_set(
2972                 __isl_take isl_aff *aff1, __isl_take isl_aff *aff2);
2973         __isl_give isl_basic_set *isl_aff_ge_basic_set(
2974                 __isl_take isl_aff *aff1, __isl_take isl_aff *aff2);
2975         __isl_give isl_set *isl_pw_aff_eq_set(
2976                 __isl_take isl_pw_aff *pwaff1,
2977                 __isl_take isl_pw_aff *pwaff2);
2978         __isl_give isl_set *isl_pw_aff_ne_set(
2979                 __isl_take isl_pw_aff *pwaff1,
2980                 __isl_take isl_pw_aff *pwaff2);
2981         __isl_give isl_set *isl_pw_aff_le_set(
2982                 __isl_take isl_pw_aff *pwaff1,
2983                 __isl_take isl_pw_aff *pwaff2);
2984         __isl_give isl_set *isl_pw_aff_lt_set(
2985                 __isl_take isl_pw_aff *pwaff1,
2986                 __isl_take isl_pw_aff *pwaff2);
2987         __isl_give isl_set *isl_pw_aff_ge_set(
2988                 __isl_take isl_pw_aff *pwaff1,
2989                 __isl_take isl_pw_aff *pwaff2);
2990         __isl_give isl_set *isl_pw_aff_gt_set(
2991                 __isl_take isl_pw_aff *pwaff1,
2992                 __isl_take isl_pw_aff *pwaff2);
2993
2994         __isl_give isl_set *isl_pw_aff_list_eq_set(
2995                 __isl_take isl_pw_aff_list *list1,
2996                 __isl_take isl_pw_aff_list *list2);
2997         __isl_give isl_set *isl_pw_aff_list_ne_set(
2998                 __isl_take isl_pw_aff_list *list1,
2999                 __isl_take isl_pw_aff_list *list2);
3000         __isl_give isl_set *isl_pw_aff_list_le_set(
3001                 __isl_take isl_pw_aff_list *list1,
3002                 __isl_take isl_pw_aff_list *list2);
3003         __isl_give isl_set *isl_pw_aff_list_lt_set(
3004                 __isl_take isl_pw_aff_list *list1,
3005                 __isl_take isl_pw_aff_list *list2);
3006         __isl_give isl_set *isl_pw_aff_list_ge_set(
3007                 __isl_take isl_pw_aff_list *list1,
3008                 __isl_take isl_pw_aff_list *list2);
3009         __isl_give isl_set *isl_pw_aff_list_gt_set(
3010                 __isl_take isl_pw_aff_list *list1,
3011                 __isl_take isl_pw_aff_list *list2);
3012
3013 The function C<isl_aff_ge_basic_set> returns a basic set
3014 containing those elements in the shared space
3015 of C<aff1> and C<aff2> where C<aff1> is greater than or equal to C<aff2>.
3016 The function C<isl_aff_ge_set> returns a set
3017 containing those elements in the shared domain
3018 of C<pwaff1> and C<pwaff2> where C<pwaff1> is greater than or equal to C<pwaff2>.
3019 The functions operating on C<isl_pw_aff_list> apply the corresponding
3020 C<isl_pw_aff> function to each pair of elements in the two lists.
3021
3022         #include <isl/aff.h>
3023         __isl_give isl_set *isl_pw_aff_nonneg_set(
3024                 __isl_take isl_pw_aff *pwaff);
3025         __isl_give isl_set *isl_pw_aff_zero_set(
3026                 __isl_take isl_pw_aff *pwaff);
3027         __isl_give isl_set *isl_pw_aff_non_zero_set(
3028                 __isl_take isl_pw_aff *pwaff);
3029
3030 The function C<isl_pw_aff_nonneg_set> returns a set
3031 containing those elements in the domain
3032 of C<pwaff> where C<pwaff> is non-negative.
3033
3034         #include <isl/aff.h>
3035         __isl_give isl_pw_aff *isl_pw_aff_cond(
3036                 __isl_take isl_set *cond,
3037                 __isl_take isl_pw_aff *pwaff_true,
3038                 __isl_take isl_pw_aff *pwaff_false);
3039
3040 The function C<isl_pw_aff_cond> performs a conditional operator
3041 and returns an expression that is equal to C<pwaff_true>
3042 for elements in C<cond> and equal to C<pwaff_false> for elements
3043 not in C<cond>.
3044
3045         #include <isl/aff.h>
3046         __isl_give isl_pw_aff *isl_pw_aff_union_min(
3047                 __isl_take isl_pw_aff *pwaff1,
3048                 __isl_take isl_pw_aff *pwaff2);
3049         __isl_give isl_pw_aff *isl_pw_aff_union_max(
3050                 __isl_take isl_pw_aff *pwaff1,
3051                 __isl_take isl_pw_aff *pwaff2);
3052         __isl_give isl_pw_aff *isl_pw_aff_union_add(
3053                 __isl_take isl_pw_aff *pwaff1,
3054                 __isl_take isl_pw_aff *pwaff2);
3055
3056 The function C<isl_pw_aff_union_max> computes a piecewise quasi-affine
3057 expression with a domain that is the union of those of C<pwaff1> and
3058 C<pwaff2> and such that on each cell, the quasi-affine expression is
3059 the maximum of those of C<pwaff1> and C<pwaff2>.  If only one of
3060 C<pwaff1> or C<pwaff2> is defined on a given cell, then the
3061 associated expression is the defined one.
3062
3063 An expression can be read from input using
3064
3065         #include <isl/aff.h>
3066         __isl_give isl_aff *isl_aff_read_from_str(
3067                 isl_ctx *ctx, const char *str);
3068         __isl_give isl_pw_aff *isl_pw_aff_read_from_str(
3069                 isl_ctx *ctx, const char *str);
3070
3071 An expression can be printed using
3072
3073         #include <isl/aff.h>
3074         __isl_give isl_printer *isl_printer_print_aff(
3075                 __isl_take isl_printer *p, __isl_keep isl_aff *aff);
3076
3077         __isl_give isl_printer *isl_printer_print_pw_aff(
3078                 __isl_take isl_printer *p,
3079                 __isl_keep isl_pw_aff *pwaff);
3080
3081 =head2 Piecewise Multiple Quasi Affine Expressions
3082
3083 An C<isl_multi_aff> object represents a sequence of
3084 zero or more affine expressions, all defined on the same domain space.
3085
3086 An C<isl_multi_aff> can be constructed from a C<isl_aff_list> using the
3087 following function.
3088
3089         #include <isl/aff.h>
3090         __isl_give isl_multi_aff *isl_multi_aff_from_aff_list(
3091                 __isl_take isl_space *space,
3092                 __isl_take isl_aff_list *list);
3093
3094 An empty piecewise multiple quasi affine expression (one with no cells) or
3095 a piecewise multiple quasi affine expression with a single cell can
3096 be created using the following functions.
3097
3098         #include <isl/aff.h>
3099         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_empty(
3100                 __isl_take isl_space *space);
3101         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_alloc(
3102                 __isl_take isl_set *set,
3103                 __isl_take isl_multi_aff *maff);
3104
3105 A piecewise multiple quasi affine expression can also be initialized
3106 from an C<isl_set> or C<isl_map>, provided the C<isl_set> is a singleton
3107 and the C<isl_map> is single-valued.
3108
3109         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_set(
3110                 __isl_take isl_set *set);
3111         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_map(
3112                 __isl_take isl_map *map);
3113
3114 Multiple quasi affine expressions can be copied and freed using
3115
3116         #include <isl/aff.h>
3117         __isl_give isl_multi_aff *isl_multi_aff_copy(
3118                 __isl_keep isl_multi_aff *maff);
3119         void *isl_multi_aff_free(__isl_take isl_multi_aff *maff);
3120
3121         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_copy(
3122                 __isl_keep isl_pw_multi_aff *pma);
3123         void *isl_pw_multi_aff_free(
3124                 __isl_take isl_pw_multi_aff *pma);
3125
3126 The expression can be inspected using
3127
3128         #include <isl/aff.h>
3129         isl_ctx *isl_multi_aff_get_ctx(
3130                 __isl_keep isl_multi_aff *maff);
3131         isl_ctx *isl_pw_multi_aff_get_ctx(
3132                 __isl_keep isl_pw_multi_aff *pma);
3133         unsigned isl_multi_aff_dim(__isl_keep isl_multi_aff *maff,
3134                 enum isl_dim_type type);
3135         unsigned isl_pw_multi_aff_dim(
3136                 __isl_keep isl_pw_multi_aff *pma,
3137                 enum isl_dim_type type);
3138         __isl_give isl_aff *isl_multi_aff_get_aff(
3139                 __isl_keep isl_multi_aff *multi, int pos);
3140         __isl_give isl_pw_aff *isl_pw_multi_aff_get_pw_aff(
3141                 __isl_keep isl_pw_multi_aff *pma, int pos);
3142         const char *isl_pw_multi_aff_get_dim_name(
3143                 __isl_keep isl_pw_multi_aff *pma,
3144                 enum isl_dim_type type, unsigned pos);
3145         __isl_give isl_id *isl_pw_multi_aff_get_dim_id(
3146                 __isl_keep isl_pw_multi_aff *pma,
3147                 enum isl_dim_type type, unsigned pos);
3148         const char *isl_multi_aff_get_tuple_name(
3149                 __isl_keep isl_multi_aff *multi,
3150                 enum isl_dim_type type);
3151         const char *isl_pw_multi_aff_get_tuple_name(
3152                 __isl_keep isl_pw_multi_aff *pma,
3153                 enum isl_dim_type type);
3154         int isl_pw_multi_aff_has_tuple_id(
3155                 __isl_keep isl_pw_multi_aff *pma,
3156                 enum isl_dim_type type);
3157         __isl_give isl_id *isl_pw_multi_aff_get_tuple_id(
3158                 __isl_keep isl_pw_multi_aff *pma,
3159                 enum isl_dim_type type);
3160
3161         int isl_pw_multi_aff_foreach_piece(
3162                 __isl_keep isl_pw_multi_aff *pma,
3163                 int (*fn)(__isl_take isl_set *set,
3164                             __isl_take isl_multi_aff *maff,
3165                             void *user), void *user);
3166
3167 It can be modified using
3168
3169         #include <isl/aff.h>
3170         __isl_give isl_multi_aff *isl_multi_aff_set_dim_name(
3171                 __isl_take isl_multi_aff *maff,
3172                 enum isl_dim_type type, unsigned pos, const char *s);
3173         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_tuple_id(
3174                 __isl_take isl_pw_multi_aff *pma,
3175                 enum isl_dim_type type, __isl_take isl_id *id);
3176
3177 To check whether two multiple affine expressions are
3178 obviously equal to each other, use
3179
3180         int isl_multi_aff_plain_is_equal(__isl_keep isl_multi_aff *maff1,
3181                 __isl_keep isl_multi_aff *maff2);
3182         int isl_pw_multi_aff_plain_is_equal(
3183                 __isl_keep isl_pw_multi_aff *pma1,
3184                 __isl_keep isl_pw_multi_aff *pma2);
3185
3186 Operations include
3187
3188         #include <isl/aff.h>
3189         __isl_give isl_multi_aff *isl_multi_aff_add(
3190                 __isl_take isl_multi_aff *maff1,
3191                 __isl_take isl_multi_aff *maff2);
3192         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_add(
3193                 __isl_take isl_pw_multi_aff *pma1,
3194                 __isl_take isl_pw_multi_aff *pma2);
3195         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_add(
3196                 __isl_take isl_pw_multi_aff *pma1,
3197                 __isl_take isl_pw_multi_aff *pma2);
3198         __isl_give isl_multi_aff *isl_multi_aff_scale(
3199                 __isl_take isl_multi_aff *maff,
3200                 isl_int f);
3201         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_params(
3202                 __isl_take isl_pw_multi_aff *pma,
3203                 __isl_take isl_set *set);
3204         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_domain(
3205                 __isl_take isl_pw_multi_aff *pma,
3206                 __isl_take isl_set *set);
3207         __isl_give isl_multi_aff *isl_multi_aff_lift(
3208                 __isl_take isl_multi_aff *maff,
3209                 __isl_give isl_local_space **ls);
3210         __isl_give isl_multi_aff *isl_multi_aff_gist_params(
3211                 __isl_take isl_multi_aff *maff,
3212                 __isl_take isl_set *context);
3213         __isl_give isl_multi_aff *isl_multi_aff_gist(
3214                 __isl_take isl_multi_aff *maff,
3215                 __isl_take isl_set *context);
3216         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist_params(
3217                 __isl_take isl_pw_multi_aff *pma,
3218                 __isl_take isl_set *set);
3219         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist(
3220                 __isl_take isl_pw_multi_aff *pma,
3221                 __isl_take isl_set *set);
3222
3223 If the C<ls> argument of C<isl_multi_aff_lift> is not C<NULL>,
3224 then it is assigned the local space that lies at the basis of
3225 the lifting applied.
3226
3227 An expression can be read from input using
3228
3229         #include <isl/aff.h>
3230         __isl_give isl_multi_aff *isl_multi_aff_read_from_str(
3231                 isl_ctx *ctx, const char *str);
3232         __isl_give isl_pw_multi_aff *isl_pw_multi_aff_read_from_str(
3233                 isl_ctx *ctx, const char *str);
3234
3235 An expression can be printed using
3236
3237         #include <isl/aff.h>
3238         __isl_give isl_printer *isl_printer_print_multi_aff(
3239                 __isl_take isl_printer *p,
3240                 __isl_keep isl_multi_aff *maff);
3241         __isl_give isl_printer *isl_printer_print_pw_multi_aff(
3242                 __isl_take isl_printer *p,
3243                 __isl_keep isl_pw_multi_aff *pma);
3244
3245 =head2 Points
3246
3247 Points are elements of a set.  They can be used to construct
3248 simple sets (boxes) or they can be used to represent the
3249 individual elements of a set.
3250 The zero point (the origin) can be created using
3251
3252         __isl_give isl_point *isl_point_zero(__isl_take isl_space *space);
3253
3254 The coordinates of a point can be inspected, set and changed
3255 using
3256
3257         int isl_point_get_coordinate(__isl_keep isl_point *pnt,
3258                 enum isl_dim_type type, int pos, isl_int *v);
3259         __isl_give isl_point *isl_point_set_coordinate(
3260                 __isl_take isl_point *pnt,
3261                 enum isl_dim_type type, int pos, isl_int v);
3262
3263         __isl_give isl_point *isl_point_add_ui(
3264                 __isl_take isl_point *pnt,
3265                 enum isl_dim_type type, int pos, unsigned val);
3266         __isl_give isl_point *isl_point_sub_ui(
3267                 __isl_take isl_point *pnt,
3268                 enum isl_dim_type type, int pos, unsigned val);
3269
3270 Other properties can be obtained using
3271
3272         isl_ctx *isl_point_get_ctx(__isl_keep isl_point *pnt);
3273
3274 Points can be copied or freed using
3275
3276         __isl_give isl_point *isl_point_copy(
3277                 __isl_keep isl_point *pnt);
3278         void isl_point_free(__isl_take isl_point *pnt);
3279
3280 A singleton set can be created from a point using
3281
3282         __isl_give isl_basic_set *isl_basic_set_from_point(
3283                 __isl_take isl_point *pnt);
3284         __isl_give isl_set *isl_set_from_point(
3285                 __isl_take isl_point *pnt);
3286
3287 and a box can be created from two opposite extremal points using
3288
3289         __isl_give isl_basic_set *isl_basic_set_box_from_points(
3290                 __isl_take isl_point *pnt1,
3291                 __isl_take isl_point *pnt2);
3292         __isl_give isl_set *isl_set_box_from_points(
3293                 __isl_take isl_point *pnt1,
3294                 __isl_take isl_point *pnt2);
3295
3296 All elements of a B<bounded> (union) set can be enumerated using
3297 the following functions.
3298
3299         int isl_set_foreach_point(__isl_keep isl_set *set,
3300                 int (*fn)(__isl_take isl_point *pnt, void *user),
3301                 void *user);
3302         int isl_union_set_foreach_point(__isl_keep isl_union_set *uset,
3303                 int (*fn)(__isl_take isl_point *pnt, void *user),
3304                 void *user);
3305
3306 The function C<fn> is called for each integer point in
3307 C<set> with as second argument the last argument of
3308 the C<isl_set_foreach_point> call.  The function C<fn>
3309 should return C<0> on success and C<-1> on failure.
3310 In the latter case, C<isl_set_foreach_point> will stop
3311 enumerating and return C<-1> as well.
3312 If the enumeration is performed successfully and to completion,
3313 then C<isl_set_foreach_point> returns C<0>.
3314
3315 To obtain a single point of a (basic) set, use
3316
3317         __isl_give isl_point *isl_basic_set_sample_point(
3318                 __isl_take isl_basic_set *bset);
3319         __isl_give isl_point *isl_set_sample_point(
3320                 __isl_take isl_set *set);
3321
3322 If C<set> does not contain any (integer) points, then the
3323 resulting point will be ``void'', a property that can be
3324 tested using
3325
3326         int isl_point_is_void(__isl_keep isl_point *pnt);
3327
3328 =head2 Piecewise Quasipolynomials
3329
3330 A piecewise quasipolynomial is a particular kind of function that maps
3331 a parametric point to a rational value.
3332 More specifically, a quasipolynomial is a polynomial expression in greatest
3333 integer parts of affine expressions of parameters and variables.
3334 A piecewise quasipolynomial is a subdivision of a given parametric
3335 domain into disjoint cells with a quasipolynomial associated to
3336 each cell.  The value of the piecewise quasipolynomial at a given
3337 point is the value of the quasipolynomial associated to the cell
3338 that contains the point.  Outside of the union of cells,
3339 the value is assumed to be zero.
3340 For example, the piecewise quasipolynomial
3341
3342         [n] -> { [x] -> ((1 + n) - x) : x <= n and x >= 0 }
3343
3344 maps C<x> to C<1 + n - x> for values of C<x> between C<0> and C<n>.
3345 A given piecewise quasipolynomial has a fixed domain dimension.
3346 Union piecewise quasipolynomials are used to contain piecewise quasipolynomials
3347 defined over different domains.
3348 Piecewise quasipolynomials are mainly used by the C<barvinok>
3349 library for representing the number of elements in a parametric set or map.
3350 For example, the piecewise quasipolynomial above represents
3351 the number of points in the map
3352
3353         [n] -> { [x] -> [y] : x,y >= 0 and 0 <= x + y <= n }
3354
3355 =head3 Input and Output
3356
3357 Piecewise quasipolynomials can be read from input using
3358
3359         __isl_give isl_union_pw_qpolynomial *
3360         isl_union_pw_qpolynomial_read_from_str(
3361                 isl_ctx *ctx, const char *str);
3362
3363 Quasipolynomials and piecewise quasipolynomials can be printed
3364 using the following functions.
3365
3366         __isl_give isl_printer *isl_printer_print_qpolynomial(
3367                 __isl_take isl_printer *p,
3368                 __isl_keep isl_qpolynomial *qp);
3369
3370         __isl_give isl_printer *isl_printer_print_pw_qpolynomial(
3371                 __isl_take isl_printer *p,
3372                 __isl_keep isl_pw_qpolynomial *pwqp);
3373
3374         __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial(
3375                 __isl_take isl_printer *p,
3376                 __isl_keep isl_union_pw_qpolynomial *upwqp);
3377
3378 The output format of the printer
3379 needs to be set to either C<ISL_FORMAT_ISL> or C<ISL_FORMAT_C>.
3380 For C<isl_printer_print_union_pw_qpolynomial>, only C<ISL_FORMAT_ISL>
3381 is supported.
3382 In case of printing in C<ISL_FORMAT_C>, the user may want
3383 to set the names of all dimensions
3384
3385         __isl_give isl_qpolynomial *isl_qpolynomial_set_dim_name(
3386                 __isl_take isl_qpolynomial *qp,
3387                 enum isl_dim_type type, unsigned pos,
3388                 const char *s);
3389         __isl_give isl_pw_qpolynomial *
3390         isl_pw_qpolynomial_set_dim_name(
3391                 __isl_take isl_pw_qpolynomial *pwqp,
3392                 enum isl_dim_type type, unsigned pos,
3393                 const char *s);
3394
3395 =head3 Creating New (Piecewise) Quasipolynomials
3396
3397 Some simple quasipolynomials can be created using the following functions.
3398 More complicated quasipolynomials can be created by applying
3399 operations such as addition and multiplication
3400 on the resulting quasipolynomials
3401
3402         __isl_give isl_qpolynomial *isl_qpolynomial_zero_on_domain(
3403                 __isl_take isl_space *domain);
3404         __isl_give isl_qpolynomial *isl_qpolynomial_one_on_domain(
3405                 __isl_take isl_space *domain);
3406         __isl_give isl_qpolynomial *isl_qpolynomial_infty_on_domain(
3407                 __isl_take isl_space *domain);
3408         __isl_give isl_qpolynomial *isl_qpolynomial_neginfty_on_domain(
3409                 __isl_take isl_space *domain);
3410         __isl_give isl_qpolynomial *isl_qpolynomial_nan_on_domain(
3411                 __isl_take isl_space *domain);
3412         __isl_give isl_qpolynomial *isl_qpolynomial_rat_cst_on_domain(
3413                 __isl_take isl_space *domain,
3414                 const isl_int n, const isl_int d);
3415         __isl_give isl_qpolynomial *isl_qpolynomial_var_on_domain(
3416                 __isl_take isl_space *domain,
3417                 enum isl_dim_type type, unsigned pos);
3418         __isl_give isl_qpolynomial *isl_qpolynomial_from_aff(
3419                 __isl_take isl_aff *aff);
3420
3421 Note that the space in which a quasipolynomial lives is a map space
3422 with a one-dimensional range.  The C<domain> argument in some of
3423 the functions above corresponds to the domain of this map space.
3424
3425 The zero piecewise quasipolynomial or a piecewise quasipolynomial
3426 with a single cell can be created using the following functions.
3427 Multiple of these single cell piecewise quasipolynomials can
3428 be combined to create more complicated piecewise quasipolynomials.
3429
3430         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_zero(
3431                 __isl_take isl_space *space);
3432         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_alloc(
3433                 __isl_take isl_set *set,
3434                 __isl_take isl_qpolynomial *qp);
3435         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_from_qpolynomial(
3436                 __isl_take isl_qpolynomial *qp);
3437         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_from_pw_aff(
3438                 __isl_take isl_pw_aff *pwaff);
3439
3440         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_zero(
3441                 __isl_take isl_space *space);
3442         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_from_pw_qpolynomial(
3443                 __isl_take isl_pw_qpolynomial *pwqp);
3444         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add_pw_qpolynomial(
3445                 __isl_take isl_union_pw_qpolynomial *upwqp,
3446                 __isl_take isl_pw_qpolynomial *pwqp);
3447
3448 Quasipolynomials can be copied and freed again using the following
3449 functions.
3450
3451         __isl_give isl_qpolynomial *isl_qpolynomial_copy(
3452                 __isl_keep isl_qpolynomial *qp);
3453         void *isl_qpolynomial_free(__isl_take isl_qpolynomial *qp);
3454
3455         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_copy(
3456                 __isl_keep isl_pw_qpolynomial *pwqp);
3457         void *isl_pw_qpolynomial_free(
3458                 __isl_take isl_pw_qpolynomial *pwqp);
3459
3460         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_copy(
3461                 __isl_keep isl_union_pw_qpolynomial *upwqp);
3462         void isl_union_pw_qpolynomial_free(
3463                 __isl_take isl_union_pw_qpolynomial *upwqp);
3464
3465 =head3 Inspecting (Piecewise) Quasipolynomials
3466
3467 To iterate over all piecewise quasipolynomials in a union
3468 piecewise quasipolynomial, use the following function
3469
3470         int isl_union_pw_qpolynomial_foreach_pw_qpolynomial(
3471                 __isl_keep isl_union_pw_qpolynomial *upwqp,
3472                 int (*fn)(__isl_take isl_pw_qpolynomial *pwqp, void *user),
3473                 void *user);
3474
3475 To extract the piecewise quasipolynomial in a given space from a union, use
3476
3477         __isl_give isl_pw_qpolynomial *
3478         isl_union_pw_qpolynomial_extract_pw_qpolynomial(
3479                 __isl_keep isl_union_pw_qpolynomial *upwqp,
3480                 __isl_take isl_space *space);
3481
3482 To iterate over the cells in a piecewise quasipolynomial,
3483 use either of the following two functions
3484
3485         int isl_pw_qpolynomial_foreach_piece(
3486                 __isl_keep isl_pw_qpolynomial *pwqp,
3487                 int (*fn)(__isl_take isl_set *set,
3488                           __isl_take isl_qpolynomial *qp,
3489                           void *user), void *user);
3490         int isl_pw_qpolynomial_foreach_lifted_piece(
3491                 __isl_keep isl_pw_qpolynomial *pwqp,
3492                 int (*fn)(__isl_take isl_set *set,
3493                           __isl_take isl_qpolynomial *qp,
3494                           void *user), void *user);
3495
3496 As usual, the function C<fn> should return C<0> on success
3497 and C<-1> on failure.  The difference between
3498 C<isl_pw_qpolynomial_foreach_piece> and
3499 C<isl_pw_qpolynomial_foreach_lifted_piece> is that
3500 C<isl_pw_qpolynomial_foreach_lifted_piece> will first
3501 compute unique representations for all existentially quantified
3502 variables and then turn these existentially quantified variables
3503 into extra set variables, adapting the associated quasipolynomial
3504 accordingly.  This means that the C<set> passed to C<fn>
3505 will not have any existentially quantified variables, but that
3506 the dimensions of the sets may be different for different
3507 invocations of C<fn>.
3508
3509 To iterate over all terms in a quasipolynomial,
3510 use
3511
3512         int isl_qpolynomial_foreach_term(
3513                 __isl_keep isl_qpolynomial *qp,
3514                 int (*fn)(__isl_take isl_term *term,
3515                           void *user), void *user);
3516
3517 The terms themselves can be inspected and freed using
3518 these functions
3519
3520         unsigned isl_term_dim(__isl_keep isl_term *term,
3521                 enum isl_dim_type type);
3522         void isl_term_get_num(__isl_keep isl_term *term,
3523                 isl_int *n);
3524         void isl_term_get_den(__isl_keep isl_term *term,
3525                 isl_int *d);
3526         int isl_term_get_exp(__isl_keep isl_term *term,
3527                 enum isl_dim_type type, unsigned pos);
3528         __isl_give isl_aff *isl_term_get_div(
3529                 __isl_keep isl_term *term, unsigned pos);
3530         void isl_term_free(__isl_take isl_term *term);
3531
3532 Each term is a product of parameters, set variables and
3533 integer divisions.  The function C<isl_term_get_exp>
3534 returns the exponent of a given dimensions in the given term.
3535 The C<isl_int>s in the arguments of C<isl_term_get_num>
3536 and C<isl_term_get_den> need to have been initialized
3537 using C<isl_int_init> before calling these functions.
3538
3539 =head3 Properties of (Piecewise) Quasipolynomials
3540
3541 To check whether a quasipolynomial is actually a constant,
3542 use the following function.
3543
3544         int isl_qpolynomial_is_cst(__isl_keep isl_qpolynomial *qp,
3545                 isl_int *n, isl_int *d);
3546
3547 If C<qp> is a constant and if C<n> and C<d> are not C<NULL>
3548 then the numerator and denominator of the constant
3549 are returned in C<*n> and C<*d>, respectively.
3550
3551 To check whether two union piecewise quasipolynomials are
3552 obviously equal, use
3553
3554         int isl_union_pw_qpolynomial_plain_is_equal(
3555                 __isl_keep isl_union_pw_qpolynomial *upwqp1,
3556                 __isl_keep isl_union_pw_qpolynomial *upwqp2);
3557
3558 =head3 Operations on (Piecewise) Quasipolynomials
3559
3560         __isl_give isl_qpolynomial *isl_qpolynomial_scale(
3561                 __isl_take isl_qpolynomial *qp, isl_int v);
3562         __isl_give isl_qpolynomial *isl_qpolynomial_neg(
3563                 __isl_take isl_qpolynomial *qp);
3564         __isl_give isl_qpolynomial *isl_qpolynomial_add(
3565                 __isl_take isl_qpolynomial *qp1,
3566                 __isl_take isl_qpolynomial *qp2);
3567         __isl_give isl_qpolynomial *isl_qpolynomial_sub(
3568                 __isl_take isl_qpolynomial *qp1,
3569                 __isl_take isl_qpolynomial *qp2);
3570         __isl_give isl_qpolynomial *isl_qpolynomial_mul(
3571                 __isl_take isl_qpolynomial *qp1,
3572                 __isl_take isl_qpolynomial *qp2);
3573         __isl_give isl_qpolynomial *isl_qpolynomial_pow(
3574                 __isl_take isl_qpolynomial *qp, unsigned exponent);
3575
3576         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add(
3577                 __isl_take isl_pw_qpolynomial *pwqp1,
3578                 __isl_take isl_pw_qpolynomial *pwqp2);
3579         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_sub(
3580                 __isl_take isl_pw_qpolynomial *pwqp1,
3581                 __isl_take isl_pw_qpolynomial *pwqp2);
3582         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add_disjoint(
3583                 __isl_take isl_pw_qpolynomial *pwqp1,
3584                 __isl_take isl_pw_qpolynomial *pwqp2);
3585         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_neg(
3586                 __isl_take isl_pw_qpolynomial *pwqp);
3587         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_mul(
3588                 __isl_take isl_pw_qpolynomial *pwqp1,
3589                 __isl_take isl_pw_qpolynomial *pwqp2);
3590         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_pow(
3591                 __isl_take isl_pw_qpolynomial *pwqp, unsigned exponent);
3592
3593         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add(
3594                 __isl_take isl_union_pw_qpolynomial *upwqp1,
3595                 __isl_take isl_union_pw_qpolynomial *upwqp2);
3596         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_sub(
3597                 __isl_take isl_union_pw_qpolynomial *upwqp1,
3598                 __isl_take isl_union_pw_qpolynomial *upwqp2);
3599         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_mul(
3600                 __isl_take isl_union_pw_qpolynomial *upwqp1,
3601                 __isl_take isl_union_pw_qpolynomial *upwqp2);
3602
3603         __isl_give isl_qpolynomial *isl_pw_qpolynomial_eval(
3604                 __isl_take isl_pw_qpolynomial *pwqp,
3605                 __isl_take isl_point *pnt);
3606
3607         __isl_give isl_qpolynomial *isl_union_pw_qpolynomial_eval(
3608                 __isl_take isl_union_pw_qpolynomial *upwqp,
3609                 __isl_take isl_point *pnt);
3610
3611         __isl_give isl_set *isl_pw_qpolynomial_domain(
3612                 __isl_take isl_pw_qpolynomial *pwqp);
3613         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_intersect_domain(
3614                 __isl_take isl_pw_qpolynomial *pwpq,
3615                 __isl_take isl_set *set);
3616         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_intersect_params(
3617                 __isl_take isl_pw_qpolynomial *pwpq,
3618                 __isl_take isl_set *set);
3619
3620         __isl_give isl_union_set *isl_union_pw_qpolynomial_domain(
3621                 __isl_take isl_union_pw_qpolynomial *upwqp);
3622         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_intersect_domain(
3623                 __isl_take isl_union_pw_qpolynomial *upwpq,
3624                 __isl_take isl_union_set *uset);
3625         __isl_give isl_union_pw_qpolynomial *
3626         isl_union_pw_qpolynomial_intersect_params(
3627                 __isl_take isl_union_pw_qpolynomial *upwpq,
3628                 __isl_take isl_set *set);
3629
3630         __isl_give isl_qpolynomial *isl_qpolynomial_align_params(
3631                 __isl_take isl_qpolynomial *qp,
3632                 __isl_take isl_space *model);
3633
3634         __isl_give isl_qpolynomial *isl_qpolynomial_project_domain_on_params(
3635                 __isl_take isl_qpolynomial *qp);
3636         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_project_domain_on_params(
3637                 __isl_take isl_pw_qpolynomial *pwqp);
3638
3639         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_coalesce(
3640                 __isl_take isl_union_pw_qpolynomial *upwqp);
3641
3642         __isl_give isl_qpolynomial *isl_qpolynomial_gist_params(
3643                 __isl_take isl_qpolynomial *qp,
3644                 __isl_take isl_set *context);
3645         __isl_give isl_qpolynomial *isl_qpolynomial_gist(
3646                 __isl_take isl_qpolynomial *qp,
3647                 __isl_take isl_set *context);
3648
3649         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist_params(
3650                 __isl_take isl_pw_qpolynomial *pwqp,
3651                 __isl_take isl_set *context);
3652         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist(
3653                 __isl_take isl_pw_qpolynomial *pwqp,
3654                 __isl_take isl_set *context);
3655
3656         __isl_give isl_union_pw_qpolynomial *
3657         isl_union_pw_qpolynomial_gist_params(
3658                 __isl_take isl_union_pw_qpolynomial *upwqp,
3659                 __isl_take isl_set *context);
3660         __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_gist(
3661                 __isl_take isl_union_pw_qpolynomial *upwqp,
3662                 __isl_take isl_union_set *context);
3663
3664 The gist operation applies the gist operation to each of
3665 the cells in the domain of the input piecewise quasipolynomial.
3666 The context is also exploited
3667 to simplify the quasipolynomials associated to each cell.
3668
3669         __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_to_polynomial(
3670                 __isl_take isl_pw_qpolynomial *pwqp, int sign);
3671         __isl_give isl_union_pw_qpolynomial *
3672         isl_union_pw_qpolynomial_to_polynomial(
3673                 __isl_take isl_union_pw_qpolynomial *upwqp, int sign);
3674
3675 Approximate each quasipolynomial by a polynomial.  If C<sign> is positive,
3676 the polynomial will be an overapproximation.  If C<sign> is negative,
3677 it will be an underapproximation.  If C<sign> is zero, the approximation
3678 will lie somewhere in between.
3679
3680 =head2 Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions
3681
3682 A piecewise quasipolynomial reduction is a piecewise
3683 reduction (or fold) of quasipolynomials.
3684 In particular, the reduction can be maximum or a minimum.
3685 The objects are mainly used to represent the result of
3686 an upper or lower bound on a quasipolynomial over its domain,
3687 i.e., as the result of the following function.
3688
3689         __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_bound(
3690                 __isl_take isl_pw_qpolynomial *pwqp,
3691                 enum isl_fold type, int *tight);
3692
3693         __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_bound(
3694                 __isl_take isl_union_pw_qpolynomial *upwqp,
3695                 enum isl_fold type, int *tight);
3696
3697 The C<type> argument may be either C<isl_fold_min> or C<isl_fold_max>.
3698 If C<tight> is not C<NULL>, then C<*tight> is set to C<1>
3699 is the returned bound is known be tight, i.e., for each value
3700 of the parameters there is at least
3701 one element in the domain that reaches the bound.
3702 If the domain of C<pwqp> is not wrapping, then the bound is computed
3703 over all elements in that domain and the result has a purely parametric
3704 domain.  If the domain of C<pwqp> is wrapping, then the bound is
3705 computed over the range of the wrapped relation.  The domain of the
3706 wrapped relation becomes the domain of the result.
3707
3708 A (piecewise) quasipolynomial reduction can be copied or freed using the
3709 following functions.
3710
3711         __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_copy(
3712                 __isl_keep isl_qpolynomial_fold *fold);
3713         __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_copy(
3714                 __isl_keep isl_pw_qpolynomial_fold *pwf);
3715         __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_copy(
3716                 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
3717         void isl_qpolynomial_fold_free(
3718                 __isl_take isl_qpolynomial_fold *fold);
3719         void *isl_pw_qpolynomial_fold_free(
3720                 __isl_take isl_pw_qpolynomial_fold *pwf);
3721         void isl_union_pw_qpolynomial_fold_free(
3722                 __isl_take isl_union_pw_qpolynomial_fold *upwf);
3723
3724 =head3 Printing Piecewise Quasipolynomial Reductions
3725
3726 Piecewise quasipolynomial reductions can be printed
3727 using the following function.
3728
3729         __isl_give isl_printer *isl_printer_print_pw_qpolynomial_fold(
3730                 __isl_take isl_printer *p,
3731                 __isl_keep isl_pw_qpolynomial_fold *pwf);
3732         __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial_fold(
3733                 __isl_take isl_printer *p,
3734                 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
3735
3736 For C<isl_printer_print_pw_qpolynomial_fold>,
3737 output format of the printer
3738 needs to be set to either C<ISL_FORMAT_ISL> or C<ISL_FORMAT_C>.
3739 For C<isl_printer_print_union_pw_qpolynomial_fold>,
3740 output format of the printer
3741 needs to be set to C<ISL_FORMAT_ISL>.
3742 In case of printing in C<ISL_FORMAT_C>, the user may want
3743 to set the names of all dimensions
3744
3745         __isl_give isl_pw_qpolynomial_fold *
3746         isl_pw_qpolynomial_fold_set_dim_name(
3747                 __isl_take isl_pw_qpolynomial_fold *pwf,
3748                 enum isl_dim_type type, unsigned pos,
3749                 const char *s);
3750
3751 =head3 Inspecting (Piecewise) Quasipolynomial Reductions
3752
3753 To iterate over all piecewise quasipolynomial reductions in a union
3754 piecewise quasipolynomial reduction, use the following function
3755
3756         int isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(
3757                 __isl_keep isl_union_pw_qpolynomial_fold *upwf,
3758                 int (*fn)(__isl_take isl_pw_qpolynomial_fold *pwf,
3759                             void *user), void *user);
3760
3761 To iterate over the cells in a piecewise quasipolynomial reduction,
3762 use either of the following two functions
3763
3764         int isl_pw_qpolynomial_fold_foreach_piece(
3765                 __isl_keep isl_pw_qpolynomial_fold *pwf,
3766                 int (*fn)(__isl_take isl_set *set,
3767                           __isl_take isl_qpolynomial_fold *fold,
3768                           void *user), void *user);
3769         int isl_pw_qpolynomial_fold_foreach_lifted_piece(
3770                 __isl_keep isl_pw_qpolynomial_fold *pwf,
3771                 int (*fn)(__isl_take isl_set *set,
3772                           __isl_take isl_qpolynomial_fold *fold,
3773                           void *user), void *user);
3774
3775 See L<Inspecting (Piecewise) Quasipolynomials> for an explanation
3776 of the difference between these two functions.
3777
3778 To iterate over all quasipolynomials in a reduction, use
3779
3780         int isl_qpolynomial_fold_foreach_qpolynomial(
3781                 __isl_keep isl_qpolynomial_fold *fold,
3782                 int (*fn)(__isl_take isl_qpolynomial *qp,
3783                           void *user), void *user);
3784
3785 =head3 Properties of Piecewise Quasipolynomial Reductions
3786
3787 To check whether two union piecewise quasipolynomial reductions are
3788 obviously equal, use
3789
3790         int isl_union_pw_qpolynomial_fold_plain_is_equal(
3791                 __isl_keep isl_union_pw_qpolynomial_fold *upwf1,
3792                 __isl_keep isl_union_pw_qpolynomial_fold *upwf2);
3793
3794 =head3 Operations on Piecewise Quasipolynomial Reductions
3795
3796         __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_scale(
3797                 __isl_take isl_qpolynomial_fold *fold, isl_int v);
3798
3799         __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_add(
3800                 __isl_take isl_pw_qpolynomial_fold *pwf1,
3801                 __isl_take isl_pw_qpolynomial_fold *pwf2);
3802
3803         __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_fold(
3804                 __isl_take isl_pw_qpolynomial_fold *pwf1,
3805                 __isl_take isl_pw_qpolynomial_fold *pwf2);
3806
3807         __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_fold(
3808                 __isl_take isl_union_pw_qpolynomial_fold *upwf1,
3809                 __isl_take isl_union_pw_qpolynomial_fold *upwf2);
3810
3811         __isl_give isl_qpolynomial *isl_pw_qpolynomial_fold_eval(
3812                 __isl_take isl_pw_qpolynomial_fold *pwf,
3813                 __isl_take isl_point *pnt);
3814
3815         __isl_give isl_qpolynomial *isl_union_pw_qpolynomial_fold_eval(
3816                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
3817                 __isl_take isl_point *pnt);
3818
3819         __isl_give isl_pw_qpolynomial_fold *
3820         sl_pw_qpolynomial_fold_intersect_params(
3821                 __isl_take isl_pw_qpolynomial_fold *pwf,
3822                 __isl_take isl_set *set);
3823
3824         __isl_give isl_union_set *isl_union_pw_qpolynomial_fold_domain(
3825                 __isl_take isl_union_pw_qpolynomial_fold *upwf);
3826         __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_intersect_domain(
3827                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
3828                 __isl_take isl_union_set *uset);
3829         __isl_give isl_union_pw_qpolynomial_fold *
3830         isl_union_pw_qpolynomial_fold_intersect_params(
3831                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
3832                 __isl_take isl_set *set);
3833
3834         __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_project_domain_on_params(
3835                 __isl_take isl_pw_qpolynomial_fold *pwf);
3836
3837         __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_coalesce(
3838                 __isl_take isl_pw_qpolynomial_fold *pwf);
3839
3840         __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_coalesce(
3841                 __isl_take isl_union_pw_qpolynomial_fold *upwf);
3842
3843         __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist_params(
3844                 __isl_take isl_qpolynomial_fold *fold,
3845                 __isl_take isl_set *context);
3846         __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist(
3847                 __isl_take isl_qpolynomial_fold *fold,
3848                 __isl_take isl_set *context);
3849
3850         __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_gist(
3851                 __isl_take isl_pw_qpolynomial_fold *pwf,
3852                 __isl_take isl_set *context);
3853         __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_gist_params(
3854                 __isl_take isl_pw_qpolynomial_fold *pwf,
3855                 __isl_take isl_set *context);
3856
3857         __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_gist(
3858                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
3859                 __isl_take isl_union_set *context);
3860         __isl_give isl_union_pw_qpolynomial_fold *
3861         isl_union_pw_qpolynomial_fold_gist_params(
3862                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
3863                 __isl_take isl_set *context);
3864
3865 The gist operation applies the gist operation to each of
3866 the cells in the domain of the input piecewise quasipolynomial reduction.
3867 In future, the operation will also exploit the context
3868 to simplify the quasipolynomial reductions associated to each cell.
3869
3870         __isl_give isl_pw_qpolynomial_fold *
3871         isl_set_apply_pw_qpolynomial_fold(
3872                 __isl_take isl_set *set,
3873                 __isl_take isl_pw_qpolynomial_fold *pwf,
3874                 int *tight);
3875         __isl_give isl_pw_qpolynomial_fold *
3876         isl_map_apply_pw_qpolynomial_fold(
3877                 __isl_take isl_map *map,
3878                 __isl_take isl_pw_qpolynomial_fold *pwf,
3879                 int *tight);
3880         __isl_give isl_union_pw_qpolynomial_fold *
3881         isl_union_set_apply_union_pw_qpolynomial_fold(
3882                 __isl_take isl_union_set *uset,
3883                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
3884                 int *tight);
3885         __isl_give isl_union_pw_qpolynomial_fold *
3886         isl_union_map_apply_union_pw_qpolynomial_fold(
3887                 __isl_take isl_union_map *umap,
3888                 __isl_take isl_union_pw_qpolynomial_fold *upwf,
3889                 int *tight);
3890
3891 The functions taking a map
3892 compose the given map with the given piecewise quasipolynomial reduction.
3893 That is, compute a bound (of the same type as C<pwf> or C<upwf> itself)
3894 over all elements in the intersection of the range of the map
3895 and the domain of the piecewise quasipolynomial reduction
3896 as a function of an element in the domain of the map.
3897 The functions taking a set compute a bound over all elements in the
3898 intersection of the set and the domain of the
3899 piecewise quasipolynomial reduction.
3900
3901 =head2 Dependence Analysis
3902
3903 C<isl> contains specialized functionality for performing
3904 array dataflow analysis.  That is, given a I<sink> access relation
3905 and a collection of possible I<source> access relations,
3906 C<isl> can compute relations that describe
3907 for each iteration of the sink access, which iteration
3908 of which of the source access relations was the last
3909 to access the same data element before the given iteration
3910 of the sink access.
3911 The resulting dependence relations map source iterations
3912 to the corresponding sink iterations.
3913 To compute standard flow dependences, the sink should be
3914 a read, while the sources should be writes.
3915 If any of the source accesses are marked as being I<may>
3916 accesses, then there will be a dependence from the last
3917 I<must> access B<and> from any I<may> access that follows
3918 this last I<must> access.
3919 In particular, if I<all> sources are I<may> accesses,
3920 then memory based dependence analysis is performed.
3921 If, on the other hand, all sources are I<must> accesses,
3922 then value based dependence analysis is performed.
3923
3924         #include <isl/flow.h>
3925
3926         typedef int (*isl_access_level_before)(void *first, void *second);
3927
3928         __isl_give isl_access_info *isl_access_info_alloc(
3929                 __isl_take isl_map *sink,
3930                 void *sink_user, isl_access_level_before fn,
3931                 int max_source);
3932         __isl_give isl_access_info *isl_access_info_add_source(
3933                 __isl_take isl_access_info *acc,
3934                 __isl_take isl_map *source, int must,
3935                 void *source_user);
3936         void isl_access_info_free(__isl_take isl_access_info *acc);
3937
3938         __isl_give isl_flow *isl_access_info_compute_flow(
3939                 __isl_take isl_access_info *acc);
3940
3941         int isl_flow_foreach(__isl_keep isl_flow *deps,
3942                 int (*fn)(__isl_take isl_map *dep, int must,
3943                           void *dep_user, void *user),
3944                 void *user);
3945         __isl_give isl_map *isl_flow_get_no_source(
3946                 __isl_keep isl_flow *deps, int must);
3947         void isl_flow_free(__isl_take isl_flow *deps);
3948
3949 The function C<isl_access_info_compute_flow> performs the actual
3950 dependence analysis.  The other functions are used to construct
3951 the input for this function or to read off the output.
3952
3953 The input is collected in an C<isl_access_info>, which can
3954 be created through a call to C<isl_access_info_alloc>.
3955 The arguments to this functions are the sink access relation
3956 C<sink>, a token C<sink_user> used to identify the sink
3957 access to the user, a callback function for specifying the
3958 relative order of source and sink accesses, and the number
3959 of source access relations that will be added.
3960 The callback function has type C<int (*)(void *first, void *second)>.
3961 The function is called with two user supplied tokens identifying
3962 either a source or the sink and it should return the shared nesting
3963 level and the relative order of the two accesses.
3964 In particular, let I<n> be the number of loops shared by
3965 the two accesses.  If C<first> precedes C<second> textually,
3966 then the function should return I<2 * n + 1>; otherwise,
3967 it should return I<2 * n>.
3968 The sources can be added to the C<isl_access_info> by performing
3969 (at most) C<max_source> calls to C<isl_access_info_add_source>.
3970 C<must> indicates whether the source is a I<must> access
3971 or a I<may> access.  Note that a multi-valued access relation
3972 should only be marked I<must> if every iteration in the domain
3973 of the relation accesses I<all> elements in its image.
3974 The C<source_user> token is again used to identify
3975 the source access.  The range of the source access relation
3976 C<source> should have the same dimension as the range
3977 of the sink access relation.
3978 The C<isl_access_info_free> function should usually not be
3979 called explicitly, because it is called implicitly by
3980 C<isl_access_info_compute_flow>.
3981
3982 The result of the dependence analysis is collected in an
3983 C<isl_flow>.  There may be elements of
3984 the sink access for which no preceding source access could be
3985 found or for which all preceding sources are I<may> accesses.
3986 The relations containing these elements can be obtained through
3987 calls to C<isl_flow_get_no_source>, the first with C<must> set
3988 and the second with C<must> unset.
3989 In the case of standard flow dependence analysis,
3990 with the sink a read and the sources I<must> writes,
3991 the first relation corresponds to the reads from uninitialized
3992 array elements and the second relation is empty.
3993 The actual flow dependences can be extracted using
3994 C<isl_flow_foreach>.  This function will call the user-specified
3995 callback function C<fn> for each B<non-empty> dependence between
3996 a source and the sink.  The callback function is called
3997 with four arguments, the actual flow dependence relation
3998 mapping source iterations to sink iterations, a boolean that
3999 indicates whether it is a I<must> or I<may> dependence, a token
4000 identifying the source and an additional C<void *> with value
4001 equal to the third argument of the C<isl_flow_foreach> call.
4002 A dependence is marked I<must> if it originates from a I<must>
4003 source and if it is not followed by any I<may> sources.
4004
4005 After finishing with an C<isl_flow>, the user should call
4006 C<isl_flow_free> to free all associated memory.
4007
4008 A higher-level interface to dependence analysis is provided
4009 by the following function.
4010
4011         #include <isl/flow.h>
4012
4013         int isl_union_map_compute_flow(__isl_take isl_union_map *sink,
4014                 __isl_take isl_union_map *must_source,
4015                 __isl_take isl_union_map *may_source,
4016                 __isl_take isl_union_map *schedule,
4017                 __isl_give isl_union_map **must_dep,
4018                 __isl_give isl_union_map **may_dep,
4019                 __isl_give isl_union_map **must_no_source,
4020                 __isl_give isl_union_map **may_no_source);
4021
4022 The arrays are identified by the tuple names of the ranges
4023 of the accesses.  The iteration domains by the tuple names
4024 of the domains of the accesses and of the schedule.
4025 The relative order of the iteration domains is given by the
4026 schedule.  The relations returned through C<must_no_source>
4027 and C<may_no_source> are subsets of C<sink>.
4028 Any of C<must_dep>, C<may_dep>, C<must_no_source>
4029 or C<may_no_source> may be C<NULL>, but a C<NULL> value for
4030 any of the other arguments is treated as an error.
4031
4032 =head2 Scheduling
4033
4034 B<The functionality described in this section is fairly new
4035 and may be subject to change.>
4036
4037 The following function can be used to compute a schedule
4038 for a union of domains.  The generated schedule respects
4039 all C<validity> dependences.  That is, all dependence distances
4040 over these dependences in the scheduled space are lexicographically
4041 positive.  The generated schedule schedule also tries to minimize
4042 the dependence distances over C<proximity> dependences.
4043 Moreover, it tries to obtain sequences (bands) of schedule dimensions
4044 for groups of domains where the dependence distances have only
4045 non-negative values.
4046 The algorithm used to construct the schedule is similar to that
4047 of C<Pluto>.
4048
4049         #include <isl/schedule.h>
4050         __isl_give isl_schedule *isl_union_set_compute_schedule(
4051                 __isl_take isl_union_set *domain,
4052                 __isl_take isl_union_map *validity,
4053                 __isl_take isl_union_map *proximity);
4054         void *isl_schedule_free(__isl_take isl_schedule *sched);
4055
4056 A mapping from the domains to the scheduled space can be obtained
4057 from an C<isl_schedule> using the following function.
4058
4059         __isl_give isl_union_map *isl_schedule_get_map(
4060                 __isl_keep isl_schedule *sched);
4061
4062 A representation of the schedule can be printed using
4063          
4064         __isl_give isl_printer *isl_printer_print_schedule(
4065                 __isl_take isl_printer *p,
4066                 __isl_keep isl_schedule *schedule);
4067
4068 A representation of the schedule as a forest of bands can be obtained
4069 using the following function.
4070
4071         __isl_give isl_band_list *isl_schedule_get_band_forest(
4072                 __isl_keep isl_schedule *schedule);
4073
4074 The list can be manipulated as explained in L<"Lists">.
4075 The bands inside the list can be copied and freed using the following
4076 functions.
4077
4078         #include <isl/band.h>
4079         __isl_give isl_band *isl_band_copy(
4080                 __isl_keep isl_band *band);
4081         void *isl_band_free(__isl_take isl_band *band);
4082
4083 Each band contains zero or more scheduling dimensions.
4084 These are referred to as the members of the band.
4085 The section of the schedule that corresponds to the band is
4086 referred to as the partial schedule of the band.
4087 For those nodes that participate in a band, the outer scheduling
4088 dimensions form the prefix schedule, while the inner scheduling
4089 dimensions form the suffix schedule.
4090 That is, if we take a cut of the band forest, then the union of
4091 the concatenations of the prefix, partial and suffix schedules of
4092 each band in the cut is equal to the entire schedule (modulo
4093 some possible padding at the end with zero scheduling dimensions).
4094 The properties of a band can be inspected using the following functions.
4095
4096         #include <isl/band.h>
4097         isl_ctx *isl_band_get_ctx(__isl_keep isl_band *band);
4098
4099         int isl_band_has_children(__isl_keep isl_band *band);
4100         __isl_give isl_band_list *isl_band_get_children(
4101                 __isl_keep isl_band *band);
4102
4103         __isl_give isl_union_map *isl_band_get_prefix_schedule(
4104                 __isl_keep isl_band *band);
4105         __isl_give isl_union_map *isl_band_get_partial_schedule(
4106                 __isl_keep isl_band *band);
4107         __isl_give isl_union_map *isl_band_get_suffix_schedule(
4108                 __isl_keep isl_band *band);
4109
4110         int isl_band_n_member(__isl_keep isl_band *band);
4111         int isl_band_member_is_zero_distance(
4112                 __isl_keep isl_band *band, int pos);
4113
4114 Note that a scheduling dimension is considered to be ``zero
4115 distance'' if it does not carry any proximity dependences
4116 within its band.
4117 That is, if the dependence distances of the proximity
4118 dependences are all zero in that direction (for fixed
4119 iterations of outer bands).
4120
4121 A representation of the band can be printed using
4122
4123         #include <isl/band.h>
4124         __isl_give isl_printer *isl_printer_print_band(
4125                 __isl_take isl_printer *p,
4126                 __isl_keep isl_band *band);
4127
4128 =head3 Options
4129
4130         #include <isl/schedule.h>
4131         int isl_options_set_schedule_maximize_band_depth(
4132                 isl_ctx *ctx, int val);
4133         int isl_options_get_schedule_maximize_band_depth(
4134                 isl_ctx *ctx);
4135         int isl_options_set_schedule_outer_zero_distance(
4136                 isl_ctx *ctx, int val);
4137         int isl_options_get_schedule_outer_zero_distance(
4138                 isl_ctx *ctx);
4139         int isl_options_set_schedule_split_parallel(
4140                 isl_ctx *ctx, int val);
4141         int isl_options_get_schedule_split_parallel(
4142                 isl_ctx *ctx);
4143
4144
4145 =over
4146
4147 =item * maximize_band_depth
4148
4149 If this option is set, we do not split bands at the point
4150 where we detect splitting is necessary. Instead, we
4151 backtrack and split bands as early as possible. This
4152 reduces the number of splits and maximizes the width of
4153 the bands. Wider bands give more possibilities for tiling.
4154
4155 =item * schedule_outer_zero_distance
4156
4157 It this option is set, then we try to construct schedules
4158 where the outermost scheduling dimension in each band
4159 results in a zero dependence distance over the proximity
4160 dependences.
4161
4162 =item * schedule_split_parallel
4163
4164 If this option is set, then we try to construct schedules in which the
4165 constant term is split off from the linear part if the linear parts of
4166 the scheduling rows for all nodes in the graphs are the same.
4167 The constant term is then placed in a separate band and the linear
4168 part is simplified.
4169
4170 =back
4171
4172 =head2 Parametric Vertex Enumeration
4173
4174 The parametric vertex enumeration described in this section
4175 is mainly intended to be used internally and by the C<barvinok>
4176 library.
4177
4178         #include <isl/vertices.h>
4179         __isl_give isl_vertices *isl_basic_set_compute_vertices(
4180                 __isl_keep isl_basic_set *bset);
4181
4182 The function C<isl_basic_set_compute_vertices> performs the
4183 actual computation of the parametric vertices and the chamber
4184 decomposition and store the result in an C<isl_vertices> object.
4185 This information can be queried by either iterating over all
4186 the vertices or iterating over all the chambers or cells
4187 and then iterating over all vertices that are active on the chamber.
4188
4189         int isl_vertices_foreach_vertex(
4190                 __isl_keep isl_vertices *vertices,
4191                 int (*fn)(__isl_take isl_vertex *vertex, void *user),
4192                 void *user);
4193
4194         int isl_vertices_foreach_cell(
4195                 __isl_keep isl_vertices *vertices,
4196                 int (*fn)(__isl_take isl_cell *cell, void *user),
4197                 void *user);
4198         int isl_cell_foreach_vertex(__isl_keep isl_cell *cell,
4199                 int (*fn)(__isl_take isl_vertex *vertex, void *user),
4200                 void *user);
4201
4202 Other operations that can be performed on an C<isl_vertices> object are
4203 the following.
4204
4205         isl_ctx *isl_vertices_get_ctx(
4206                 __isl_keep isl_vertices *vertices);
4207         int isl_vertices_get_n_vertices(
4208                 __isl_keep isl_vertices *vertices);
4209         void isl_vertices_free(__isl_take isl_vertices *vertices);
4210
4211 Vertices can be inspected and destroyed using the following functions.
4212
4213         isl_ctx *isl_vertex_get_ctx(__isl_keep isl_vertex *vertex);
4214         int isl_vertex_get_id(__isl_keep isl_vertex *vertex);
4215         __isl_give isl_basic_set *isl_vertex_get_domain(
4216                 __isl_keep isl_vertex *vertex);
4217         __isl_give isl_basic_set *isl_vertex_get_expr(
4218                 __isl_keep isl_vertex *vertex);
4219         void isl_vertex_free(__isl_take isl_vertex *vertex);
4220
4221 C<isl_vertex_get_expr> returns a singleton parametric set describing
4222 the vertex, while C<isl_vertex_get_domain> returns the activity domain
4223 of the vertex.
4224 Note that C<isl_vertex_get_domain> and C<isl_vertex_get_expr> return
4225 B<rational> basic sets, so they should mainly be used for inspection
4226 and should not be mixed with integer sets.
4227
4228 Chambers can be inspected and destroyed using the following functions.
4229
4230         isl_ctx *isl_cell_get_ctx(__isl_keep isl_cell *cell);
4231         __isl_give isl_basic_set *isl_cell_get_domain(
4232                 __isl_keep isl_cell *cell);
4233         void isl_cell_free(__isl_take isl_cell *cell);
4234
4235 =head1 Applications
4236
4237 Although C<isl> is mainly meant to be used as a library,
4238 it also contains some basic applications that use some
4239 of the functionality of C<isl>.
4240 The input may be specified in either the L<isl format>
4241 or the L<PolyLib format>.
4242
4243 =head2 C<isl_polyhedron_sample>
4244
4245 C<isl_polyhedron_sample> takes a polyhedron as input and prints
4246 an integer element of the polyhedron, if there is any.
4247 The first column in the output is the denominator and is always
4248 equal to 1.  If the polyhedron contains no integer points,
4249 then a vector of length zero is printed.
4250
4251 =head2 C<isl_pip>
4252
4253 C<isl_pip> takes the same input as the C<example> program
4254 from the C<piplib> distribution, i.e., a set of constraints
4255 on the parameters, a line containing only -1 and finally a set
4256 of constraints on a parametric polyhedron.
4257 The coefficients of the parameters appear in the last columns
4258 (but before the final constant column).
4259 The output is the lexicographic minimum of the parametric polyhedron.
4260 As C<isl> currently does not have its own output format, the output
4261 is just a dump of the internal state.
4262
4263 =head2 C<isl_polyhedron_minimize>
4264
4265 C<isl_polyhedron_minimize> computes the minimum of some linear
4266 or affine objective function over the integer points in a polyhedron.
4267 If an affine objective function
4268 is given, then the constant should appear in the last column.
4269
4270 =head2 C<isl_polytope_scan>
4271
4272 Given a polytope, C<isl_polytope_scan> prints
4273 all integer points in the polytope.