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