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