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