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
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.
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>.
23 =head2 Backward Incompatible Changes
25 =head3 Changes since isl-0.02
29 =item * The old printing functions have been deprecated
30 and replaced by C<isl_printer> functions, see L<Input and Output>.
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>.
38 =head3 Changes since isl-0.03
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>.
49 =head3 Changes since isl-0.04
53 =item * All header files have been renamed from C<isl_header.h>
58 =head3 Changes since isl-0.05
62 =item * The functions C<isl_printer_print_basic_set> and
63 C<isl_printer_print_basic_map> no longer print a newline.
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.
70 =item * The functions C<isl_basic_map_identity> and
71 C<isl_map_identity> now take a B<map> space as input. An old call
72 C<isl_map_identity(space)> can be rewritten to
73 C<isl_map_identity(isl_space_map_from_set(space))>.
75 =item * The function C<isl_map_power> no longer takes
76 a parameter position as input. Instead, the exponent
77 is now expressed as the domain of the resulting relation.
81 =head3 Changes since isl-0.06
85 =item * The format of C<isl_printer_print_qpolynomial>'s
86 C<ISL_FORMAT_ISL> output has changed.
87 Use C<ISL_FORMAT_C> to obtain the old output.
89 =item * The C<*_fast_*> functions have been renamed to C<*_plain_*>.
90 Some of the old names have been kept for backward compatibility,
91 but they will be removed in the future.
95 =head3 Changes since isl-0.07
99 =item * The function C<isl_pw_aff_max> has been renamed to
100 C<isl_pw_aff_union_max>.
101 Similarly, the function C<isl_pw_aff_add> has been renamed to
102 C<isl_pw_aff_union_add>.
104 =item * The C<isl_dim> type has been renamed to C<isl_space>
105 along with the associated functions.
106 Some of the old names have been kept for backward compatibility,
107 but they will be removed in the future.
109 =item * Spaces of maps, sets and parameter domains are now
110 treated differently. The distinction between map spaces and set spaces
111 has always been made on a conceptual level, but proper use of such spaces
112 was never checked. Furthermore, up until isl-0.07 there was no way
113 of explicitly creating a parameter space. These can now be created
114 directly using C<isl_space_params_alloc> or from other spaces using
117 =item * The space in which C<isl_aff>, C<isl_pw_aff>, C<isl_qpolynomial>,
118 C<isl_pw_qpolynomial>, C<isl_qpolynomial_fold> and C<isl_pw_qpolynomial_fold>
119 objects live is now a map space
120 instead of a set space. This means, for example, that the dimensions
121 of the domain of an C<isl_aff> are now considered to be of type
122 C<isl_dim_in> instead of C<isl_dim_set>. Extra functions have been
123 added to obtain the domain space. Some of the constructors still
124 take a domain space and have therefore been renamed.
126 =item * The functions C<isl_equality_alloc> and C<isl_inequality_alloc>
127 now take an C<isl_local_space> instead of an C<isl_space>.
128 An C<isl_local_space> can be created from an C<isl_space>
129 using C<isl_local_space_from_space>.
131 =item * The C<isl_div> type has been removed. Functions that used
132 to return an C<isl_div> now return an C<isl_aff>.
133 Note that the space of an C<isl_aff> is that of relation.
134 When replacing a call to C<isl_div_get_coefficient> by a call to
135 C<isl_aff_get_coefficient> any C<isl_dim_set> argument needs
136 to be replaced by C<isl_dim_in>.
137 A call to C<isl_aff_from_div> can be replaced by a call
139 A call to C<isl_qpolynomial_div(div)> call be replaced by
142 isl_qpolynomial_from_aff(isl_aff_floor(div))
144 The function C<isl_constraint_div> has also been renamed
145 to C<isl_constraint_get_div>.
147 =item * The C<nparam> argument has been removed from
148 C<isl_map_read_from_str> and similar functions.
149 When reading input in the original PolyLib format,
150 the result will have no parameters.
151 If parameters are expected, the caller may want to perform
152 dimension manipulation on the result.
156 =head3 Changes since isl-0.09
160 =item * The C<schedule_split_parallel> option has been replaced
161 by the C<schedule_split_scaled> option.
163 =item * The first argument of C<isl_pw_aff_cond> is now
164 an C<isl_pw_aff> instead of an C<isl_set>.
165 A call C<isl_pw_aff_cond(a, b, c)> can be replaced by
167 isl_pw_aff_cond(isl_set_indicator_function(a), b, c)
171 =head3 Changes since isl-0.10
175 =item * The functions C<isl_set_dim_has_lower_bound> and
176 C<isl_set_dim_has_upper_bound> have been renamed to
177 C<isl_set_dim_has_any_lower_bound> and
178 C<isl_set_dim_has_any_upper_bound>.
179 The new C<isl_set_dim_has_lower_bound> and
180 C<isl_set_dim_has_upper_bound> have slightly different meanings.
184 =head3 Changes since isl-0.12
188 =item * C<isl_int> has been replaced by C<isl_val>.
189 Some of the old functions are still available in C<isl/deprecated/*.h>
190 but they will be removed in the future.
192 =item * The functions C<isl_pw_qpolynomial_eval>,
193 C<isl_union_pw_qpolynomial_eval>, C<isl_pw_qpolynomial_fold_eval>
194 and C<isl_union_pw_qpolynomial_fold_eval> have been changed to return
195 an C<isl_val> instead of an C<isl_qpolynomial>.
201 C<isl> is released under the MIT license.
205 Permission is hereby granted, free of charge, to any person obtaining a copy of
206 this software and associated documentation files (the "Software"), to deal in
207 the Software without restriction, including without limitation the rights to
208 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
209 of the Software, and to permit persons to whom the Software is furnished to do
210 so, subject to the following conditions:
212 The above copyright notice and this permission notice shall be included in all
213 copies or substantial portions of the Software.
215 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
216 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
217 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
218 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
219 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
220 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
225 Note that C<isl> currently requires C<GMP>, which is released
226 under the GNU Lesser General Public License (LGPL). This means
227 that code linked against C<isl> is also linked against LGPL code.
231 The source of C<isl> can be obtained either as a tarball
232 or from the git repository. Both are available from
233 L<http://freshmeat.net/projects/isl/>.
234 The installation process depends on how you obtained
237 =head2 Installation from the git repository
241 =item 1 Clone or update the repository
243 The first time the source is obtained, you need to clone
246 git clone git://repo.or.cz/isl.git
248 To obtain updates, you need to pull in the latest changes
252 =item 2 Generate C<configure>
258 After performing the above steps, continue
259 with the L<Common installation instructions>.
261 =head2 Common installation instructions
265 =item 1 Obtain C<GMP>
267 Building C<isl> requires C<GMP>, including its headers files.
268 Your distribution may not provide these header files by default
269 and you may need to install a package called C<gmp-devel> or something
270 similar. Alternatively, C<GMP> can be built from
271 source, available from L<http://gmplib.org/>.
275 C<isl> uses the standard C<autoconf> C<configure> script.
280 optionally followed by some configure options.
281 A complete list of options can be obtained by running
285 Below we discuss some of the more common options.
291 Installation prefix for C<isl>
293 =item C<--with-gmp-prefix>
295 Installation prefix for C<GMP> (architecture-independent files).
297 =item C<--with-gmp-exec-prefix>
299 Installation prefix for C<GMP> (architecture-dependent files).
307 =item 4 Install (optional)
313 =head1 Integer Set Library
315 =head2 Initialization
317 All manipulations of integer sets and relations occur within
318 the context of an C<isl_ctx>.
319 A given C<isl_ctx> can only be used within a single thread.
320 All arguments of a function are required to have been allocated
321 within the same context.
322 There are currently no functions available for moving an object
323 from one C<isl_ctx> to another C<isl_ctx>. This means that
324 there is currently no way of safely moving an object from one
325 thread to another, unless the whole C<isl_ctx> is moved.
327 An C<isl_ctx> can be allocated using C<isl_ctx_alloc> and
328 freed using C<isl_ctx_free>.
329 All objects allocated within an C<isl_ctx> should be freed
330 before the C<isl_ctx> itself is freed.
332 isl_ctx *isl_ctx_alloc();
333 void isl_ctx_free(isl_ctx *ctx);
337 An C<isl_val> represents an integer value, a rational value
338 or one of three special values, infinity, negative infinity and NaN.
339 Some predefined values can be created using the following functions.
342 __isl_give isl_val *isl_val_zero(isl_ctx *ctx);
343 __isl_give isl_val *isl_val_one(isl_ctx *ctx);
344 __isl_give isl_val *isl_val_nan(isl_ctx *ctx);
345 __isl_give isl_val *isl_val_infty(isl_ctx *ctx);
346 __isl_give isl_val *isl_val_neginfty(isl_ctx *ctx);
348 Specific integer values can be created using the following functions.
351 __isl_give isl_val *isl_val_int_from_si(isl_ctx *ctx,
353 __isl_give isl_val *isl_val_int_from_ui(isl_ctx *ctx,
355 __isl_give isl_val *isl_val_int_from_chunks(isl_ctx *ctx,
356 size_t n, size_t size, const void *chunks);
358 The function C<isl_val_int_from_chunks> constructs an C<isl_val>
359 from the C<n> I<digits>, each consisting of C<size> bytes, stored at C<chunks>.
360 The least significant digit is assumed to be stored first.
362 Value objects can be copied and freed using the following functions.
365 __isl_give isl_val *isl_val_copy(__isl_keep isl_val *v);
366 void *isl_val_free(__isl_take isl_val *v);
368 They can be inspected using the following functions.
371 isl_ctx *isl_val_get_ctx(__isl_keep isl_val *val);
372 long isl_val_get_num_si(__isl_keep isl_val *v);
373 long isl_val_get_den_si(__isl_keep isl_val *v);
374 double isl_val_get_d(__isl_keep isl_val *v);
375 size_t isl_val_n_abs_num_chunks(__isl_keep isl_val *v,
377 int isl_val_get_abs_num_chunks(__isl_keep isl_val *v,
378 size_t size, void *chunks);
380 C<isl_val_n_abs_num_chunks> returns the number of I<digits>
381 of C<size> bytes needed to store the absolute value of the
383 C<isl_val_get_abs_num_chunks> stores these digits at C<chunks>,
384 which is assumed to have been preallocated by the caller.
385 The least significant digit is stored first.
386 Note that C<isl_val_get_num_si>, C<isl_val_get_den_si>,
387 C<isl_val_get_d>, C<isl_val_n_abs_num_chunks>
388 and C<isl_val_get_abs_num_chunks> can only be applied to rational values.
390 An C<isl_val> can be modified using the following function.
393 __isl_give isl_val *isl_val_set_si(__isl_take isl_val *v,
396 The following unary properties are defined on C<isl_val>s.
399 int isl_val_sgn(__isl_keep isl_val *v);
400 int isl_val_is_zero(__isl_keep isl_val *v);
401 int isl_val_is_one(__isl_keep isl_val *v);
402 int isl_val_is_negone(__isl_keep isl_val *v);
403 int isl_val_is_nonneg(__isl_keep isl_val *v);
404 int isl_val_is_nonpos(__isl_keep isl_val *v);
405 int isl_val_is_pos(__isl_keep isl_val *v);
406 int isl_val_is_neg(__isl_keep isl_val *v);
407 int isl_val_is_int(__isl_keep isl_val *v);
408 int isl_val_is_rat(__isl_keep isl_val *v);
409 int isl_val_is_nan(__isl_keep isl_val *v);
410 int isl_val_is_infty(__isl_keep isl_val *v);
411 int isl_val_is_neginfty(__isl_keep isl_val *v);
413 Note that the sign of NaN is undefined.
415 The following binary properties are defined on pairs of C<isl_val>s.
418 int isl_val_lt(__isl_keep isl_val *v1,
419 __isl_keep isl_val *v2);
420 int isl_val_le(__isl_keep isl_val *v1,
421 __isl_keep isl_val *v2);
422 int isl_val_gt(__isl_keep isl_val *v1,
423 __isl_keep isl_val *v2);
424 int isl_val_ge(__isl_keep isl_val *v1,
425 __isl_keep isl_val *v2);
426 int isl_val_eq(__isl_keep isl_val *v1,
427 __isl_keep isl_val *v2);
428 int isl_val_ne(__isl_keep isl_val *v1,
429 __isl_keep isl_val *v2);
431 For integer C<isl_val>s we additionally have the following binary property.
434 int isl_val_is_divisible_by(__isl_keep isl_val *v1,
435 __isl_keep isl_val *v2);
437 An C<isl_val> can also be compared to an integer using the following
438 function. The result is undefined for NaN.
441 int isl_val_cmp_si(__isl_keep isl_val *v, long i);
443 The following unary operations are available on C<isl_val>s.
446 __isl_give isl_val *isl_val_abs(__isl_take isl_val *v);
447 __isl_give isl_val *isl_val_neg(__isl_take isl_val *v);
448 __isl_give isl_val *isl_val_floor(__isl_take isl_val *v);
449 __isl_give isl_val *isl_val_ceil(__isl_take isl_val *v);
450 __isl_give isl_val *isl_val_trunc(__isl_take isl_val *v);
452 The following binary operations are available on C<isl_val>s.
455 __isl_give isl_val *isl_val_abs(__isl_take isl_val *v);
456 __isl_give isl_val *isl_val_neg(__isl_take isl_val *v);
457 __isl_give isl_val *isl_val_floor(__isl_take isl_val *v);
458 __isl_give isl_val *isl_val_ceil(__isl_take isl_val *v);
459 __isl_give isl_val *isl_val_trunc(__isl_take isl_val *v);
460 __isl_give isl_val *isl_val_2exp(__isl_take isl_val *v);
461 __isl_give isl_val *isl_val_min(__isl_take isl_val *v1,
462 __isl_take isl_val *v2);
463 __isl_give isl_val *isl_val_max(__isl_take isl_val *v1,
464 __isl_take isl_val *v2);
465 __isl_give isl_val *isl_val_add(__isl_take isl_val *v1,
466 __isl_take isl_val *v2);
467 __isl_give isl_val *isl_val_add_ui(__isl_take isl_val *v1,
469 __isl_give isl_val *isl_val_sub(__isl_take isl_val *v1,
470 __isl_take isl_val *v2);
471 __isl_give isl_val *isl_val_sub_ui(__isl_take isl_val *v1,
473 __isl_give isl_val *isl_val_mul(__isl_take isl_val *v1,
474 __isl_take isl_val *v2);
475 __isl_give isl_val *isl_val_mul_ui(__isl_take isl_val *v1,
477 __isl_give isl_val *isl_val_div(__isl_take isl_val *v1,
478 __isl_take isl_val *v2);
480 On integer values, we additionally have the following operations.
483 __isl_give isl_val *isl_val_2exp(__isl_take isl_val *v);
484 __isl_give isl_val *isl_val_mod(__isl_take isl_val *v1,
485 __isl_take isl_val *v2);
486 __isl_give isl_val *isl_val_gcd(__isl_take isl_val *v1,
487 __isl_take isl_val *v2);
488 __isl_give isl_val *isl_val_gcdext(__isl_take isl_val *v1,
489 __isl_take isl_val *v2, __isl_give isl_val **x,
490 __isl_give isl_val **y);
492 The function C<isl_val_gcdext> returns the greatest common divisor g
493 of C<v1> and C<v2> as well as two integers C<*x> and C<*y> such
494 that C<*x> * C<v1> + C<*y> * C<v2> = g.
496 A value can be read from input using
499 __isl_give isl_val *isl_val_read_from_str(isl_ctx *ctx,
502 A value can be printed using
505 __isl_give isl_printer *isl_printer_print_val(
506 __isl_take isl_printer *p, __isl_keep isl_val *v);
508 =head3 GMP specific functions
510 These functions are only available if C<isl> has been compiled with C<GMP>
513 Specific integer and rational values can be created from C<GMP> values using
514 the following functions.
516 #include <isl/val_gmp.h>
517 __isl_give isl_val *isl_val_int_from_gmp(isl_ctx *ctx,
519 __isl_give isl_val *isl_val_from_gmp(isl_ctx *ctx,
520 const mpz_t n, const mpz_t d);
522 The numerator and denominator of a rational value can be extracted as
523 C<GMP> values using the following functions.
525 #include <isl/val_gmp.h>
526 int isl_val_get_num_gmp(__isl_keep isl_val *v, mpz_t z);
527 int isl_val_get_den_gmp(__isl_keep isl_val *v, mpz_t z);
529 =head2 Sets and Relations
531 C<isl> uses six types of objects for representing sets and relations,
532 C<isl_basic_set>, C<isl_basic_map>, C<isl_set>, C<isl_map>,
533 C<isl_union_set> and C<isl_union_map>.
534 C<isl_basic_set> and C<isl_basic_map> represent sets and relations that
535 can be described as a conjunction of affine constraints, while
536 C<isl_set> and C<isl_map> represent unions of
537 C<isl_basic_set>s and C<isl_basic_map>s, respectively.
538 However, all C<isl_basic_set>s or C<isl_basic_map>s in the union need
539 to live in the same space. C<isl_union_set>s and C<isl_union_map>s
540 represent unions of C<isl_set>s or C<isl_map>s in I<different> spaces,
541 where spaces are considered different if they have a different number
542 of dimensions and/or different names (see L<"Spaces">).
543 The difference between sets and relations (maps) is that sets have
544 one set of variables, while relations have two sets of variables,
545 input variables and output variables.
547 =head2 Memory Management
549 Since a high-level operation on sets and/or relations usually involves
550 several substeps and since the user is usually not interested in
551 the intermediate results, most functions that return a new object
552 will also release all the objects passed as arguments.
553 If the user still wants to use one or more of these arguments
554 after the function call, she should pass along a copy of the
555 object rather than the object itself.
556 The user is then responsible for making sure that the original
557 object gets used somewhere else or is explicitly freed.
559 The arguments and return values of all documented functions are
560 annotated to make clear which arguments are released and which
561 arguments are preserved. In particular, the following annotations
568 C<__isl_give> means that a new object is returned.
569 The user should make sure that the returned pointer is
570 used exactly once as a value for an C<__isl_take> argument.
571 In between, it can be used as a value for as many
572 C<__isl_keep> arguments as the user likes.
573 There is one exception, and that is the case where the
574 pointer returned is C<NULL>. Is this case, the user
575 is free to use it as an C<__isl_take> argument or not.
579 C<__isl_take> means that the object the argument points to
580 is taken over by the function and may no longer be used
581 by the user as an argument to any other function.
582 The pointer value must be one returned by a function
583 returning an C<__isl_give> pointer.
584 If the user passes in a C<NULL> value, then this will
585 be treated as an error in the sense that the function will
586 not perform its usual operation. However, it will still
587 make sure that all the other C<__isl_take> arguments
592 C<__isl_keep> means that the function will only use the object
593 temporarily. After the function has finished, the user
594 can still use it as an argument to other functions.
595 A C<NULL> value will be treated in the same way as
596 a C<NULL> value for an C<__isl_take> argument.
600 =head2 Error Handling
602 C<isl> supports different ways to react in case a runtime error is triggered.
603 Runtime errors arise, e.g., if a function such as C<isl_map_intersect> is called
604 with two maps that have incompatible spaces. There are three possible ways
605 to react on error: to warn, to continue or to abort.
607 The default behavior is to warn. In this mode, C<isl> prints a warning, stores
608 the last error in the corresponding C<isl_ctx> and the function in which the
609 error was triggered returns C<NULL>. An error does not corrupt internal state,
610 such that isl can continue to be used. C<isl> also provides functions to
611 read the last error and to reset the memory that stores the last error. The
612 last error is only stored for information purposes. Its presence does not
613 change the behavior of C<isl>. Hence, resetting an error is not required to
614 continue to use isl, but only to observe new errors.
617 enum isl_error isl_ctx_last_error(isl_ctx *ctx);
618 void isl_ctx_reset_error(isl_ctx *ctx);
620 Another option is to continue on error. This is similar to warn on error mode,
621 except that C<isl> does not print any warning. This allows a program to
622 implement its own error reporting.
624 The last option is to directly abort the execution of the program from within
625 the isl library. This makes it obviously impossible to recover from an error,
626 but it allows to directly spot the error location. By aborting on error,
627 debuggers break at the location the error occurred and can provide a stack
628 trace. Other tools that automatically provide stack traces on abort or that do
629 not want to continue execution after an error was triggered may also prefer to
632 The on error behavior of isl can be specified by calling
633 C<isl_options_set_on_error> or by setting the command line option
634 C<--isl-on-error>. Valid arguments for the function call are
635 C<ISL_ON_ERROR_WARN>, C<ISL_ON_ERROR_CONTINUE> and C<ISL_ON_ERROR_ABORT>. The
636 choices for the command line option are C<warn>, C<continue> and C<abort>.
637 It is also possible to query the current error mode.
639 #include <isl/options.h>
640 int isl_options_set_on_error(isl_ctx *ctx, int val);
641 int isl_options_get_on_error(isl_ctx *ctx);
645 Identifiers are used to identify both individual dimensions
646 and tuples of dimensions. They consist of an optional name and an optional
647 user pointer. The name and the user pointer cannot both be C<NULL>, however.
648 Identifiers with the same name but different pointer values
649 are considered to be distinct.
650 Similarly, identifiers with different names but the same pointer value
651 are also considered to be distinct.
652 Equal identifiers are represented using the same object.
653 Pairs of identifiers can therefore be tested for equality using the
655 Identifiers can be constructed, copied, freed, inspected and printed
656 using the following functions.
659 __isl_give isl_id *isl_id_alloc(isl_ctx *ctx,
660 __isl_keep const char *name, void *user);
661 __isl_give isl_id *isl_id_set_free_user(
662 __isl_take isl_id *id,
663 __isl_give void (*free_user)(void *user));
664 __isl_give isl_id *isl_id_copy(isl_id *id);
665 void *isl_id_free(__isl_take isl_id *id);
667 isl_ctx *isl_id_get_ctx(__isl_keep isl_id *id);
668 void *isl_id_get_user(__isl_keep isl_id *id);
669 __isl_keep const char *isl_id_get_name(__isl_keep isl_id *id);
671 __isl_give isl_printer *isl_printer_print_id(
672 __isl_take isl_printer *p, __isl_keep isl_id *id);
674 The callback set by C<isl_id_set_free_user> is called on the user
675 pointer when the last reference to the C<isl_id> is freed.
676 Note that C<isl_id_get_name> returns a pointer to some internal
677 data structure, so the result can only be used while the
678 corresponding C<isl_id> is alive.
682 Whenever a new set, relation or similiar object is created from scratch,
683 the space in which it lives needs to be specified using an C<isl_space>.
684 Each space involves zero or more parameters and zero, one or two
685 tuples of set or input/output dimensions. The parameters and dimensions
686 are identified by an C<isl_dim_type> and a position.
687 The type C<isl_dim_param> refers to parameters,
688 the type C<isl_dim_set> refers to set dimensions (for spaces
689 with a single tuple of dimensions) and the types C<isl_dim_in>
690 and C<isl_dim_out> refer to input and output dimensions
691 (for spaces with two tuples of dimensions).
692 Local spaces (see L</"Local Spaces">) also contain dimensions
693 of type C<isl_dim_div>.
694 Note that parameters are only identified by their position within
695 a given object. Across different objects, parameters are (usually)
696 identified by their names or identifiers. Only unnamed parameters
697 are identified by their positions across objects. The use of unnamed
698 parameters is discouraged.
700 #include <isl/space.h>
701 __isl_give isl_space *isl_space_alloc(isl_ctx *ctx,
702 unsigned nparam, unsigned n_in, unsigned n_out);
703 __isl_give isl_space *isl_space_params_alloc(isl_ctx *ctx,
705 __isl_give isl_space *isl_space_set_alloc(isl_ctx *ctx,
706 unsigned nparam, unsigned dim);
707 __isl_give isl_space *isl_space_copy(__isl_keep isl_space *space);
708 void *isl_space_free(__isl_take isl_space *space);
709 unsigned isl_space_dim(__isl_keep isl_space *space,
710 enum isl_dim_type type);
712 The space used for creating a parameter domain
713 needs to be created using C<isl_space_params_alloc>.
714 For other sets, the space
715 needs to be created using C<isl_space_set_alloc>, while
716 for a relation, the space
717 needs to be created using C<isl_space_alloc>.
718 C<isl_space_dim> can be used
719 to find out the number of dimensions of each type in
720 a space, where type may be
721 C<isl_dim_param>, C<isl_dim_in> (only for relations),
722 C<isl_dim_out> (only for relations), C<isl_dim_set>
723 (only for sets) or C<isl_dim_all>.
725 To check whether a given space is that of a set or a map
726 or whether it is a parameter space, use these functions:
728 #include <isl/space.h>
729 int isl_space_is_params(__isl_keep isl_space *space);
730 int isl_space_is_set(__isl_keep isl_space *space);
731 int isl_space_is_map(__isl_keep isl_space *space);
733 Spaces can be compared using the following functions:
735 #include <isl/space.h>
736 int isl_space_is_equal(__isl_keep isl_space *space1,
737 __isl_keep isl_space *space2);
738 int isl_space_is_domain(__isl_keep isl_space *space1,
739 __isl_keep isl_space *space2);
740 int isl_space_is_range(__isl_keep isl_space *space1,
741 __isl_keep isl_space *space2);
743 C<isl_space_is_domain> checks whether the first argument is equal
744 to the domain of the second argument. This requires in particular that
745 the first argument is a set space and that the second argument
748 It is often useful to create objects that live in the
749 same space as some other object. This can be accomplished
750 by creating the new objects
751 (see L<Creating New Sets and Relations> or
752 L<Creating New (Piecewise) Quasipolynomials>) based on the space
753 of the original object.
756 __isl_give isl_space *isl_basic_set_get_space(
757 __isl_keep isl_basic_set *bset);
758 __isl_give isl_space *isl_set_get_space(__isl_keep isl_set *set);
760 #include <isl/union_set.h>
761 __isl_give isl_space *isl_union_set_get_space(
762 __isl_keep isl_union_set *uset);
765 __isl_give isl_space *isl_basic_map_get_space(
766 __isl_keep isl_basic_map *bmap);
767 __isl_give isl_space *isl_map_get_space(__isl_keep isl_map *map);
769 #include <isl/union_map.h>
770 __isl_give isl_space *isl_union_map_get_space(
771 __isl_keep isl_union_map *umap);
773 #include <isl/constraint.h>
774 __isl_give isl_space *isl_constraint_get_space(
775 __isl_keep isl_constraint *constraint);
777 #include <isl/polynomial.h>
778 __isl_give isl_space *isl_qpolynomial_get_domain_space(
779 __isl_keep isl_qpolynomial *qp);
780 __isl_give isl_space *isl_qpolynomial_get_space(
781 __isl_keep isl_qpolynomial *qp);
782 __isl_give isl_space *isl_qpolynomial_fold_get_space(
783 __isl_keep isl_qpolynomial_fold *fold);
784 __isl_give isl_space *isl_pw_qpolynomial_get_domain_space(
785 __isl_keep isl_pw_qpolynomial *pwqp);
786 __isl_give isl_space *isl_pw_qpolynomial_get_space(
787 __isl_keep isl_pw_qpolynomial *pwqp);
788 __isl_give isl_space *isl_pw_qpolynomial_fold_get_domain_space(
789 __isl_keep isl_pw_qpolynomial_fold *pwf);
790 __isl_give isl_space *isl_pw_qpolynomial_fold_get_space(
791 __isl_keep isl_pw_qpolynomial_fold *pwf);
792 __isl_give isl_space *isl_union_pw_qpolynomial_get_space(
793 __isl_keep isl_union_pw_qpolynomial *upwqp);
794 __isl_give isl_space *isl_union_pw_qpolynomial_fold_get_space(
795 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
798 __isl_give isl_space *isl_multi_val_get_space(
799 __isl_keep isl_multi_val *mv);
802 __isl_give isl_space *isl_aff_get_domain_space(
803 __isl_keep isl_aff *aff);
804 __isl_give isl_space *isl_aff_get_space(
805 __isl_keep isl_aff *aff);
806 __isl_give isl_space *isl_pw_aff_get_domain_space(
807 __isl_keep isl_pw_aff *pwaff);
808 __isl_give isl_space *isl_pw_aff_get_space(
809 __isl_keep isl_pw_aff *pwaff);
810 __isl_give isl_space *isl_multi_aff_get_domain_space(
811 __isl_keep isl_multi_aff *maff);
812 __isl_give isl_space *isl_multi_aff_get_space(
813 __isl_keep isl_multi_aff *maff);
814 __isl_give isl_space *isl_pw_multi_aff_get_domain_space(
815 __isl_keep isl_pw_multi_aff *pma);
816 __isl_give isl_space *isl_pw_multi_aff_get_space(
817 __isl_keep isl_pw_multi_aff *pma);
818 __isl_give isl_space *isl_union_pw_multi_aff_get_space(
819 __isl_keep isl_union_pw_multi_aff *upma);
820 __isl_give isl_space *isl_multi_pw_aff_get_domain_space(
821 __isl_keep isl_multi_pw_aff *mpa);
822 __isl_give isl_space *isl_multi_pw_aff_get_space(
823 __isl_keep isl_multi_pw_aff *mpa);
825 #include <isl/point.h>
826 __isl_give isl_space *isl_point_get_space(
827 __isl_keep isl_point *pnt);
829 The identifiers or names of the individual dimensions may be set or read off
830 using the following functions.
832 #include <isl/space.h>
833 __isl_give isl_space *isl_space_set_dim_id(
834 __isl_take isl_space *space,
835 enum isl_dim_type type, unsigned pos,
836 __isl_take isl_id *id);
837 int isl_space_has_dim_id(__isl_keep isl_space *space,
838 enum isl_dim_type type, unsigned pos);
839 __isl_give isl_id *isl_space_get_dim_id(
840 __isl_keep isl_space *space,
841 enum isl_dim_type type, unsigned pos);
842 __isl_give isl_space *isl_space_set_dim_name(
843 __isl_take isl_space *space,
844 enum isl_dim_type type, unsigned pos,
845 __isl_keep const char *name);
846 int isl_space_has_dim_name(__isl_keep isl_space *space,
847 enum isl_dim_type type, unsigned pos);
848 __isl_keep const char *isl_space_get_dim_name(
849 __isl_keep isl_space *space,
850 enum isl_dim_type type, unsigned pos);
852 Note that C<isl_space_get_name> returns a pointer to some internal
853 data structure, so the result can only be used while the
854 corresponding C<isl_space> is alive.
855 Also note that every function that operates on two sets or relations
856 requires that both arguments have the same parameters. This also
857 means that if one of the arguments has named parameters, then the
858 other needs to have named parameters too and the names need to match.
859 Pairs of C<isl_set>, C<isl_map>, C<isl_union_set> and/or C<isl_union_map>
860 arguments may have different parameters (as long as they are named),
861 in which case the result will have as parameters the union of the parameters of
864 Given the identifier or name of a dimension (typically a parameter),
865 its position can be obtained from the following function.
867 #include <isl/space.h>
868 int isl_space_find_dim_by_id(__isl_keep isl_space *space,
869 enum isl_dim_type type, __isl_keep isl_id *id);
870 int isl_space_find_dim_by_name(__isl_keep isl_space *space,
871 enum isl_dim_type type, const char *name);
873 The identifiers or names of entire spaces may be set or read off
874 using the following functions.
876 #include <isl/space.h>
877 __isl_give isl_space *isl_space_set_tuple_id(
878 __isl_take isl_space *space,
879 enum isl_dim_type type, __isl_take isl_id *id);
880 __isl_give isl_space *isl_space_reset_tuple_id(
881 __isl_take isl_space *space, enum isl_dim_type type);
882 int isl_space_has_tuple_id(__isl_keep isl_space *space,
883 enum isl_dim_type type);
884 __isl_give isl_id *isl_space_get_tuple_id(
885 __isl_keep isl_space *space, enum isl_dim_type type);
886 __isl_give isl_space *isl_space_set_tuple_name(
887 __isl_take isl_space *space,
888 enum isl_dim_type type, const char *s);
889 int isl_space_has_tuple_name(__isl_keep isl_space *space,
890 enum isl_dim_type type);
891 const char *isl_space_get_tuple_name(__isl_keep isl_space *space,
892 enum isl_dim_type type);
894 The C<type> argument needs to be one of C<isl_dim_in>, C<isl_dim_out>
895 or C<isl_dim_set>. As with C<isl_space_get_name>,
896 the C<isl_space_get_tuple_name> function returns a pointer to some internal
898 Binary operations require the corresponding spaces of their arguments
899 to have the same name.
901 To keep the names of all parameters and tuples, but reset the user pointers
902 of all the corresponding identifiers, use the following function.
904 __isl_give isl_space *isl_space_reset_user(
905 __isl_take isl_space *space);
907 Spaces can be nested. In particular, the domain of a set or
908 the domain or range of a relation can be a nested relation.
909 The following functions can be used to construct and deconstruct
912 #include <isl/space.h>
913 int isl_space_is_wrapping(__isl_keep isl_space *space);
914 int isl_space_range_is_wrapping(
915 __isl_keep isl_space *space);
916 __isl_give isl_space *isl_space_wrap(__isl_take isl_space *space);
917 __isl_give isl_space *isl_space_unwrap(__isl_take isl_space *space);
918 __isl_give isl_space *isl_space_product(__isl_take isl_space *space1,
919 __isl_take isl_space *space2);
920 __isl_give isl_space *isl_space_domain_product(
921 __isl_take isl_space *space1,
922 __isl_take isl_space *space2);
923 __isl_give isl_space *isl_space_range_product(
924 __isl_take isl_space *space1,
925 __isl_take isl_space *space2);
926 __isl_give isl_space *isl_space_range_factor_domain(
927 __isl_take isl_space *space);
928 __isl_give isl_space *isl_space_range_factor_range(
929 __isl_take isl_space *space);
931 The input to C<isl_space_is_wrapping> and C<isl_space_unwrap> should
932 be the space of a set, while that of
933 C<isl_space_range_is_wrapping> and
934 C<isl_space_wrap> should be the space of a relation.
935 Conversely, the output of C<isl_space_unwrap> is the space
936 of a relation, while that of C<isl_space_wrap> is the space of a set.
938 C<isl_space_product>, C<isl_space_domain_product>
939 and C<isl_space_range_product> take pairs or relation spaces and
940 produce a single relations space, where either the domain, the range
941 or both domain and range are wrapped spaces of relations between
942 the domains and/or ranges of the input spaces.
943 If the product is only constructed over the domain or the range
944 then the ranges or the domains of the inputs should be the same.
945 The functions C<isl_space_range_factor_domain> and
946 C<isl_space_range_factor_range> extract the two arguments from
947 the result of a call to C<isl_space_range_product>.
949 Spaces can be created from other spaces
950 using the following functions.
952 __isl_give isl_space *isl_space_domain(__isl_take isl_space *space);
953 __isl_give isl_space *isl_space_from_domain(__isl_take isl_space *space);
954 __isl_give isl_space *isl_space_range(__isl_take isl_space *space);
955 __isl_give isl_space *isl_space_from_range(__isl_take isl_space *space);
956 __isl_give isl_space *isl_space_domain_map(
957 __isl_take isl_space *space);
958 __isl_give isl_space *isl_space_range_map(
959 __isl_take isl_space *space);
960 __isl_give isl_space *isl_space_params(
961 __isl_take isl_space *space);
962 __isl_give isl_space *isl_space_set_from_params(
963 __isl_take isl_space *space);
964 __isl_give isl_space *isl_space_reverse(__isl_take isl_space *space);
965 __isl_give isl_space *isl_space_join(__isl_take isl_space *left,
966 __isl_take isl_space *right);
967 __isl_give isl_space *isl_space_align_params(
968 __isl_take isl_space *space1, __isl_take isl_space *space2)
969 __isl_give isl_space *isl_space_insert_dims(__isl_take isl_space *space,
970 enum isl_dim_type type, unsigned pos, unsigned n);
971 __isl_give isl_space *isl_space_add_dims(__isl_take isl_space *space,
972 enum isl_dim_type type, unsigned n);
973 __isl_give isl_space *isl_space_drop_dims(__isl_take isl_space *space,
974 enum isl_dim_type type, unsigned first, unsigned n);
975 __isl_give isl_space *isl_space_move_dims(__isl_take isl_space *space,
976 enum isl_dim_type dst_type, unsigned dst_pos,
977 enum isl_dim_type src_type, unsigned src_pos,
979 __isl_give isl_space *isl_space_map_from_set(
980 __isl_take isl_space *space);
981 __isl_give isl_space *isl_space_map_from_domain_and_range(
982 __isl_take isl_space *domain,
983 __isl_take isl_space *range);
984 __isl_give isl_space *isl_space_zip(__isl_take isl_space *space);
985 __isl_give isl_space *isl_space_curry(
986 __isl_take isl_space *space);
987 __isl_give isl_space *isl_space_uncurry(
988 __isl_take isl_space *space);
990 Note that if dimensions are added or removed from a space, then
991 the name and the internal structure are lost.
995 A local space is essentially a space with
996 zero or more existentially quantified variables.
997 The local space of a (constraint of a) basic set or relation can be obtained
998 using the following functions.
1000 #include <isl/constraint.h>
1001 __isl_give isl_local_space *isl_constraint_get_local_space(
1002 __isl_keep isl_constraint *constraint);
1004 #include <isl/set.h>
1005 __isl_give isl_local_space *isl_basic_set_get_local_space(
1006 __isl_keep isl_basic_set *bset);
1008 #include <isl/map.h>
1009 __isl_give isl_local_space *isl_basic_map_get_local_space(
1010 __isl_keep isl_basic_map *bmap);
1012 A new local space can be created from a space using
1014 #include <isl/local_space.h>
1015 __isl_give isl_local_space *isl_local_space_from_space(
1016 __isl_take isl_space *space);
1018 They can be inspected, modified, copied and freed using the following functions.
1020 #include <isl/local_space.h>
1021 isl_ctx *isl_local_space_get_ctx(
1022 __isl_keep isl_local_space *ls);
1023 int isl_local_space_is_set(__isl_keep isl_local_space *ls);
1024 int isl_local_space_dim(__isl_keep isl_local_space *ls,
1025 enum isl_dim_type type);
1026 int isl_local_space_has_dim_id(
1027 __isl_keep isl_local_space *ls,
1028 enum isl_dim_type type, unsigned pos);
1029 __isl_give isl_id *isl_local_space_get_dim_id(
1030 __isl_keep isl_local_space *ls,
1031 enum isl_dim_type type, unsigned pos);
1032 int isl_local_space_has_dim_name(
1033 __isl_keep isl_local_space *ls,
1034 enum isl_dim_type type, unsigned pos)
1035 const char *isl_local_space_get_dim_name(
1036 __isl_keep isl_local_space *ls,
1037 enum isl_dim_type type, unsigned pos);
1038 __isl_give isl_local_space *isl_local_space_set_dim_name(
1039 __isl_take isl_local_space *ls,
1040 enum isl_dim_type type, unsigned pos, const char *s);
1041 __isl_give isl_local_space *isl_local_space_set_dim_id(
1042 __isl_take isl_local_space *ls,
1043 enum isl_dim_type type, unsigned pos,
1044 __isl_take isl_id *id);
1045 __isl_give isl_space *isl_local_space_get_space(
1046 __isl_keep isl_local_space *ls);
1047 __isl_give isl_aff *isl_local_space_get_div(
1048 __isl_keep isl_local_space *ls, int pos);
1049 __isl_give isl_local_space *isl_local_space_copy(
1050 __isl_keep isl_local_space *ls);
1051 void *isl_local_space_free(__isl_take isl_local_space *ls);
1053 Note that C<isl_local_space_get_div> can only be used on local spaces
1056 Two local spaces can be compared using
1058 int isl_local_space_is_equal(__isl_keep isl_local_space *ls1,
1059 __isl_keep isl_local_space *ls2);
1061 Local spaces can be created from other local spaces
1062 using the following functions.
1064 __isl_give isl_local_space *isl_local_space_domain(
1065 __isl_take isl_local_space *ls);
1066 __isl_give isl_local_space *isl_local_space_range(
1067 __isl_take isl_local_space *ls);
1068 __isl_give isl_local_space *isl_local_space_from_domain(
1069 __isl_take isl_local_space *ls);
1070 __isl_give isl_local_space *isl_local_space_intersect(
1071 __isl_take isl_local_space *ls1,
1072 __isl_take isl_local_space *ls2);
1073 __isl_give isl_local_space *isl_local_space_add_dims(
1074 __isl_take isl_local_space *ls,
1075 enum isl_dim_type type, unsigned n);
1076 __isl_give isl_local_space *isl_local_space_insert_dims(
1077 __isl_take isl_local_space *ls,
1078 enum isl_dim_type type, unsigned first, unsigned n);
1079 __isl_give isl_local_space *isl_local_space_drop_dims(
1080 __isl_take isl_local_space *ls,
1081 enum isl_dim_type type, unsigned first, unsigned n);
1083 =head2 Input and Output
1085 C<isl> supports its own input/output format, which is similar
1086 to the C<Omega> format, but also supports the C<PolyLib> format
1089 =head3 C<isl> format
1091 The C<isl> format is similar to that of C<Omega>, but has a different
1092 syntax for describing the parameters and allows for the definition
1093 of an existentially quantified variable as the integer division
1094 of an affine expression.
1095 For example, the set of integers C<i> between C<0> and C<n>
1096 such that C<i % 10 <= 6> can be described as
1098 [n] -> { [i] : exists (a = [i/10] : 0 <= i and i <= n and
1101 A set or relation can have several disjuncts, separated
1102 by the keyword C<or>. Each disjunct is either a conjunction
1103 of constraints or a projection (C<exists>) of a conjunction
1104 of constraints. The constraints are separated by the keyword
1107 =head3 C<PolyLib> format
1109 If the represented set is a union, then the first line
1110 contains a single number representing the number of disjuncts.
1111 Otherwise, a line containing the number C<1> is optional.
1113 Each disjunct is represented by a matrix of constraints.
1114 The first line contains two numbers representing
1115 the number of rows and columns,
1116 where the number of rows is equal to the number of constraints
1117 and the number of columns is equal to two plus the number of variables.
1118 The following lines contain the actual rows of the constraint matrix.
1119 In each row, the first column indicates whether the constraint
1120 is an equality (C<0>) or inequality (C<1>). The final column
1121 corresponds to the constant term.
1123 If the set is parametric, then the coefficients of the parameters
1124 appear in the last columns before the constant column.
1125 The coefficients of any existentially quantified variables appear
1126 between those of the set variables and those of the parameters.
1128 =head3 Extended C<PolyLib> format
1130 The extended C<PolyLib> format is nearly identical to the
1131 C<PolyLib> format. The only difference is that the line
1132 containing the number of rows and columns of a constraint matrix
1133 also contains four additional numbers:
1134 the number of output dimensions, the number of input dimensions,
1135 the number of local dimensions (i.e., the number of existentially
1136 quantified variables) and the number of parameters.
1137 For sets, the number of ``output'' dimensions is equal
1138 to the number of set dimensions, while the number of ``input''
1143 #include <isl/set.h>
1144 __isl_give isl_basic_set *isl_basic_set_read_from_file(
1145 isl_ctx *ctx, FILE *input);
1146 __isl_give isl_basic_set *isl_basic_set_read_from_str(
1147 isl_ctx *ctx, const char *str);
1148 __isl_give isl_set *isl_set_read_from_file(isl_ctx *ctx,
1150 __isl_give isl_set *isl_set_read_from_str(isl_ctx *ctx,
1153 #include <isl/map.h>
1154 __isl_give isl_basic_map *isl_basic_map_read_from_file(
1155 isl_ctx *ctx, FILE *input);
1156 __isl_give isl_basic_map *isl_basic_map_read_from_str(
1157 isl_ctx *ctx, const char *str);
1158 __isl_give isl_map *isl_map_read_from_file(
1159 isl_ctx *ctx, FILE *input);
1160 __isl_give isl_map *isl_map_read_from_str(isl_ctx *ctx,
1163 #include <isl/union_set.h>
1164 __isl_give isl_union_set *isl_union_set_read_from_file(
1165 isl_ctx *ctx, FILE *input);
1166 __isl_give isl_union_set *isl_union_set_read_from_str(
1167 isl_ctx *ctx, const char *str);
1169 #include <isl/union_map.h>
1170 __isl_give isl_union_map *isl_union_map_read_from_file(
1171 isl_ctx *ctx, FILE *input);
1172 __isl_give isl_union_map *isl_union_map_read_from_str(
1173 isl_ctx *ctx, const char *str);
1175 The input format is autodetected and may be either the C<PolyLib> format
1176 or the C<isl> format.
1180 Before anything can be printed, an C<isl_printer> needs to
1183 __isl_give isl_printer *isl_printer_to_file(isl_ctx *ctx,
1185 __isl_give isl_printer *isl_printer_to_str(isl_ctx *ctx);
1186 void *isl_printer_free(__isl_take isl_printer *printer);
1187 __isl_give char *isl_printer_get_str(
1188 __isl_keep isl_printer *printer);
1190 The printer can be inspected using the following functions.
1192 FILE *isl_printer_get_file(
1193 __isl_keep isl_printer *printer);
1194 int isl_printer_get_output_format(
1195 __isl_keep isl_printer *p);
1197 The behavior of the printer can be modified in various ways
1199 __isl_give isl_printer *isl_printer_set_output_format(
1200 __isl_take isl_printer *p, int output_format);
1201 __isl_give isl_printer *isl_printer_set_indent(
1202 __isl_take isl_printer *p, int indent);
1203 __isl_give isl_printer *isl_printer_indent(
1204 __isl_take isl_printer *p, int indent);
1205 __isl_give isl_printer *isl_printer_set_prefix(
1206 __isl_take isl_printer *p, const char *prefix);
1207 __isl_give isl_printer *isl_printer_set_suffix(
1208 __isl_take isl_printer *p, const char *suffix);
1210 The C<output_format> may be either C<ISL_FORMAT_ISL>, C<ISL_FORMAT_OMEGA>,
1211 C<ISL_FORMAT_POLYLIB>, C<ISL_FORMAT_EXT_POLYLIB> or C<ISL_FORMAT_LATEX>
1212 and defaults to C<ISL_FORMAT_ISL>.
1213 Each line in the output is indented by C<indent> (set by
1214 C<isl_printer_set_indent>) spaces
1215 (default: 0), prefixed by C<prefix> and suffixed by C<suffix>.
1216 In the C<PolyLib> format output,
1217 the coefficients of the existentially quantified variables
1218 appear between those of the set variables and those
1220 The function C<isl_printer_indent> increases the indentation
1221 by the specified amount (which may be negative).
1223 To actually print something, use
1225 #include <isl/printer.h>
1226 __isl_give isl_printer *isl_printer_print_double(
1227 __isl_take isl_printer *p, double d);
1229 #include <isl/set.h>
1230 __isl_give isl_printer *isl_printer_print_basic_set(
1231 __isl_take isl_printer *printer,
1232 __isl_keep isl_basic_set *bset);
1233 __isl_give isl_printer *isl_printer_print_set(
1234 __isl_take isl_printer *printer,
1235 __isl_keep isl_set *set);
1237 #include <isl/map.h>
1238 __isl_give isl_printer *isl_printer_print_basic_map(
1239 __isl_take isl_printer *printer,
1240 __isl_keep isl_basic_map *bmap);
1241 __isl_give isl_printer *isl_printer_print_map(
1242 __isl_take isl_printer *printer,
1243 __isl_keep isl_map *map);
1245 #include <isl/union_set.h>
1246 __isl_give isl_printer *isl_printer_print_union_set(
1247 __isl_take isl_printer *p,
1248 __isl_keep isl_union_set *uset);
1250 #include <isl/union_map.h>
1251 __isl_give isl_printer *isl_printer_print_union_map(
1252 __isl_take isl_printer *p,
1253 __isl_keep isl_union_map *umap);
1255 When called on a file printer, the following function flushes
1256 the file. When called on a string printer, the buffer is cleared.
1258 __isl_give isl_printer *isl_printer_flush(
1259 __isl_take isl_printer *p);
1261 =head2 Creating New Sets and Relations
1263 C<isl> has functions for creating some standard sets and relations.
1267 =item * Empty sets and relations
1269 __isl_give isl_basic_set *isl_basic_set_empty(
1270 __isl_take isl_space *space);
1271 __isl_give isl_basic_map *isl_basic_map_empty(
1272 __isl_take isl_space *space);
1273 __isl_give isl_set *isl_set_empty(
1274 __isl_take isl_space *space);
1275 __isl_give isl_map *isl_map_empty(
1276 __isl_take isl_space *space);
1277 __isl_give isl_union_set *isl_union_set_empty(
1278 __isl_take isl_space *space);
1279 __isl_give isl_union_map *isl_union_map_empty(
1280 __isl_take isl_space *space);
1282 For C<isl_union_set>s and C<isl_union_map>s, the space
1283 is only used to specify the parameters.
1285 =item * Universe sets and relations
1287 __isl_give isl_basic_set *isl_basic_set_universe(
1288 __isl_take isl_space *space);
1289 __isl_give isl_basic_map *isl_basic_map_universe(
1290 __isl_take isl_space *space);
1291 __isl_give isl_set *isl_set_universe(
1292 __isl_take isl_space *space);
1293 __isl_give isl_map *isl_map_universe(
1294 __isl_take isl_space *space);
1295 __isl_give isl_union_set *isl_union_set_universe(
1296 __isl_take isl_union_set *uset);
1297 __isl_give isl_union_map *isl_union_map_universe(
1298 __isl_take isl_union_map *umap);
1300 The sets and relations constructed by the functions above
1301 contain all integer values, while those constructed by the
1302 functions below only contain non-negative values.
1304 __isl_give isl_basic_set *isl_basic_set_nat_universe(
1305 __isl_take isl_space *space);
1306 __isl_give isl_basic_map *isl_basic_map_nat_universe(
1307 __isl_take isl_space *space);
1308 __isl_give isl_set *isl_set_nat_universe(
1309 __isl_take isl_space *space);
1310 __isl_give isl_map *isl_map_nat_universe(
1311 __isl_take isl_space *space);
1313 =item * Identity relations
1315 __isl_give isl_basic_map *isl_basic_map_identity(
1316 __isl_take isl_space *space);
1317 __isl_give isl_map *isl_map_identity(
1318 __isl_take isl_space *space);
1320 The number of input and output dimensions in C<space> needs
1323 =item * Lexicographic order
1325 __isl_give isl_map *isl_map_lex_lt(
1326 __isl_take isl_space *set_space);
1327 __isl_give isl_map *isl_map_lex_le(
1328 __isl_take isl_space *set_space);
1329 __isl_give isl_map *isl_map_lex_gt(
1330 __isl_take isl_space *set_space);
1331 __isl_give isl_map *isl_map_lex_ge(
1332 __isl_take isl_space *set_space);
1333 __isl_give isl_map *isl_map_lex_lt_first(
1334 __isl_take isl_space *space, unsigned n);
1335 __isl_give isl_map *isl_map_lex_le_first(
1336 __isl_take isl_space *space, unsigned n);
1337 __isl_give isl_map *isl_map_lex_gt_first(
1338 __isl_take isl_space *space, unsigned n);
1339 __isl_give isl_map *isl_map_lex_ge_first(
1340 __isl_take isl_space *space, unsigned n);
1342 The first four functions take a space for a B<set>
1343 and return relations that express that the elements in the domain
1344 are lexicographically less
1345 (C<isl_map_lex_lt>), less or equal (C<isl_map_lex_le>),
1346 greater (C<isl_map_lex_gt>) or greater or equal (C<isl_map_lex_ge>)
1347 than the elements in the range.
1348 The last four functions take a space for a map
1349 and return relations that express that the first C<n> dimensions
1350 in the domain are lexicographically less
1351 (C<isl_map_lex_lt_first>), less or equal (C<isl_map_lex_le_first>),
1352 greater (C<isl_map_lex_gt_first>) or greater or equal (C<isl_map_lex_ge_first>)
1353 than the first C<n> dimensions in the range.
1357 A basic set or relation can be converted to a set or relation
1358 using the following functions.
1360 __isl_give isl_set *isl_set_from_basic_set(
1361 __isl_take isl_basic_set *bset);
1362 __isl_give isl_map *isl_map_from_basic_map(
1363 __isl_take isl_basic_map *bmap);
1365 Sets and relations can be converted to union sets and relations
1366 using the following functions.
1368 __isl_give isl_union_set *isl_union_set_from_basic_set(
1369 __isl_take isl_basic_set *bset);
1370 __isl_give isl_union_map *isl_union_map_from_basic_map(
1371 __isl_take isl_basic_map *bmap);
1372 __isl_give isl_union_set *isl_union_set_from_set(
1373 __isl_take isl_set *set);
1374 __isl_give isl_union_map *isl_union_map_from_map(
1375 __isl_take isl_map *map);
1377 The inverse conversions below can only be used if the input
1378 union set or relation is known to contain elements in exactly one
1381 __isl_give isl_set *isl_set_from_union_set(
1382 __isl_take isl_union_set *uset);
1383 __isl_give isl_map *isl_map_from_union_map(
1384 __isl_take isl_union_map *umap);
1386 A zero-dimensional (basic) set can be constructed on a given parameter domain
1387 using the following function.
1389 __isl_give isl_basic_set *isl_basic_set_from_params(
1390 __isl_take isl_basic_set *bset);
1391 __isl_give isl_set *isl_set_from_params(
1392 __isl_take isl_set *set);
1394 Sets and relations can be copied and freed again using the following
1397 __isl_give isl_basic_set *isl_basic_set_copy(
1398 __isl_keep isl_basic_set *bset);
1399 __isl_give isl_set *isl_set_copy(__isl_keep isl_set *set);
1400 __isl_give isl_union_set *isl_union_set_copy(
1401 __isl_keep isl_union_set *uset);
1402 __isl_give isl_basic_map *isl_basic_map_copy(
1403 __isl_keep isl_basic_map *bmap);
1404 __isl_give isl_map *isl_map_copy(__isl_keep isl_map *map);
1405 __isl_give isl_union_map *isl_union_map_copy(
1406 __isl_keep isl_union_map *umap);
1407 void *isl_basic_set_free(__isl_take isl_basic_set *bset);
1408 void *isl_set_free(__isl_take isl_set *set);
1409 void *isl_union_set_free(__isl_take isl_union_set *uset);
1410 void *isl_basic_map_free(__isl_take isl_basic_map *bmap);
1411 void *isl_map_free(__isl_take isl_map *map);
1412 void *isl_union_map_free(__isl_take isl_union_map *umap);
1414 Other sets and relations can be constructed by starting
1415 from a universe set or relation, adding equality and/or
1416 inequality constraints and then projecting out the
1417 existentially quantified variables, if any.
1418 Constraints can be constructed, manipulated and
1419 added to (or removed from) (basic) sets and relations
1420 using the following functions.
1422 #include <isl/constraint.h>
1423 __isl_give isl_constraint *isl_equality_alloc(
1424 __isl_take isl_local_space *ls);
1425 __isl_give isl_constraint *isl_inequality_alloc(
1426 __isl_take isl_local_space *ls);
1427 __isl_give isl_constraint *isl_constraint_set_constant_si(
1428 __isl_take isl_constraint *constraint, int v);
1429 __isl_give isl_constraint *isl_constraint_set_constant_val(
1430 __isl_take isl_constraint *constraint,
1431 __isl_take isl_val *v);
1432 __isl_give isl_constraint *isl_constraint_set_coefficient_si(
1433 __isl_take isl_constraint *constraint,
1434 enum isl_dim_type type, int pos, int v);
1435 __isl_give isl_constraint *
1436 isl_constraint_set_coefficient_val(
1437 __isl_take isl_constraint *constraint,
1438 enum isl_dim_type type, int pos, isl_val *v);
1439 __isl_give isl_basic_map *isl_basic_map_add_constraint(
1440 __isl_take isl_basic_map *bmap,
1441 __isl_take isl_constraint *constraint);
1442 __isl_give isl_basic_set *isl_basic_set_add_constraint(
1443 __isl_take isl_basic_set *bset,
1444 __isl_take isl_constraint *constraint);
1445 __isl_give isl_map *isl_map_add_constraint(
1446 __isl_take isl_map *map,
1447 __isl_take isl_constraint *constraint);
1448 __isl_give isl_set *isl_set_add_constraint(
1449 __isl_take isl_set *set,
1450 __isl_take isl_constraint *constraint);
1451 __isl_give isl_basic_set *isl_basic_set_drop_constraint(
1452 __isl_take isl_basic_set *bset,
1453 __isl_take isl_constraint *constraint);
1455 For example, to create a set containing the even integers
1456 between 10 and 42, you would use the following code.
1459 isl_local_space *ls;
1461 isl_basic_set *bset;
1463 space = isl_space_set_alloc(ctx, 0, 2);
1464 bset = isl_basic_set_universe(isl_space_copy(space));
1465 ls = isl_local_space_from_space(space);
1467 c = isl_equality_alloc(isl_local_space_copy(ls));
1468 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
1469 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 2);
1470 bset = isl_basic_set_add_constraint(bset, c);
1472 c = isl_inequality_alloc(isl_local_space_copy(ls));
1473 c = isl_constraint_set_constant_si(c, -10);
1474 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
1475 bset = isl_basic_set_add_constraint(bset, c);
1477 c = isl_inequality_alloc(ls);
1478 c = isl_constraint_set_constant_si(c, 42);
1479 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
1480 bset = isl_basic_set_add_constraint(bset, c);
1482 bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 1);
1486 isl_basic_set *bset;
1487 bset = isl_basic_set_read_from_str(ctx,
1488 "{[i] : exists (a : i = 2a and i >= 10 and i <= 42)}");
1490 A basic set or relation can also be constructed from two matrices
1491 describing the equalities and the inequalities.
1493 __isl_give isl_basic_set *isl_basic_set_from_constraint_matrices(
1494 __isl_take isl_space *space,
1495 __isl_take isl_mat *eq, __isl_take isl_mat *ineq,
1496 enum isl_dim_type c1,
1497 enum isl_dim_type c2, enum isl_dim_type c3,
1498 enum isl_dim_type c4);
1499 __isl_give isl_basic_map *isl_basic_map_from_constraint_matrices(
1500 __isl_take isl_space *space,
1501 __isl_take isl_mat *eq, __isl_take isl_mat *ineq,
1502 enum isl_dim_type c1,
1503 enum isl_dim_type c2, enum isl_dim_type c3,
1504 enum isl_dim_type c4, enum isl_dim_type c5);
1506 The C<isl_dim_type> arguments indicate the order in which
1507 different kinds of variables appear in the input matrices
1508 and should be a permutation of C<isl_dim_cst>, C<isl_dim_param>,
1509 C<isl_dim_set> and C<isl_dim_div> for sets and
1510 of C<isl_dim_cst>, C<isl_dim_param>,
1511 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div> for relations.
1513 A (basic or union) set or relation can also be constructed from a
1514 (union) (piecewise) (multiple) affine expression
1515 or a list of affine expressions
1516 (See L<"Piecewise Quasi Affine Expressions"> and
1517 L<"Piecewise Multiple Quasi Affine Expressions">).
1519 __isl_give isl_basic_map *isl_basic_map_from_aff(
1520 __isl_take isl_aff *aff);
1521 __isl_give isl_map *isl_map_from_aff(
1522 __isl_take isl_aff *aff);
1523 __isl_give isl_set *isl_set_from_pw_aff(
1524 __isl_take isl_pw_aff *pwaff);
1525 __isl_give isl_map *isl_map_from_pw_aff(
1526 __isl_take isl_pw_aff *pwaff);
1527 __isl_give isl_basic_map *isl_basic_map_from_aff_list(
1528 __isl_take isl_space *domain_space,
1529 __isl_take isl_aff_list *list);
1530 __isl_give isl_basic_map *isl_basic_map_from_multi_aff(
1531 __isl_take isl_multi_aff *maff)
1532 __isl_give isl_map *isl_map_from_multi_aff(
1533 __isl_take isl_multi_aff *maff)
1534 __isl_give isl_set *isl_set_from_pw_multi_aff(
1535 __isl_take isl_pw_multi_aff *pma);
1536 __isl_give isl_map *isl_map_from_pw_multi_aff(
1537 __isl_take isl_pw_multi_aff *pma);
1538 __isl_give isl_set *isl_set_from_multi_pw_aff(
1539 __isl_take isl_multi_pw_aff *mpa);
1540 __isl_give isl_map *isl_map_from_multi_pw_aff(
1541 __isl_take isl_multi_pw_aff *mpa);
1542 __isl_give isl_union_map *
1543 isl_union_map_from_union_pw_multi_aff(
1544 __isl_take isl_union_pw_multi_aff *upma);
1546 The C<domain_dim> argument describes the domain of the resulting
1547 basic relation. It is required because the C<list> may consist
1548 of zero affine expressions.
1550 =head2 Inspecting Sets and Relations
1552 Usually, the user should not have to care about the actual constraints
1553 of the sets and maps, but should instead apply the abstract operations
1554 explained in the following sections.
1555 Occasionally, however, it may be required to inspect the individual
1556 coefficients of the constraints. This section explains how to do so.
1557 In these cases, it may also be useful to have C<isl> compute
1558 an explicit representation of the existentially quantified variables.
1560 __isl_give isl_set *isl_set_compute_divs(
1561 __isl_take isl_set *set);
1562 __isl_give isl_map *isl_map_compute_divs(
1563 __isl_take isl_map *map);
1564 __isl_give isl_union_set *isl_union_set_compute_divs(
1565 __isl_take isl_union_set *uset);
1566 __isl_give isl_union_map *isl_union_map_compute_divs(
1567 __isl_take isl_union_map *umap);
1569 This explicit representation defines the existentially quantified
1570 variables as integer divisions of the other variables, possibly
1571 including earlier existentially quantified variables.
1572 An explicitly represented existentially quantified variable therefore
1573 has a unique value when the values of the other variables are known.
1574 If, furthermore, the same existentials, i.e., existentials
1575 with the same explicit representations, should appear in the
1576 same order in each of the disjuncts of a set or map, then the user should call
1577 either of the following functions.
1579 __isl_give isl_set *isl_set_align_divs(
1580 __isl_take isl_set *set);
1581 __isl_give isl_map *isl_map_align_divs(
1582 __isl_take isl_map *map);
1584 Alternatively, the existentially quantified variables can be removed
1585 using the following functions, which compute an overapproximation.
1587 __isl_give isl_basic_set *isl_basic_set_remove_divs(
1588 __isl_take isl_basic_set *bset);
1589 __isl_give isl_basic_map *isl_basic_map_remove_divs(
1590 __isl_take isl_basic_map *bmap);
1591 __isl_give isl_set *isl_set_remove_divs(
1592 __isl_take isl_set *set);
1593 __isl_give isl_map *isl_map_remove_divs(
1594 __isl_take isl_map *map);
1596 It is also possible to only remove those divs that are defined
1597 in terms of a given range of dimensions or only those for which
1598 no explicit representation is known.
1600 __isl_give isl_basic_set *
1601 isl_basic_set_remove_divs_involving_dims(
1602 __isl_take isl_basic_set *bset,
1603 enum isl_dim_type type,
1604 unsigned first, unsigned n);
1605 __isl_give isl_basic_map *
1606 isl_basic_map_remove_divs_involving_dims(
1607 __isl_take isl_basic_map *bmap,
1608 enum isl_dim_type type,
1609 unsigned first, unsigned n);
1610 __isl_give isl_set *isl_set_remove_divs_involving_dims(
1611 __isl_take isl_set *set, enum isl_dim_type type,
1612 unsigned first, unsigned n);
1613 __isl_give isl_map *isl_map_remove_divs_involving_dims(
1614 __isl_take isl_map *map, enum isl_dim_type type,
1615 unsigned first, unsigned n);
1617 __isl_give isl_basic_set *
1618 isl_basic_set_remove_unknown_divs(
1619 __isl_take isl_basic_set *bset);
1620 __isl_give isl_set *isl_set_remove_unknown_divs(
1621 __isl_take isl_set *set);
1622 __isl_give isl_map *isl_map_remove_unknown_divs(
1623 __isl_take isl_map *map);
1625 To iterate over all the sets or maps in a union set or map, use
1627 int isl_union_set_foreach_set(__isl_keep isl_union_set *uset,
1628 int (*fn)(__isl_take isl_set *set, void *user),
1630 int isl_union_map_foreach_map(__isl_keep isl_union_map *umap,
1631 int (*fn)(__isl_take isl_map *map, void *user),
1634 The number of sets or maps in a union set or map can be obtained
1637 int isl_union_set_n_set(__isl_keep isl_union_set *uset);
1638 int isl_union_map_n_map(__isl_keep isl_union_map *umap);
1640 To extract the set or map in a given space from a union, use
1642 __isl_give isl_set *isl_union_set_extract_set(
1643 __isl_keep isl_union_set *uset,
1644 __isl_take isl_space *space);
1645 __isl_give isl_map *isl_union_map_extract_map(
1646 __isl_keep isl_union_map *umap,
1647 __isl_take isl_space *space);
1649 To iterate over all the basic sets or maps in a set or map, use
1651 int isl_set_foreach_basic_set(__isl_keep isl_set *set,
1652 int (*fn)(__isl_take isl_basic_set *bset, void *user),
1654 int isl_map_foreach_basic_map(__isl_keep isl_map *map,
1655 int (*fn)(__isl_take isl_basic_map *bmap, void *user),
1658 The callback function C<fn> should return 0 if successful and
1659 -1 if an error occurs. In the latter case, or if any other error
1660 occurs, the above functions will return -1.
1662 It should be noted that C<isl> does not guarantee that
1663 the basic sets or maps passed to C<fn> are disjoint.
1664 If this is required, then the user should call one of
1665 the following functions first.
1667 __isl_give isl_set *isl_set_make_disjoint(
1668 __isl_take isl_set *set);
1669 __isl_give isl_map *isl_map_make_disjoint(
1670 __isl_take isl_map *map);
1672 The number of basic sets in a set can be obtained
1675 int isl_set_n_basic_set(__isl_keep isl_set *set);
1677 To iterate over the constraints of a basic set or map, use
1679 #include <isl/constraint.h>
1681 int isl_basic_set_n_constraint(
1682 __isl_keep isl_basic_set *bset);
1683 int isl_basic_set_foreach_constraint(
1684 __isl_keep isl_basic_set *bset,
1685 int (*fn)(__isl_take isl_constraint *c, void *user),
1687 int isl_basic_map_foreach_constraint(
1688 __isl_keep isl_basic_map *bmap,
1689 int (*fn)(__isl_take isl_constraint *c, void *user),
1691 void *isl_constraint_free(__isl_take isl_constraint *c);
1693 Again, the callback function C<fn> should return 0 if successful and
1694 -1 if an error occurs. In the latter case, or if any other error
1695 occurs, the above functions will return -1.
1696 The constraint C<c> represents either an equality or an inequality.
1697 Use the following function to find out whether a constraint
1698 represents an equality. If not, it represents an inequality.
1700 int isl_constraint_is_equality(
1701 __isl_keep isl_constraint *constraint);
1703 The coefficients of the constraints can be inspected using
1704 the following functions.
1706 int isl_constraint_is_lower_bound(
1707 __isl_keep isl_constraint *constraint,
1708 enum isl_dim_type type, unsigned pos);
1709 int isl_constraint_is_upper_bound(
1710 __isl_keep isl_constraint *constraint,
1711 enum isl_dim_type type, unsigned pos);
1712 __isl_give isl_val *isl_constraint_get_constant_val(
1713 __isl_keep isl_constraint *constraint);
1714 __isl_give isl_val *isl_constraint_get_coefficient_val(
1715 __isl_keep isl_constraint *constraint,
1716 enum isl_dim_type type, int pos);
1717 int isl_constraint_involves_dims(
1718 __isl_keep isl_constraint *constraint,
1719 enum isl_dim_type type, unsigned first, unsigned n);
1721 The explicit representations of the existentially quantified
1722 variables can be inspected using the following function.
1723 Note that the user is only allowed to use this function
1724 if the inspected set or map is the result of a call
1725 to C<isl_set_compute_divs> or C<isl_map_compute_divs>.
1726 The existentially quantified variable is equal to the floor
1727 of the returned affine expression. The affine expression
1728 itself can be inspected using the functions in
1729 L<"Piecewise Quasi Affine Expressions">.
1731 __isl_give isl_aff *isl_constraint_get_div(
1732 __isl_keep isl_constraint *constraint, int pos);
1734 To obtain the constraints of a basic set or map in matrix
1735 form, use the following functions.
1737 __isl_give isl_mat *isl_basic_set_equalities_matrix(
1738 __isl_keep isl_basic_set *bset,
1739 enum isl_dim_type c1, enum isl_dim_type c2,
1740 enum isl_dim_type c3, enum isl_dim_type c4);
1741 __isl_give isl_mat *isl_basic_set_inequalities_matrix(
1742 __isl_keep isl_basic_set *bset,
1743 enum isl_dim_type c1, enum isl_dim_type c2,
1744 enum isl_dim_type c3, enum isl_dim_type c4);
1745 __isl_give isl_mat *isl_basic_map_equalities_matrix(
1746 __isl_keep isl_basic_map *bmap,
1747 enum isl_dim_type c1,
1748 enum isl_dim_type c2, enum isl_dim_type c3,
1749 enum isl_dim_type c4, enum isl_dim_type c5);
1750 __isl_give isl_mat *isl_basic_map_inequalities_matrix(
1751 __isl_keep isl_basic_map *bmap,
1752 enum isl_dim_type c1,
1753 enum isl_dim_type c2, enum isl_dim_type c3,
1754 enum isl_dim_type c4, enum isl_dim_type c5);
1756 The C<isl_dim_type> arguments dictate the order in which
1757 different kinds of variables appear in the resulting matrix
1758 and should be a permutation of C<isl_dim_cst>, C<isl_dim_param>,
1759 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div>.
1761 The number of parameters, input, output or set dimensions can
1762 be obtained using the following functions.
1764 unsigned isl_basic_set_dim(__isl_keep isl_basic_set *bset,
1765 enum isl_dim_type type);
1766 unsigned isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
1767 enum isl_dim_type type);
1768 unsigned isl_set_dim(__isl_keep isl_set *set,
1769 enum isl_dim_type type);
1770 unsigned isl_map_dim(__isl_keep isl_map *map,
1771 enum isl_dim_type type);
1773 To check whether the description of a set or relation depends
1774 on one or more given dimensions, it is not necessary to iterate over all
1775 constraints. Instead the following functions can be used.
1777 int isl_basic_set_involves_dims(
1778 __isl_keep isl_basic_set *bset,
1779 enum isl_dim_type type, unsigned first, unsigned n);
1780 int isl_set_involves_dims(__isl_keep isl_set *set,
1781 enum isl_dim_type type, unsigned first, unsigned n);
1782 int isl_basic_map_involves_dims(
1783 __isl_keep isl_basic_map *bmap,
1784 enum isl_dim_type type, unsigned first, unsigned n);
1785 int isl_map_involves_dims(__isl_keep isl_map *map,
1786 enum isl_dim_type type, unsigned first, unsigned n);
1788 Similarly, the following functions can be used to check whether
1789 a given dimension is involved in any lower or upper bound.
1791 int isl_set_dim_has_any_lower_bound(__isl_keep isl_set *set,
1792 enum isl_dim_type type, unsigned pos);
1793 int isl_set_dim_has_any_upper_bound(__isl_keep isl_set *set,
1794 enum isl_dim_type type, unsigned pos);
1796 Note that these functions return true even if there is a bound on
1797 the dimension on only some of the basic sets of C<set>.
1798 To check if they have a bound for all of the basic sets in C<set>,
1799 use the following functions instead.
1801 int isl_set_dim_has_lower_bound(__isl_keep isl_set *set,
1802 enum isl_dim_type type, unsigned pos);
1803 int isl_set_dim_has_upper_bound(__isl_keep isl_set *set,
1804 enum isl_dim_type type, unsigned pos);
1806 The identifiers or names of the domain and range spaces of a set
1807 or relation can be read off or set using the following functions.
1809 __isl_give isl_set *isl_set_set_tuple_id(
1810 __isl_take isl_set *set, __isl_take isl_id *id);
1811 __isl_give isl_set *isl_set_reset_tuple_id(
1812 __isl_take isl_set *set);
1813 int isl_set_has_tuple_id(__isl_keep isl_set *set);
1814 __isl_give isl_id *isl_set_get_tuple_id(
1815 __isl_keep isl_set *set);
1816 __isl_give isl_map *isl_map_set_tuple_id(
1817 __isl_take isl_map *map, enum isl_dim_type type,
1818 __isl_take isl_id *id);
1819 __isl_give isl_map *isl_map_reset_tuple_id(
1820 __isl_take isl_map *map, enum isl_dim_type type);
1821 int isl_map_has_tuple_id(__isl_keep isl_map *map,
1822 enum isl_dim_type type);
1823 __isl_give isl_id *isl_map_get_tuple_id(
1824 __isl_keep isl_map *map, enum isl_dim_type type);
1826 const char *isl_basic_set_get_tuple_name(
1827 __isl_keep isl_basic_set *bset);
1828 __isl_give isl_basic_set *isl_basic_set_set_tuple_name(
1829 __isl_take isl_basic_set *set, const char *s);
1830 int isl_set_has_tuple_name(__isl_keep isl_set *set);
1831 const char *isl_set_get_tuple_name(
1832 __isl_keep isl_set *set);
1833 const char *isl_basic_map_get_tuple_name(
1834 __isl_keep isl_basic_map *bmap,
1835 enum isl_dim_type type);
1836 __isl_give isl_basic_map *isl_basic_map_set_tuple_name(
1837 __isl_take isl_basic_map *bmap,
1838 enum isl_dim_type type, const char *s);
1839 int isl_map_has_tuple_name(__isl_keep isl_map *map,
1840 enum isl_dim_type type);
1841 const char *isl_map_get_tuple_name(
1842 __isl_keep isl_map *map,
1843 enum isl_dim_type type);
1845 As with C<isl_space_get_tuple_name>, the value returned points to
1846 an internal data structure.
1847 The identifiers, positions or names of individual dimensions can be
1848 read off using the following functions.
1850 __isl_give isl_id *isl_basic_set_get_dim_id(
1851 __isl_keep isl_basic_set *bset,
1852 enum isl_dim_type type, unsigned pos);
1853 __isl_give isl_set *isl_set_set_dim_id(
1854 __isl_take isl_set *set, enum isl_dim_type type,
1855 unsigned pos, __isl_take isl_id *id);
1856 int isl_set_has_dim_id(__isl_keep isl_set *set,
1857 enum isl_dim_type type, unsigned pos);
1858 __isl_give isl_id *isl_set_get_dim_id(
1859 __isl_keep isl_set *set, enum isl_dim_type type,
1861 int isl_basic_map_has_dim_id(
1862 __isl_keep isl_basic_map *bmap,
1863 enum isl_dim_type type, unsigned pos);
1864 __isl_give isl_map *isl_map_set_dim_id(
1865 __isl_take isl_map *map, enum isl_dim_type type,
1866 unsigned pos, __isl_take isl_id *id);
1867 int isl_map_has_dim_id(__isl_keep isl_map *map,
1868 enum isl_dim_type type, unsigned pos);
1869 __isl_give isl_id *isl_map_get_dim_id(
1870 __isl_keep isl_map *map, enum isl_dim_type type,
1873 int isl_set_find_dim_by_id(__isl_keep isl_set *set,
1874 enum isl_dim_type type, __isl_keep isl_id *id);
1875 int isl_map_find_dim_by_id(__isl_keep isl_map *map,
1876 enum isl_dim_type type, __isl_keep isl_id *id);
1877 int isl_set_find_dim_by_name(__isl_keep isl_set *set,
1878 enum isl_dim_type type, const char *name);
1879 int isl_map_find_dim_by_name(__isl_keep isl_map *map,
1880 enum isl_dim_type type, const char *name);
1882 const char *isl_constraint_get_dim_name(
1883 __isl_keep isl_constraint *constraint,
1884 enum isl_dim_type type, unsigned pos);
1885 const char *isl_basic_set_get_dim_name(
1886 __isl_keep isl_basic_set *bset,
1887 enum isl_dim_type type, unsigned pos);
1888 int isl_set_has_dim_name(__isl_keep isl_set *set,
1889 enum isl_dim_type type, unsigned pos);
1890 const char *isl_set_get_dim_name(
1891 __isl_keep isl_set *set,
1892 enum isl_dim_type type, unsigned pos);
1893 const char *isl_basic_map_get_dim_name(
1894 __isl_keep isl_basic_map *bmap,
1895 enum isl_dim_type type, unsigned pos);
1896 int isl_map_has_dim_name(__isl_keep isl_map *map,
1897 enum isl_dim_type type, unsigned pos);
1898 const char *isl_map_get_dim_name(
1899 __isl_keep isl_map *map,
1900 enum isl_dim_type type, unsigned pos);
1902 These functions are mostly useful to obtain the identifiers, positions
1903 or names of the parameters. Identifiers of individual dimensions are
1904 essentially only useful for printing. They are ignored by all other
1905 operations and may not be preserved across those operations.
1907 The user pointers on all parameters and tuples can be reset
1908 using the following functions.
1910 __isl_give isl_set *isl_set_reset_user(
1911 __isl_take isl_set *set);
1912 __isl_give isl_map *isl_map_reset_user(
1913 __isl_take isl_map *map);
1917 =head3 Unary Properties
1923 The following functions test whether the given set or relation
1924 contains any integer points. The ``plain'' variants do not perform
1925 any computations, but simply check if the given set or relation
1926 is already known to be empty.
1928 int isl_basic_set_plain_is_empty(__isl_keep isl_basic_set *bset);
1929 int isl_basic_set_is_empty(__isl_keep isl_basic_set *bset);
1930 int isl_set_plain_is_empty(__isl_keep isl_set *set);
1931 int isl_set_is_empty(__isl_keep isl_set *set);
1932 int isl_union_set_is_empty(__isl_keep isl_union_set *uset);
1933 int isl_basic_map_plain_is_empty(__isl_keep isl_basic_map *bmap);
1934 int isl_basic_map_is_empty(__isl_keep isl_basic_map *bmap);
1935 int isl_map_plain_is_empty(__isl_keep isl_map *map);
1936 int isl_map_is_empty(__isl_keep isl_map *map);
1937 int isl_union_map_is_empty(__isl_keep isl_union_map *umap);
1939 =item * Universality
1941 int isl_basic_set_is_universe(__isl_keep isl_basic_set *bset);
1942 int isl_basic_map_is_universe(__isl_keep isl_basic_map *bmap);
1943 int isl_set_plain_is_universe(__isl_keep isl_set *set);
1945 =item * Single-valuedness
1947 int isl_basic_map_is_single_valued(
1948 __isl_keep isl_basic_map *bmap);
1949 int isl_map_plain_is_single_valued(
1950 __isl_keep isl_map *map);
1951 int isl_map_is_single_valued(__isl_keep isl_map *map);
1952 int isl_union_map_is_single_valued(__isl_keep isl_union_map *umap);
1956 int isl_map_plain_is_injective(__isl_keep isl_map *map);
1957 int isl_map_is_injective(__isl_keep isl_map *map);
1958 int isl_union_map_plain_is_injective(
1959 __isl_keep isl_union_map *umap);
1960 int isl_union_map_is_injective(
1961 __isl_keep isl_union_map *umap);
1965 int isl_map_is_bijective(__isl_keep isl_map *map);
1966 int isl_union_map_is_bijective(__isl_keep isl_union_map *umap);
1970 __isl_give isl_val *
1971 isl_basic_map_plain_get_val_if_fixed(
1972 __isl_keep isl_basic_map *bmap,
1973 enum isl_dim_type type, unsigned pos);
1974 __isl_give isl_val *isl_set_plain_get_val_if_fixed(
1975 __isl_keep isl_set *set,
1976 enum isl_dim_type type, unsigned pos);
1977 __isl_give isl_val *isl_map_plain_get_val_if_fixed(
1978 __isl_keep isl_map *map,
1979 enum isl_dim_type type, unsigned pos);
1981 If the set or relation obviously lies on a hyperplane where the given dimension
1982 has a fixed value, then return that value.
1983 Otherwise return NaN.
1987 int isl_set_dim_residue_class_val(
1988 __isl_keep isl_set *set,
1989 int pos, __isl_give isl_val **modulo,
1990 __isl_give isl_val **residue);
1992 Check if the values of the given set dimension are equal to a fixed
1993 value modulo some integer value. If so, assign the modulo to C<*modulo>
1994 and the fixed value to C<*residue>. If the given dimension attains only
1995 a single value, then assign C<0> to C<*modulo> and the fixed value to
1997 If the dimension does not attain only a single value and if no modulo
1998 can be found then assign C<1> to C<*modulo> and C<1> to C<*residue>.
2002 To check whether a set is a parameter domain, use this function:
2004 int isl_set_is_params(__isl_keep isl_set *set);
2005 int isl_union_set_is_params(
2006 __isl_keep isl_union_set *uset);
2010 The following functions check whether the space of the given
2011 (basic) set or relation range is a wrapped relation.
2013 int isl_basic_set_is_wrapping(
2014 __isl_keep isl_basic_set *bset);
2015 int isl_set_is_wrapping(__isl_keep isl_set *set);
2016 int isl_map_range_is_wrapping(
2017 __isl_keep isl_map *map);
2019 =item * Internal Product
2021 int isl_basic_map_can_zip(
2022 __isl_keep isl_basic_map *bmap);
2023 int isl_map_can_zip(__isl_keep isl_map *map);
2025 Check whether the product of domain and range of the given relation
2027 i.e., whether both domain and range are nested relations.
2031 int isl_basic_map_can_curry(
2032 __isl_keep isl_basic_map *bmap);
2033 int isl_map_can_curry(__isl_keep isl_map *map);
2035 Check whether the domain of the (basic) relation is a wrapped relation.
2037 int isl_basic_map_can_uncurry(
2038 __isl_keep isl_basic_map *bmap);
2039 int isl_map_can_uncurry(__isl_keep isl_map *map);
2041 Check whether the range of the (basic) relation is a wrapped relation.
2045 =head3 Binary Properties
2051 int isl_basic_set_plain_is_equal(
2052 __isl_keep isl_basic_set *bset1,
2053 __isl_keep isl_basic_set *bset2);
2054 int isl_set_plain_is_equal(__isl_keep isl_set *set1,
2055 __isl_keep isl_set *set2);
2056 int isl_set_is_equal(__isl_keep isl_set *set1,
2057 __isl_keep isl_set *set2);
2058 int isl_union_set_is_equal(
2059 __isl_keep isl_union_set *uset1,
2060 __isl_keep isl_union_set *uset2);
2061 int isl_basic_map_is_equal(
2062 __isl_keep isl_basic_map *bmap1,
2063 __isl_keep isl_basic_map *bmap2);
2064 int isl_map_is_equal(__isl_keep isl_map *map1,
2065 __isl_keep isl_map *map2);
2066 int isl_map_plain_is_equal(__isl_keep isl_map *map1,
2067 __isl_keep isl_map *map2);
2068 int isl_union_map_is_equal(
2069 __isl_keep isl_union_map *umap1,
2070 __isl_keep isl_union_map *umap2);
2072 =item * Disjointness
2074 int isl_basic_set_is_disjoint(
2075 __isl_keep isl_basic_set *bset1,
2076 __isl_keep isl_basic_set *bset2);
2077 int isl_set_plain_is_disjoint(__isl_keep isl_set *set1,
2078 __isl_keep isl_set *set2);
2079 int isl_set_is_disjoint(__isl_keep isl_set *set1,
2080 __isl_keep isl_set *set2);
2081 int isl_basic_map_is_disjoint(
2082 __isl_keep isl_basic_map *bmap1,
2083 __isl_keep isl_basic_map *bmap2);
2084 int isl_map_is_disjoint(__isl_keep isl_map *map1,
2085 __isl_keep isl_map *map2);
2089 int isl_basic_set_is_subset(
2090 __isl_keep isl_basic_set *bset1,
2091 __isl_keep isl_basic_set *bset2);
2092 int isl_set_is_subset(__isl_keep isl_set *set1,
2093 __isl_keep isl_set *set2);
2094 int isl_set_is_strict_subset(
2095 __isl_keep isl_set *set1,
2096 __isl_keep isl_set *set2);
2097 int isl_union_set_is_subset(
2098 __isl_keep isl_union_set *uset1,
2099 __isl_keep isl_union_set *uset2);
2100 int isl_union_set_is_strict_subset(
2101 __isl_keep isl_union_set *uset1,
2102 __isl_keep isl_union_set *uset2);
2103 int isl_basic_map_is_subset(
2104 __isl_keep isl_basic_map *bmap1,
2105 __isl_keep isl_basic_map *bmap2);
2106 int isl_basic_map_is_strict_subset(
2107 __isl_keep isl_basic_map *bmap1,
2108 __isl_keep isl_basic_map *bmap2);
2109 int isl_map_is_subset(
2110 __isl_keep isl_map *map1,
2111 __isl_keep isl_map *map2);
2112 int isl_map_is_strict_subset(
2113 __isl_keep isl_map *map1,
2114 __isl_keep isl_map *map2);
2115 int isl_union_map_is_subset(
2116 __isl_keep isl_union_map *umap1,
2117 __isl_keep isl_union_map *umap2);
2118 int isl_union_map_is_strict_subset(
2119 __isl_keep isl_union_map *umap1,
2120 __isl_keep isl_union_map *umap2);
2122 Check whether the first argument is a (strict) subset of the
2127 int isl_set_plain_cmp(__isl_keep isl_set *set1,
2128 __isl_keep isl_set *set2);
2130 This function is useful for sorting C<isl_set>s.
2131 The order depends on the internal representation of the inputs.
2132 The order is fixed over different calls to the function (assuming
2133 the internal representation of the inputs has not changed), but may
2134 change over different versions of C<isl>.
2138 =head2 Unary Operations
2144 __isl_give isl_set *isl_set_complement(
2145 __isl_take isl_set *set);
2146 __isl_give isl_map *isl_map_complement(
2147 __isl_take isl_map *map);
2151 __isl_give isl_basic_map *isl_basic_map_reverse(
2152 __isl_take isl_basic_map *bmap);
2153 __isl_give isl_map *isl_map_reverse(
2154 __isl_take isl_map *map);
2155 __isl_give isl_union_map *isl_union_map_reverse(
2156 __isl_take isl_union_map *umap);
2160 __isl_give isl_basic_set *isl_basic_set_project_out(
2161 __isl_take isl_basic_set *bset,
2162 enum isl_dim_type type, unsigned first, unsigned n);
2163 __isl_give isl_basic_map *isl_basic_map_project_out(
2164 __isl_take isl_basic_map *bmap,
2165 enum isl_dim_type type, unsigned first, unsigned n);
2166 __isl_give isl_set *isl_set_project_out(__isl_take isl_set *set,
2167 enum isl_dim_type type, unsigned first, unsigned n);
2168 __isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
2169 enum isl_dim_type type, unsigned first, unsigned n);
2170 __isl_give isl_basic_set *isl_basic_set_params(
2171 __isl_take isl_basic_set *bset);
2172 __isl_give isl_basic_set *isl_basic_map_domain(
2173 __isl_take isl_basic_map *bmap);
2174 __isl_give isl_basic_set *isl_basic_map_range(
2175 __isl_take isl_basic_map *bmap);
2176 __isl_give isl_set *isl_set_params(__isl_take isl_set *set);
2177 __isl_give isl_set *isl_map_params(__isl_take isl_map *map);
2178 __isl_give isl_set *isl_map_domain(
2179 __isl_take isl_map *bmap);
2180 __isl_give isl_set *isl_map_range(
2181 __isl_take isl_map *map);
2182 __isl_give isl_set *isl_union_set_params(
2183 __isl_take isl_union_set *uset);
2184 __isl_give isl_set *isl_union_map_params(
2185 __isl_take isl_union_map *umap);
2186 __isl_give isl_union_set *isl_union_map_domain(
2187 __isl_take isl_union_map *umap);
2188 __isl_give isl_union_set *isl_union_map_range(
2189 __isl_take isl_union_map *umap);
2191 __isl_give isl_basic_map *isl_basic_map_domain_map(
2192 __isl_take isl_basic_map *bmap);
2193 __isl_give isl_basic_map *isl_basic_map_range_map(
2194 __isl_take isl_basic_map *bmap);
2195 __isl_give isl_map *isl_map_domain_map(__isl_take isl_map *map);
2196 __isl_give isl_map *isl_map_range_map(__isl_take isl_map *map);
2197 __isl_give isl_union_map *isl_union_map_domain_map(
2198 __isl_take isl_union_map *umap);
2199 __isl_give isl_union_map *isl_union_map_range_map(
2200 __isl_take isl_union_map *umap);
2202 The functions above construct a (basic, regular or union) relation
2203 that maps (a wrapped version of) the input relation to its domain or range.
2207 __isl_give isl_basic_set *isl_basic_set_eliminate(
2208 __isl_take isl_basic_set *bset,
2209 enum isl_dim_type type,
2210 unsigned first, unsigned n);
2211 __isl_give isl_set *isl_set_eliminate(
2212 __isl_take isl_set *set, enum isl_dim_type type,
2213 unsigned first, unsigned n);
2214 __isl_give isl_basic_map *isl_basic_map_eliminate(
2215 __isl_take isl_basic_map *bmap,
2216 enum isl_dim_type type,
2217 unsigned first, unsigned n);
2218 __isl_give isl_map *isl_map_eliminate(
2219 __isl_take isl_map *map, enum isl_dim_type type,
2220 unsigned first, unsigned n);
2222 Eliminate the coefficients for the given dimensions from the constraints,
2223 without removing the dimensions.
2227 __isl_give isl_basic_set *isl_basic_set_fix_si(
2228 __isl_take isl_basic_set *bset,
2229 enum isl_dim_type type, unsigned pos, int value);
2230 __isl_give isl_basic_set *isl_basic_set_fix_val(
2231 __isl_take isl_basic_set *bset,
2232 enum isl_dim_type type, unsigned pos,
2233 __isl_take isl_val *v);
2234 __isl_give isl_set *isl_set_fix_si(__isl_take isl_set *set,
2235 enum isl_dim_type type, unsigned pos, int value);
2236 __isl_give isl_set *isl_set_fix_val(
2237 __isl_take isl_set *set,
2238 enum isl_dim_type type, unsigned pos,
2239 __isl_take isl_val *v);
2240 __isl_give isl_basic_map *isl_basic_map_fix_si(
2241 __isl_take isl_basic_map *bmap,
2242 enum isl_dim_type type, unsigned pos, int value);
2243 __isl_give isl_basic_map *isl_basic_map_fix_val(
2244 __isl_take isl_basic_map *bmap,
2245 enum isl_dim_type type, unsigned pos,
2246 __isl_take isl_val *v);
2247 __isl_give isl_map *isl_map_fix_si(__isl_take isl_map *map,
2248 enum isl_dim_type type, unsigned pos, int value);
2249 __isl_give isl_map *isl_map_fix_val(
2250 __isl_take isl_map *map,
2251 enum isl_dim_type type, unsigned pos,
2252 __isl_take isl_val *v);
2254 Intersect the set or relation with the hyperplane where the given
2255 dimension has the fixed given value.
2257 __isl_give isl_basic_map *isl_basic_map_lower_bound_si(
2258 __isl_take isl_basic_map *bmap,
2259 enum isl_dim_type type, unsigned pos, int value);
2260 __isl_give isl_basic_map *isl_basic_map_upper_bound_si(
2261 __isl_take isl_basic_map *bmap,
2262 enum isl_dim_type type, unsigned pos, int value);
2263 __isl_give isl_set *isl_set_lower_bound_si(
2264 __isl_take isl_set *set,
2265 enum isl_dim_type type, unsigned pos, int value);
2266 __isl_give isl_set *isl_set_lower_bound_val(
2267 __isl_take isl_set *set,
2268 enum isl_dim_type type, unsigned pos,
2269 __isl_take isl_val *value);
2270 __isl_give isl_map *isl_map_lower_bound_si(
2271 __isl_take isl_map *map,
2272 enum isl_dim_type type, unsigned pos, int value);
2273 __isl_give isl_set *isl_set_upper_bound_si(
2274 __isl_take isl_set *set,
2275 enum isl_dim_type type, unsigned pos, int value);
2276 __isl_give isl_set *isl_set_upper_bound_val(
2277 __isl_take isl_set *set,
2278 enum isl_dim_type type, unsigned pos,
2279 __isl_take isl_val *value);
2280 __isl_give isl_map *isl_map_upper_bound_si(
2281 __isl_take isl_map *map,
2282 enum isl_dim_type type, unsigned pos, int value);
2284 Intersect the set or relation with the half-space where the given
2285 dimension has a value bounded by the fixed given integer value.
2287 __isl_give isl_set *isl_set_equate(__isl_take isl_set *set,
2288 enum isl_dim_type type1, int pos1,
2289 enum isl_dim_type type2, int pos2);
2290 __isl_give isl_basic_map *isl_basic_map_equate(
2291 __isl_take isl_basic_map *bmap,
2292 enum isl_dim_type type1, int pos1,
2293 enum isl_dim_type type2, int pos2);
2294 __isl_give isl_map *isl_map_equate(__isl_take isl_map *map,
2295 enum isl_dim_type type1, int pos1,
2296 enum isl_dim_type type2, int pos2);
2298 Intersect the set or relation with the hyperplane where the given
2299 dimensions are equal to each other.
2301 __isl_give isl_map *isl_map_oppose(__isl_take isl_map *map,
2302 enum isl_dim_type type1, int pos1,
2303 enum isl_dim_type type2, int pos2);
2305 Intersect the relation with the hyperplane where the given
2306 dimensions have opposite values.
2308 __isl_give isl_basic_map *isl_basic_map_order_ge(
2309 __isl_take isl_basic_map *bmap,
2310 enum isl_dim_type type1, int pos1,
2311 enum isl_dim_type type2, int pos2);
2312 __isl_give isl_map *isl_map_order_lt(__isl_take isl_map *map,
2313 enum isl_dim_type type1, int pos1,
2314 enum isl_dim_type type2, int pos2);
2315 __isl_give isl_basic_map *isl_basic_map_order_gt(
2316 __isl_take isl_basic_map *bmap,
2317 enum isl_dim_type type1, int pos1,
2318 enum isl_dim_type type2, int pos2);
2319 __isl_give isl_map *isl_map_order_gt(__isl_take isl_map *map,
2320 enum isl_dim_type type1, int pos1,
2321 enum isl_dim_type type2, int pos2);
2323 Intersect the relation with the half-space where the given
2324 dimensions satisfy the given ordering.
2328 __isl_give isl_map *isl_set_identity(
2329 __isl_take isl_set *set);
2330 __isl_give isl_union_map *isl_union_set_identity(
2331 __isl_take isl_union_set *uset);
2333 Construct an identity relation on the given (union) set.
2337 __isl_give isl_basic_set *isl_basic_map_deltas(
2338 __isl_take isl_basic_map *bmap);
2339 __isl_give isl_set *isl_map_deltas(__isl_take isl_map *map);
2340 __isl_give isl_union_set *isl_union_map_deltas(
2341 __isl_take isl_union_map *umap);
2343 These functions return a (basic) set containing the differences
2344 between image elements and corresponding domain elements in the input.
2346 __isl_give isl_basic_map *isl_basic_map_deltas_map(
2347 __isl_take isl_basic_map *bmap);
2348 __isl_give isl_map *isl_map_deltas_map(
2349 __isl_take isl_map *map);
2350 __isl_give isl_union_map *isl_union_map_deltas_map(
2351 __isl_take isl_union_map *umap);
2353 The functions above construct a (basic, regular or union) relation
2354 that maps (a wrapped version of) the input relation to its delta set.
2358 Simplify the representation of a set or relation by trying
2359 to combine pairs of basic sets or relations into a single
2360 basic set or relation.
2362 __isl_give isl_set *isl_set_coalesce(__isl_take isl_set *set);
2363 __isl_give isl_map *isl_map_coalesce(__isl_take isl_map *map);
2364 __isl_give isl_union_set *isl_union_set_coalesce(
2365 __isl_take isl_union_set *uset);
2366 __isl_give isl_union_map *isl_union_map_coalesce(
2367 __isl_take isl_union_map *umap);
2369 One of the methods for combining pairs of basic sets or relations
2370 can result in coefficients that are much larger than those that appear
2371 in the constraints of the input. By default, the coefficients are
2372 not allowed to grow larger, but this can be changed by unsetting
2373 the following option.
2375 int isl_options_set_coalesce_bounded_wrapping(
2376 isl_ctx *ctx, int val);
2377 int isl_options_get_coalesce_bounded_wrapping(
2380 =item * Detecting equalities
2382 __isl_give isl_basic_set *isl_basic_set_detect_equalities(
2383 __isl_take isl_basic_set *bset);
2384 __isl_give isl_basic_map *isl_basic_map_detect_equalities(
2385 __isl_take isl_basic_map *bmap);
2386 __isl_give isl_set *isl_set_detect_equalities(
2387 __isl_take isl_set *set);
2388 __isl_give isl_map *isl_map_detect_equalities(
2389 __isl_take isl_map *map);
2390 __isl_give isl_union_set *isl_union_set_detect_equalities(
2391 __isl_take isl_union_set *uset);
2392 __isl_give isl_union_map *isl_union_map_detect_equalities(
2393 __isl_take isl_union_map *umap);
2395 Simplify the representation of a set or relation by detecting implicit
2398 =item * Removing redundant constraints
2400 __isl_give isl_basic_set *isl_basic_set_remove_redundancies(
2401 __isl_take isl_basic_set *bset);
2402 __isl_give isl_set *isl_set_remove_redundancies(
2403 __isl_take isl_set *set);
2404 __isl_give isl_basic_map *isl_basic_map_remove_redundancies(
2405 __isl_take isl_basic_map *bmap);
2406 __isl_give isl_map *isl_map_remove_redundancies(
2407 __isl_take isl_map *map);
2411 __isl_give isl_basic_set *isl_set_convex_hull(
2412 __isl_take isl_set *set);
2413 __isl_give isl_basic_map *isl_map_convex_hull(
2414 __isl_take isl_map *map);
2416 If the input set or relation has any existentially quantified
2417 variables, then the result of these operations is currently undefined.
2421 __isl_give isl_basic_set *
2422 isl_set_unshifted_simple_hull(
2423 __isl_take isl_set *set);
2424 __isl_give isl_basic_map *
2425 isl_map_unshifted_simple_hull(
2426 __isl_take isl_map *map);
2427 __isl_give isl_basic_set *isl_set_simple_hull(
2428 __isl_take isl_set *set);
2429 __isl_give isl_basic_map *isl_map_simple_hull(
2430 __isl_take isl_map *map);
2431 __isl_give isl_union_map *isl_union_map_simple_hull(
2432 __isl_take isl_union_map *umap);
2434 These functions compute a single basic set or relation
2435 that contains the whole input set or relation.
2436 In particular, the output is described by translates
2437 of the constraints describing the basic sets or relations in the input.
2438 In case of C<isl_set_unshifted_simple_hull>, only the original
2439 constraints are used, without any translation.
2443 (See \autoref{s:simple hull}.)
2449 __isl_give isl_basic_set *isl_basic_set_affine_hull(
2450 __isl_take isl_basic_set *bset);
2451 __isl_give isl_basic_set *isl_set_affine_hull(
2452 __isl_take isl_set *set);
2453 __isl_give isl_union_set *isl_union_set_affine_hull(
2454 __isl_take isl_union_set *uset);
2455 __isl_give isl_basic_map *isl_basic_map_affine_hull(
2456 __isl_take isl_basic_map *bmap);
2457 __isl_give isl_basic_map *isl_map_affine_hull(
2458 __isl_take isl_map *map);
2459 __isl_give isl_union_map *isl_union_map_affine_hull(
2460 __isl_take isl_union_map *umap);
2462 In case of union sets and relations, the affine hull is computed
2465 =item * Polyhedral hull
2467 __isl_give isl_basic_set *isl_set_polyhedral_hull(
2468 __isl_take isl_set *set);
2469 __isl_give isl_basic_map *isl_map_polyhedral_hull(
2470 __isl_take isl_map *map);
2471 __isl_give isl_union_set *isl_union_set_polyhedral_hull(
2472 __isl_take isl_union_set *uset);
2473 __isl_give isl_union_map *isl_union_map_polyhedral_hull(
2474 __isl_take isl_union_map *umap);
2476 These functions compute a single basic set or relation
2477 not involving any existentially quantified variables
2478 that contains the whole input set or relation.
2479 In case of union sets and relations, the polyhedral hull is computed
2482 =item * Other approximations
2484 __isl_give isl_basic_set *
2485 isl_basic_set_drop_constraints_involving_dims(
2486 __isl_take isl_basic_set *bset,
2487 enum isl_dim_type type,
2488 unsigned first, unsigned n);
2489 __isl_give isl_basic_map *
2490 isl_basic_map_drop_constraints_involving_dims(
2491 __isl_take isl_basic_map *bmap,
2492 enum isl_dim_type type,
2493 unsigned first, unsigned n);
2494 __isl_give isl_basic_set *
2495 isl_basic_set_drop_constraints_not_involving_dims(
2496 __isl_take isl_basic_set *bset,
2497 enum isl_dim_type type,
2498 unsigned first, unsigned n);
2499 __isl_give isl_set *
2500 isl_set_drop_constraints_involving_dims(
2501 __isl_take isl_set *set,
2502 enum isl_dim_type type,
2503 unsigned first, unsigned n);
2504 __isl_give isl_map *
2505 isl_map_drop_constraints_involving_dims(
2506 __isl_take isl_map *map,
2507 enum isl_dim_type type,
2508 unsigned first, unsigned n);
2510 These functions drop any constraints (not) involving the specified dimensions.
2511 Note that the result depends on the representation of the input.
2515 __isl_give isl_basic_set *isl_basic_set_sample(
2516 __isl_take isl_basic_set *bset);
2517 __isl_give isl_basic_set *isl_set_sample(
2518 __isl_take isl_set *set);
2519 __isl_give isl_basic_map *isl_basic_map_sample(
2520 __isl_take isl_basic_map *bmap);
2521 __isl_give isl_basic_map *isl_map_sample(
2522 __isl_take isl_map *map);
2524 If the input (basic) set or relation is non-empty, then return
2525 a singleton subset of the input. Otherwise, return an empty set.
2527 =item * Optimization
2529 #include <isl/ilp.h>
2530 __isl_give isl_val *isl_basic_set_max_val(
2531 __isl_keep isl_basic_set *bset,
2532 __isl_keep isl_aff *obj);
2533 __isl_give isl_val *isl_set_min_val(
2534 __isl_keep isl_set *set,
2535 __isl_keep isl_aff *obj);
2536 __isl_give isl_val *isl_set_max_val(
2537 __isl_keep isl_set *set,
2538 __isl_keep isl_aff *obj);
2540 Compute the minimum or maximum of the integer affine expression C<obj>
2541 over the points in C<set>, returning the result in C<opt>.
2542 The result is C<NULL> in case of an error, the optimal value in case
2543 there is one, negative infinity or infinity if the problem is unbounded and
2544 NaN if the problem is empty.
2546 =item * Parametric optimization
2548 __isl_give isl_pw_aff *isl_set_dim_min(
2549 __isl_take isl_set *set, int pos);
2550 __isl_give isl_pw_aff *isl_set_dim_max(
2551 __isl_take isl_set *set, int pos);
2552 __isl_give isl_pw_aff *isl_map_dim_max(
2553 __isl_take isl_map *map, int pos);
2555 Compute the minimum or maximum of the given set or output dimension
2556 as a function of the parameters (and input dimensions), but independently
2557 of the other set or output dimensions.
2558 For lexicographic optimization, see L<"Lexicographic Optimization">.
2562 The following functions compute either the set of (rational) coefficient
2563 values of valid constraints for the given set or the set of (rational)
2564 values satisfying the constraints with coefficients from the given set.
2565 Internally, these two sets of functions perform essentially the
2566 same operations, except that the set of coefficients is assumed to
2567 be a cone, while the set of values may be any polyhedron.
2568 The current implementation is based on the Farkas lemma and
2569 Fourier-Motzkin elimination, but this may change or be made optional
2570 in future. In particular, future implementations may use different
2571 dualization algorithms or skip the elimination step.
2573 __isl_give isl_basic_set *isl_basic_set_coefficients(
2574 __isl_take isl_basic_set *bset);
2575 __isl_give isl_basic_set *isl_set_coefficients(
2576 __isl_take isl_set *set);
2577 __isl_give isl_union_set *isl_union_set_coefficients(
2578 __isl_take isl_union_set *bset);
2579 __isl_give isl_basic_set *isl_basic_set_solutions(
2580 __isl_take isl_basic_set *bset);
2581 __isl_give isl_basic_set *isl_set_solutions(
2582 __isl_take isl_set *set);
2583 __isl_give isl_union_set *isl_union_set_solutions(
2584 __isl_take isl_union_set *bset);
2588 __isl_give isl_map *isl_map_fixed_power_val(
2589 __isl_take isl_map *map,
2590 __isl_take isl_val *exp);
2591 __isl_give isl_union_map *
2592 isl_union_map_fixed_power_val(
2593 __isl_take isl_union_map *umap,
2594 __isl_take isl_val *exp);
2596 Compute the given power of C<map>, where C<exp> is assumed to be non-zero.
2597 If the exponent C<exp> is negative, then the -C<exp> th power of the inverse
2598 of C<map> is computed.
2600 __isl_give isl_map *isl_map_power(__isl_take isl_map *map,
2602 __isl_give isl_union_map *isl_union_map_power(
2603 __isl_take isl_union_map *umap, int *exact);
2605 Compute a parametric representation for all positive powers I<k> of C<map>.
2606 The result maps I<k> to a nested relation corresponding to the
2607 I<k>th power of C<map>.
2608 The result may be an overapproximation. If the result is known to be exact,
2609 then C<*exact> is set to C<1>.
2611 =item * Transitive closure
2613 __isl_give isl_map *isl_map_transitive_closure(
2614 __isl_take isl_map *map, int *exact);
2615 __isl_give isl_union_map *isl_union_map_transitive_closure(
2616 __isl_take isl_union_map *umap, int *exact);
2618 Compute the transitive closure of C<map>.
2619 The result may be an overapproximation. If the result is known to be exact,
2620 then C<*exact> is set to C<1>.
2622 =item * Reaching path lengths
2624 __isl_give isl_map *isl_map_reaching_path_lengths(
2625 __isl_take isl_map *map, int *exact);
2627 Compute a relation that maps each element in the range of C<map>
2628 to the lengths of all paths composed of edges in C<map> that
2629 end up in the given element.
2630 The result may be an overapproximation. If the result is known to be exact,
2631 then C<*exact> is set to C<1>.
2632 To compute the I<maximal> path length, the resulting relation
2633 should be postprocessed by C<isl_map_lexmax>.
2634 In particular, if the input relation is a dependence relation
2635 (mapping sources to sinks), then the maximal path length corresponds
2636 to the free schedule.
2637 Note, however, that C<isl_map_lexmax> expects the maximum to be
2638 finite, so if the path lengths are unbounded (possibly due to
2639 the overapproximation), then you will get an error message.
2643 __isl_give isl_basic_set *isl_basic_map_wrap(
2644 __isl_take isl_basic_map *bmap);
2645 __isl_give isl_set *isl_map_wrap(
2646 __isl_take isl_map *map);
2647 __isl_give isl_union_set *isl_union_map_wrap(
2648 __isl_take isl_union_map *umap);
2649 __isl_give isl_basic_map *isl_basic_set_unwrap(
2650 __isl_take isl_basic_set *bset);
2651 __isl_give isl_map *isl_set_unwrap(
2652 __isl_take isl_set *set);
2653 __isl_give isl_union_map *isl_union_set_unwrap(
2654 __isl_take isl_union_set *uset);
2658 Remove any internal structure of domain (and range) of the given
2659 set or relation. If there is any such internal structure in the input,
2660 then the name of the space is also removed.
2662 __isl_give isl_basic_set *isl_basic_set_flatten(
2663 __isl_take isl_basic_set *bset);
2664 __isl_give isl_set *isl_set_flatten(
2665 __isl_take isl_set *set);
2666 __isl_give isl_basic_map *isl_basic_map_flatten_domain(
2667 __isl_take isl_basic_map *bmap);
2668 __isl_give isl_basic_map *isl_basic_map_flatten_range(
2669 __isl_take isl_basic_map *bmap);
2670 __isl_give isl_map *isl_map_flatten_range(
2671 __isl_take isl_map *map);
2672 __isl_give isl_map *isl_map_flatten_domain(
2673 __isl_take isl_map *map);
2674 __isl_give isl_basic_map *isl_basic_map_flatten(
2675 __isl_take isl_basic_map *bmap);
2676 __isl_give isl_map *isl_map_flatten(
2677 __isl_take isl_map *map);
2679 __isl_give isl_map *isl_set_flatten_map(
2680 __isl_take isl_set *set);
2682 The function above constructs a relation
2683 that maps the input set to a flattened version of the set.
2687 Lift the input set to a space with extra dimensions corresponding
2688 to the existentially quantified variables in the input.
2689 In particular, the result lives in a wrapped map where the domain
2690 is the original space and the range corresponds to the original
2691 existentially quantified variables.
2693 __isl_give isl_basic_set *isl_basic_set_lift(
2694 __isl_take isl_basic_set *bset);
2695 __isl_give isl_set *isl_set_lift(
2696 __isl_take isl_set *set);
2697 __isl_give isl_union_set *isl_union_set_lift(
2698 __isl_take isl_union_set *uset);
2700 Given a local space that contains the existentially quantified
2701 variables of a set, a basic relation that, when applied to
2702 a basic set, has essentially the same effect as C<isl_basic_set_lift>,
2703 can be constructed using the following function.
2705 #include <isl/local_space.h>
2706 __isl_give isl_basic_map *isl_local_space_lifting(
2707 __isl_take isl_local_space *ls);
2709 =item * Internal Product
2711 __isl_give isl_basic_map *isl_basic_map_zip(
2712 __isl_take isl_basic_map *bmap);
2713 __isl_give isl_map *isl_map_zip(
2714 __isl_take isl_map *map);
2715 __isl_give isl_union_map *isl_union_map_zip(
2716 __isl_take isl_union_map *umap);
2718 Given a relation with nested relations for domain and range,
2719 interchange the range of the domain with the domain of the range.
2723 __isl_give isl_basic_map *isl_basic_map_curry(
2724 __isl_take isl_basic_map *bmap);
2725 __isl_give isl_basic_map *isl_basic_map_uncurry(
2726 __isl_take isl_basic_map *bmap);
2727 __isl_give isl_map *isl_map_curry(
2728 __isl_take isl_map *map);
2729 __isl_give isl_map *isl_map_uncurry(
2730 __isl_take isl_map *map);
2731 __isl_give isl_union_map *isl_union_map_curry(
2732 __isl_take isl_union_map *umap);
2733 __isl_give isl_union_map *isl_union_map_uncurry(
2734 __isl_take isl_union_map *umap);
2736 Given a relation with a nested relation for domain,
2737 the C<curry> functions
2738 move the range of the nested relation out of the domain
2739 and use it as the domain of a nested relation in the range,
2740 with the original range as range of this nested relation.
2741 The C<uncurry> functions perform the inverse operation.
2743 =item * Aligning parameters
2745 __isl_give isl_basic_set *isl_basic_set_align_params(
2746 __isl_take isl_basic_set *bset,
2747 __isl_take isl_space *model);
2748 __isl_give isl_set *isl_set_align_params(
2749 __isl_take isl_set *set,
2750 __isl_take isl_space *model);
2751 __isl_give isl_basic_map *isl_basic_map_align_params(
2752 __isl_take isl_basic_map *bmap,
2753 __isl_take isl_space *model);
2754 __isl_give isl_map *isl_map_align_params(
2755 __isl_take isl_map *map,
2756 __isl_take isl_space *model);
2758 Change the order of the parameters of the given set or relation
2759 such that the first parameters match those of C<model>.
2760 This may involve the introduction of extra parameters.
2761 All parameters need to be named.
2763 =item * Dimension manipulation
2765 __isl_give isl_basic_set *isl_basic_set_add_dims(
2766 __isl_take isl_basic_set *bset,
2767 enum isl_dim_type type, unsigned n);
2768 __isl_give isl_set *isl_set_add_dims(
2769 __isl_take isl_set *set,
2770 enum isl_dim_type type, unsigned n);
2771 __isl_give isl_map *isl_map_add_dims(
2772 __isl_take isl_map *map,
2773 enum isl_dim_type type, unsigned n);
2774 __isl_give isl_basic_set *isl_basic_set_insert_dims(
2775 __isl_take isl_basic_set *bset,
2776 enum isl_dim_type type, unsigned pos,
2778 __isl_give isl_basic_map *isl_basic_map_insert_dims(
2779 __isl_take isl_basic_map *bmap,
2780 enum isl_dim_type type, unsigned pos,
2782 __isl_give isl_set *isl_set_insert_dims(
2783 __isl_take isl_set *set,
2784 enum isl_dim_type type, unsigned pos, unsigned n);
2785 __isl_give isl_map *isl_map_insert_dims(
2786 __isl_take isl_map *map,
2787 enum isl_dim_type type, unsigned pos, unsigned n);
2788 __isl_give isl_basic_set *isl_basic_set_move_dims(
2789 __isl_take isl_basic_set *bset,
2790 enum isl_dim_type dst_type, unsigned dst_pos,
2791 enum isl_dim_type src_type, unsigned src_pos,
2793 __isl_give isl_basic_map *isl_basic_map_move_dims(
2794 __isl_take isl_basic_map *bmap,
2795 enum isl_dim_type dst_type, unsigned dst_pos,
2796 enum isl_dim_type src_type, unsigned src_pos,
2798 __isl_give isl_set *isl_set_move_dims(
2799 __isl_take isl_set *set,
2800 enum isl_dim_type dst_type, unsigned dst_pos,
2801 enum isl_dim_type src_type, unsigned src_pos,
2803 __isl_give isl_map *isl_map_move_dims(
2804 __isl_take isl_map *map,
2805 enum isl_dim_type dst_type, unsigned dst_pos,
2806 enum isl_dim_type src_type, unsigned src_pos,
2809 It is usually not advisable to directly change the (input or output)
2810 space of a set or a relation as this removes the name and the internal
2811 structure of the space. However, the above functions can be useful
2812 to add new parameters, assuming
2813 C<isl_set_align_params> and C<isl_map_align_params>
2818 =head2 Binary Operations
2820 The two arguments of a binary operation not only need to live
2821 in the same C<isl_ctx>, they currently also need to have
2822 the same (number of) parameters.
2824 =head3 Basic Operations
2828 =item * Intersection
2830 __isl_give isl_basic_set *isl_basic_set_intersect_params(
2831 __isl_take isl_basic_set *bset1,
2832 __isl_take isl_basic_set *bset2);
2833 __isl_give isl_basic_set *isl_basic_set_intersect(
2834 __isl_take isl_basic_set *bset1,
2835 __isl_take isl_basic_set *bset2);
2836 __isl_give isl_set *isl_set_intersect_params(
2837 __isl_take isl_set *set,
2838 __isl_take isl_set *params);
2839 __isl_give isl_set *isl_set_intersect(
2840 __isl_take isl_set *set1,
2841 __isl_take isl_set *set2);
2842 __isl_give isl_union_set *isl_union_set_intersect_params(
2843 __isl_take isl_union_set *uset,
2844 __isl_take isl_set *set);
2845 __isl_give isl_union_map *isl_union_map_intersect_params(
2846 __isl_take isl_union_map *umap,
2847 __isl_take isl_set *set);
2848 __isl_give isl_union_set *isl_union_set_intersect(
2849 __isl_take isl_union_set *uset1,
2850 __isl_take isl_union_set *uset2);
2851 __isl_give isl_basic_map *isl_basic_map_intersect_domain(
2852 __isl_take isl_basic_map *bmap,
2853 __isl_take isl_basic_set *bset);
2854 __isl_give isl_basic_map *isl_basic_map_intersect_range(
2855 __isl_take isl_basic_map *bmap,
2856 __isl_take isl_basic_set *bset);
2857 __isl_give isl_basic_map *isl_basic_map_intersect(
2858 __isl_take isl_basic_map *bmap1,
2859 __isl_take isl_basic_map *bmap2);
2860 __isl_give isl_map *isl_map_intersect_params(
2861 __isl_take isl_map *map,
2862 __isl_take isl_set *params);
2863 __isl_give isl_map *isl_map_intersect_domain(
2864 __isl_take isl_map *map,
2865 __isl_take isl_set *set);
2866 __isl_give isl_map *isl_map_intersect_range(
2867 __isl_take isl_map *map,
2868 __isl_take isl_set *set);
2869 __isl_give isl_map *isl_map_intersect(
2870 __isl_take isl_map *map1,
2871 __isl_take isl_map *map2);
2872 __isl_give isl_union_map *isl_union_map_intersect_domain(
2873 __isl_take isl_union_map *umap,
2874 __isl_take isl_union_set *uset);
2875 __isl_give isl_union_map *isl_union_map_intersect_range(
2876 __isl_take isl_union_map *umap,
2877 __isl_take isl_union_set *uset);
2878 __isl_give isl_union_map *isl_union_map_intersect(
2879 __isl_take isl_union_map *umap1,
2880 __isl_take isl_union_map *umap2);
2882 The second argument to the C<_params> functions needs to be
2883 a parametric (basic) set. For the other functions, a parametric set
2884 for either argument is only allowed if the other argument is
2885 a parametric set as well.
2889 __isl_give isl_set *isl_basic_set_union(
2890 __isl_take isl_basic_set *bset1,
2891 __isl_take isl_basic_set *bset2);
2892 __isl_give isl_map *isl_basic_map_union(
2893 __isl_take isl_basic_map *bmap1,
2894 __isl_take isl_basic_map *bmap2);
2895 __isl_give isl_set *isl_set_union(
2896 __isl_take isl_set *set1,
2897 __isl_take isl_set *set2);
2898 __isl_give isl_map *isl_map_union(
2899 __isl_take isl_map *map1,
2900 __isl_take isl_map *map2);
2901 __isl_give isl_union_set *isl_union_set_union(
2902 __isl_take isl_union_set *uset1,
2903 __isl_take isl_union_set *uset2);
2904 __isl_give isl_union_map *isl_union_map_union(
2905 __isl_take isl_union_map *umap1,
2906 __isl_take isl_union_map *umap2);
2908 =item * Set difference
2910 __isl_give isl_set *isl_set_subtract(
2911 __isl_take isl_set *set1,
2912 __isl_take isl_set *set2);
2913 __isl_give isl_map *isl_map_subtract(
2914 __isl_take isl_map *map1,
2915 __isl_take isl_map *map2);
2916 __isl_give isl_map *isl_map_subtract_domain(
2917 __isl_take isl_map *map,
2918 __isl_take isl_set *dom);
2919 __isl_give isl_map *isl_map_subtract_range(
2920 __isl_take isl_map *map,
2921 __isl_take isl_set *dom);
2922 __isl_give isl_union_set *isl_union_set_subtract(
2923 __isl_take isl_union_set *uset1,
2924 __isl_take isl_union_set *uset2);
2925 __isl_give isl_union_map *isl_union_map_subtract(
2926 __isl_take isl_union_map *umap1,
2927 __isl_take isl_union_map *umap2);
2928 __isl_give isl_union_map *isl_union_map_subtract_domain(
2929 __isl_take isl_union_map *umap,
2930 __isl_take isl_union_set *dom);
2931 __isl_give isl_union_map *isl_union_map_subtract_range(
2932 __isl_take isl_union_map *umap,
2933 __isl_take isl_union_set *dom);
2937 __isl_give isl_basic_set *isl_basic_set_apply(
2938 __isl_take isl_basic_set *bset,
2939 __isl_take isl_basic_map *bmap);
2940 __isl_give isl_set *isl_set_apply(
2941 __isl_take isl_set *set,
2942 __isl_take isl_map *map);
2943 __isl_give isl_union_set *isl_union_set_apply(
2944 __isl_take isl_union_set *uset,
2945 __isl_take isl_union_map *umap);
2946 __isl_give isl_basic_map *isl_basic_map_apply_domain(
2947 __isl_take isl_basic_map *bmap1,
2948 __isl_take isl_basic_map *bmap2);
2949 __isl_give isl_basic_map *isl_basic_map_apply_range(
2950 __isl_take isl_basic_map *bmap1,
2951 __isl_take isl_basic_map *bmap2);
2952 __isl_give isl_map *isl_map_apply_domain(
2953 __isl_take isl_map *map1,
2954 __isl_take isl_map *map2);
2955 __isl_give isl_union_map *isl_union_map_apply_domain(
2956 __isl_take isl_union_map *umap1,
2957 __isl_take isl_union_map *umap2);
2958 __isl_give isl_map *isl_map_apply_range(
2959 __isl_take isl_map *map1,
2960 __isl_take isl_map *map2);
2961 __isl_give isl_union_map *isl_union_map_apply_range(
2962 __isl_take isl_union_map *umap1,
2963 __isl_take isl_union_map *umap2);
2967 __isl_give isl_basic_set *
2968 isl_basic_set_preimage_multi_aff(
2969 __isl_take isl_basic_set *bset,
2970 __isl_take isl_multi_aff *ma);
2971 __isl_give isl_set *isl_set_preimage_multi_aff(
2972 __isl_take isl_set *set,
2973 __isl_take isl_multi_aff *ma);
2974 __isl_give isl_set *isl_set_preimage_pw_multi_aff(
2975 __isl_take isl_set *set,
2976 __isl_take isl_pw_multi_aff *pma);
2977 __isl_give isl_set *isl_set_preimage_multi_pw_aff(
2978 __isl_take isl_set *set,
2979 __isl_take isl_multi_pw_aff *mpa);
2980 __isl_give isl_basic_map *
2981 isl_basic_map_preimage_domain_multi_aff(
2982 __isl_take isl_basic_map *bmap,
2983 __isl_take isl_multi_aff *ma);
2984 __isl_give isl_map *isl_map_preimage_domain_multi_aff(
2985 __isl_take isl_map *map,
2986 __isl_take isl_multi_aff *ma);
2987 __isl_give isl_map *
2988 isl_map_preimage_domain_pw_multi_aff(
2989 __isl_take isl_map *map,
2990 __isl_take isl_pw_multi_aff *pma);
2991 __isl_give isl_map *
2992 isl_map_preimage_domain_multi_pw_aff(
2993 __isl_take isl_map *map,
2994 __isl_take isl_multi_pw_aff *mpa);
2995 __isl_give isl_union_map *
2996 isl_union_map_preimage_domain_multi_aff(
2997 __isl_take isl_union_map *umap,
2998 __isl_take isl_multi_aff *ma);
2999 __isl_give isl_basic_map *
3000 isl_basic_map_preimage_range_multi_aff(
3001 __isl_take isl_basic_map *bmap,
3002 __isl_take isl_multi_aff *ma);
3004 These functions compute the preimage of the given set or map domain/range under
3005 the given function. In other words, the expression is plugged
3006 into the set description or into the domain/range of the map.
3007 Objects of types C<isl_multi_aff> and C<isl_pw_multi_aff> are described in
3008 L</"Piecewise Multiple Quasi Affine Expressions">.
3010 =item * Cartesian Product
3012 __isl_give isl_set *isl_set_product(
3013 __isl_take isl_set *set1,
3014 __isl_take isl_set *set2);
3015 __isl_give isl_union_set *isl_union_set_product(
3016 __isl_take isl_union_set *uset1,
3017 __isl_take isl_union_set *uset2);
3018 __isl_give isl_basic_map *isl_basic_map_domain_product(
3019 __isl_take isl_basic_map *bmap1,
3020 __isl_take isl_basic_map *bmap2);
3021 __isl_give isl_basic_map *isl_basic_map_range_product(
3022 __isl_take isl_basic_map *bmap1,
3023 __isl_take isl_basic_map *bmap2);
3024 __isl_give isl_basic_map *isl_basic_map_product(
3025 __isl_take isl_basic_map *bmap1,
3026 __isl_take isl_basic_map *bmap2);
3027 __isl_give isl_map *isl_map_domain_product(
3028 __isl_take isl_map *map1,
3029 __isl_take isl_map *map2);
3030 __isl_give isl_map *isl_map_range_product(
3031 __isl_take isl_map *map1,
3032 __isl_take isl_map *map2);
3033 __isl_give isl_union_map *isl_union_map_domain_product(
3034 __isl_take isl_union_map *umap1,
3035 __isl_take isl_union_map *umap2);
3036 __isl_give isl_union_map *isl_union_map_range_product(
3037 __isl_take isl_union_map *umap1,
3038 __isl_take isl_union_map *umap2);
3039 __isl_give isl_map *isl_map_product(
3040 __isl_take isl_map *map1,
3041 __isl_take isl_map *map2);
3042 __isl_give isl_union_map *isl_union_map_product(
3043 __isl_take isl_union_map *umap1,
3044 __isl_take isl_union_map *umap2);
3046 The above functions compute the cross product of the given
3047 sets or relations. The domains and ranges of the results
3048 are wrapped maps between domains and ranges of the inputs.
3049 To obtain a ``flat'' product, use the following functions
3052 __isl_give isl_basic_set *isl_basic_set_flat_product(
3053 __isl_take isl_basic_set *bset1,
3054 __isl_take isl_basic_set *bset2);
3055 __isl_give isl_set *isl_set_flat_product(
3056 __isl_take isl_set *set1,
3057 __isl_take isl_set *set2);
3058 __isl_give isl_basic_map *isl_basic_map_flat_range_product(
3059 __isl_take isl_basic_map *bmap1,
3060 __isl_take isl_basic_map *bmap2);
3061 __isl_give isl_map *isl_map_flat_domain_product(
3062 __isl_take isl_map *map1,
3063 __isl_take isl_map *map2);
3064 __isl_give isl_map *isl_map_flat_range_product(
3065 __isl_take isl_map *map1,
3066 __isl_take isl_map *map2);
3067 __isl_give isl_union_map *isl_union_map_flat_range_product(
3068 __isl_take isl_union_map *umap1,
3069 __isl_take isl_union_map *umap2);
3070 __isl_give isl_basic_map *isl_basic_map_flat_product(
3071 __isl_take isl_basic_map *bmap1,
3072 __isl_take isl_basic_map *bmap2);
3073 __isl_give isl_map *isl_map_flat_product(
3074 __isl_take isl_map *map1,
3075 __isl_take isl_map *map2);
3077 The arguments of a call to C<isl_map_product> can be extracted
3078 from the result using the following two functions.
3080 __isl_give isl_map *isl_map_range_factor_domain(
3081 __isl_take isl_map *map);
3082 __isl_give isl_map *isl_map_range_factor_range(
3083 __isl_take isl_map *map);
3085 =item * Simplification
3087 __isl_give isl_basic_set *isl_basic_set_gist(
3088 __isl_take isl_basic_set *bset,
3089 __isl_take isl_basic_set *context);
3090 __isl_give isl_set *isl_set_gist(__isl_take isl_set *set,
3091 __isl_take isl_set *context);
3092 __isl_give isl_set *isl_set_gist_params(
3093 __isl_take isl_set *set,
3094 __isl_take isl_set *context);
3095 __isl_give isl_union_set *isl_union_set_gist(
3096 __isl_take isl_union_set *uset,
3097 __isl_take isl_union_set *context);
3098 __isl_give isl_union_set *isl_union_set_gist_params(
3099 __isl_take isl_union_set *uset,
3100 __isl_take isl_set *set);
3101 __isl_give isl_basic_map *isl_basic_map_gist(
3102 __isl_take isl_basic_map *bmap,
3103 __isl_take isl_basic_map *context);
3104 __isl_give isl_map *isl_map_gist(__isl_take isl_map *map,
3105 __isl_take isl_map *context);
3106 __isl_give isl_map *isl_map_gist_params(
3107 __isl_take isl_map *map,
3108 __isl_take isl_set *context);
3109 __isl_give isl_map *isl_map_gist_domain(
3110 __isl_take isl_map *map,
3111 __isl_take isl_set *context);
3112 __isl_give isl_map *isl_map_gist_range(
3113 __isl_take isl_map *map,
3114 __isl_take isl_set *context);
3115 __isl_give isl_union_map *isl_union_map_gist(
3116 __isl_take isl_union_map *umap,
3117 __isl_take isl_union_map *context);
3118 __isl_give isl_union_map *isl_union_map_gist_params(
3119 __isl_take isl_union_map *umap,
3120 __isl_take isl_set *set);
3121 __isl_give isl_union_map *isl_union_map_gist_domain(
3122 __isl_take isl_union_map *umap,
3123 __isl_take isl_union_set *uset);
3124 __isl_give isl_union_map *isl_union_map_gist_range(
3125 __isl_take isl_union_map *umap,
3126 __isl_take isl_union_set *uset);
3128 The gist operation returns a set or relation that has the
3129 same intersection with the context as the input set or relation.
3130 Any implicit equality in the intersection is made explicit in the result,
3131 while all inequalities that are redundant with respect to the intersection
3133 In case of union sets and relations, the gist operation is performed
3138 =head3 Lexicographic Optimization
3140 Given a (basic) set C<set> (or C<bset>) and a zero-dimensional domain C<dom>,
3141 the following functions
3142 compute a set that contains the lexicographic minimum or maximum
3143 of the elements in C<set> (or C<bset>) for those values of the parameters
3144 that satisfy C<dom>.
3145 If C<empty> is not C<NULL>, then C<*empty> is assigned a set
3146 that contains the parameter values in C<dom> for which C<set> (or C<bset>)
3148 In other words, the union of the parameter values
3149 for which the result is non-empty and of C<*empty>
3152 __isl_give isl_set *isl_basic_set_partial_lexmin(
3153 __isl_take isl_basic_set *bset,
3154 __isl_take isl_basic_set *dom,
3155 __isl_give isl_set **empty);
3156 __isl_give isl_set *isl_basic_set_partial_lexmax(
3157 __isl_take isl_basic_set *bset,
3158 __isl_take isl_basic_set *dom,
3159 __isl_give isl_set **empty);
3160 __isl_give isl_set *isl_set_partial_lexmin(
3161 __isl_take isl_set *set, __isl_take isl_set *dom,
3162 __isl_give isl_set **empty);
3163 __isl_give isl_set *isl_set_partial_lexmax(
3164 __isl_take isl_set *set, __isl_take isl_set *dom,
3165 __isl_give isl_set **empty);
3167 Given a (basic) set C<set> (or C<bset>), the following functions simply
3168 return a set containing the lexicographic minimum or maximum
3169 of the elements in C<set> (or C<bset>).
3170 In case of union sets, the optimum is computed per space.
3172 __isl_give isl_set *isl_basic_set_lexmin(
3173 __isl_take isl_basic_set *bset);
3174 __isl_give isl_set *isl_basic_set_lexmax(
3175 __isl_take isl_basic_set *bset);
3176 __isl_give isl_set *isl_set_lexmin(
3177 __isl_take isl_set *set);
3178 __isl_give isl_set *isl_set_lexmax(
3179 __isl_take isl_set *set);
3180 __isl_give isl_union_set *isl_union_set_lexmin(
3181 __isl_take isl_union_set *uset);
3182 __isl_give isl_union_set *isl_union_set_lexmax(
3183 __isl_take isl_union_set *uset);
3185 Given a (basic) relation C<map> (or C<bmap>) and a domain C<dom>,
3186 the following functions
3187 compute a relation that maps each element of C<dom>
3188 to the single lexicographic minimum or maximum
3189 of the elements that are associated to that same
3190 element in C<map> (or C<bmap>).
3191 If C<empty> is not C<NULL>, then C<*empty> is assigned a set
3192 that contains the elements in C<dom> that do not map
3193 to any elements in C<map> (or C<bmap>).
3194 In other words, the union of the domain of the result and of C<*empty>
3197 __isl_give isl_map *isl_basic_map_partial_lexmax(
3198 __isl_take isl_basic_map *bmap,
3199 __isl_take isl_basic_set *dom,
3200 __isl_give isl_set **empty);
3201 __isl_give isl_map *isl_basic_map_partial_lexmin(
3202 __isl_take isl_basic_map *bmap,
3203 __isl_take isl_basic_set *dom,
3204 __isl_give isl_set **empty);
3205 __isl_give isl_map *isl_map_partial_lexmax(
3206 __isl_take isl_map *map, __isl_take isl_set *dom,
3207 __isl_give isl_set **empty);
3208 __isl_give isl_map *isl_map_partial_lexmin(
3209 __isl_take isl_map *map, __isl_take isl_set *dom,
3210 __isl_give isl_set **empty);
3212 Given a (basic) map C<map> (or C<bmap>), the following functions simply
3213 return a map mapping each element in the domain of
3214 C<map> (or C<bmap>) to the lexicographic minimum or maximum
3215 of all elements associated to that element.
3216 In case of union relations, the optimum is computed per space.
3218 __isl_give isl_map *isl_basic_map_lexmin(
3219 __isl_take isl_basic_map *bmap);
3220 __isl_give isl_map *isl_basic_map_lexmax(
3221 __isl_take isl_basic_map *bmap);
3222 __isl_give isl_map *isl_map_lexmin(
3223 __isl_take isl_map *map);
3224 __isl_give isl_map *isl_map_lexmax(
3225 __isl_take isl_map *map);
3226 __isl_give isl_union_map *isl_union_map_lexmin(
3227 __isl_take isl_union_map *umap);
3228 __isl_give isl_union_map *isl_union_map_lexmax(
3229 __isl_take isl_union_map *umap);
3231 The following functions return their result in the form of
3232 a piecewise multi-affine expression
3233 (See L<"Piecewise Multiple Quasi Affine Expressions">),
3234 but are otherwise equivalent to the corresponding functions
3235 returning a basic set or relation.
3237 __isl_give isl_pw_multi_aff *
3238 isl_basic_map_lexmin_pw_multi_aff(
3239 __isl_take isl_basic_map *bmap);
3240 __isl_give isl_pw_multi_aff *
3241 isl_basic_set_partial_lexmin_pw_multi_aff(
3242 __isl_take isl_basic_set *bset,
3243 __isl_take isl_basic_set *dom,
3244 __isl_give isl_set **empty);
3245 __isl_give isl_pw_multi_aff *
3246 isl_basic_set_partial_lexmax_pw_multi_aff(
3247 __isl_take isl_basic_set *bset,
3248 __isl_take isl_basic_set *dom,
3249 __isl_give isl_set **empty);
3250 __isl_give isl_pw_multi_aff *
3251 isl_basic_map_partial_lexmin_pw_multi_aff(
3252 __isl_take isl_basic_map *bmap,
3253 __isl_take isl_basic_set *dom,
3254 __isl_give isl_set **empty);
3255 __isl_give isl_pw_multi_aff *
3256 isl_basic_map_partial_lexmax_pw_multi_aff(
3257 __isl_take isl_basic_map *bmap,
3258 __isl_take isl_basic_set *dom,
3259 __isl_give isl_set **empty);
3260 __isl_give isl_pw_multi_aff *isl_set_lexmin_pw_multi_aff(
3261 __isl_take isl_set *set);
3262 __isl_give isl_pw_multi_aff *isl_set_lexmax_pw_multi_aff(
3263 __isl_take isl_set *set);
3264 __isl_give isl_pw_multi_aff *isl_map_lexmin_pw_multi_aff(
3265 __isl_take isl_map *map);
3266 __isl_give isl_pw_multi_aff *isl_map_lexmax_pw_multi_aff(
3267 __isl_take isl_map *map);
3271 Lists are defined over several element types, including
3272 C<isl_val>, C<isl_id>, C<isl_aff>, C<isl_pw_aff>, C<isl_constraint>,
3273 C<isl_basic_set>, C<isl_set>, C<isl_ast_expr> and C<isl_ast_node>.
3274 Here we take lists of C<isl_set>s as an example.
3275 Lists can be created, copied, modified and freed using the following functions.
3277 #include <isl/list.h>
3278 __isl_give isl_set_list *isl_set_list_from_set(
3279 __isl_take isl_set *el);
3280 __isl_give isl_set_list *isl_set_list_alloc(
3281 isl_ctx *ctx, int n);
3282 __isl_give isl_set_list *isl_set_list_copy(
3283 __isl_keep isl_set_list *list);
3284 __isl_give isl_set_list *isl_set_list_insert(
3285 __isl_take isl_set_list *list, unsigned pos,
3286 __isl_take isl_set *el);
3287 __isl_give isl_set_list *isl_set_list_add(
3288 __isl_take isl_set_list *list,
3289 __isl_take isl_set *el);
3290 __isl_give isl_set_list *isl_set_list_drop(
3291 __isl_take isl_set_list *list,
3292 unsigned first, unsigned n);
3293 __isl_give isl_set_list *isl_set_list_set_set(
3294 __isl_take isl_set_list *list, int index,
3295 __isl_take isl_set *set);
3296 __isl_give isl_set_list *isl_set_list_concat(
3297 __isl_take isl_set_list *list1,
3298 __isl_take isl_set_list *list2);
3299 __isl_give isl_set_list *isl_set_list_sort(
3300 __isl_take isl_set_list *list,
3301 int (*cmp)(__isl_keep isl_set *a,
3302 __isl_keep isl_set *b, void *user),
3304 void *isl_set_list_free(__isl_take isl_set_list *list);
3306 C<isl_set_list_alloc> creates an empty list with a capacity for
3307 C<n> elements. C<isl_set_list_from_set> creates a list with a single
3310 Lists can be inspected using the following functions.
3312 #include <isl/list.h>
3313 isl_ctx *isl_set_list_get_ctx(__isl_keep isl_set_list *list);
3314 int isl_set_list_n_set(__isl_keep isl_set_list *list);
3315 __isl_give isl_set *isl_set_list_get_set(
3316 __isl_keep isl_set_list *list, int index);
3317 int isl_set_list_foreach(__isl_keep isl_set_list *list,
3318 int (*fn)(__isl_take isl_set *el, void *user),
3320 int isl_set_list_foreach_scc(__isl_keep isl_set_list *list,
3321 int (*follows)(__isl_keep isl_set *a,
3322 __isl_keep isl_set *b, void *user),
3324 int (*fn)(__isl_take isl_set *el, void *user),
3327 The function C<isl_set_list_foreach_scc> calls C<fn> on each of the
3328 strongly connected components of the graph with as vertices the elements
3329 of C<list> and a directed edge from vertex C<b> to vertex C<a>
3330 iff C<follows(a, b)> returns C<1>. The callbacks C<follows> and C<fn>
3331 should return C<-1> on error.
3333 Lists can be printed using
3335 #include <isl/list.h>
3336 __isl_give isl_printer *isl_printer_print_set_list(
3337 __isl_take isl_printer *p,
3338 __isl_keep isl_set_list *list);
3340 =head2 Associative arrays
3342 Associative arrays map isl objects of a specific type to isl objects
3343 of some (other) specific type. They are defined for several pairs
3344 of types, including (C<isl_map>, C<isl_basic_set>),
3345 (C<isl_id>, C<isl_ast_expr>) and.
3346 (C<isl_id>, C<isl_pw_aff>).
3347 Here, we take associative arrays that map C<isl_id>s to C<isl_ast_expr>s
3350 Associative arrays can be created, copied and freed using
3351 the following functions.
3353 #include <isl/id_to_ast_expr.h>
3354 __isl_give id_to_ast_expr *isl_id_to_ast_expr_alloc(
3355 isl_ctx *ctx, int min_size);
3356 __isl_give id_to_ast_expr *isl_id_to_ast_expr_copy(
3357 __isl_keep id_to_ast_expr *id2expr);
3358 void *isl_id_to_ast_expr_free(
3359 __isl_take id_to_ast_expr *id2expr);
3361 The C<min_size> argument to C<isl_id_to_ast_expr_alloc> can be used
3362 to specify the expected size of the associative array.
3363 The associative array will be grown automatically as needed.
3365 Associative arrays can be inspected using the following functions.
3367 #include <isl/id_to_ast_expr.h>
3368 isl_ctx *isl_id_to_ast_expr_get_ctx(
3369 __isl_keep id_to_ast_expr *id2expr);
3370 int isl_id_to_ast_expr_has(
3371 __isl_keep id_to_ast_expr *id2expr,
3372 __isl_keep isl_id *key);
3373 __isl_give isl_ast_expr *isl_id_to_ast_expr_get(
3374 __isl_keep id_to_ast_expr *id2expr,
3375 __isl_take isl_id *key);
3376 int isl_id_to_ast_expr_foreach(
3377 __isl_keep id_to_ast_expr *id2expr,
3378 int (*fn)(__isl_take isl_id *key,
3379 __isl_take isl_ast_expr *val, void *user),
3382 They can be modified using the following function.
3384 #include <isl/id_to_ast_expr.h>
3385 __isl_give id_to_ast_expr *isl_id_to_ast_expr_set(
3386 __isl_take id_to_ast_expr *id2expr,
3387 __isl_take isl_id *key,
3388 __isl_take isl_ast_expr *val);
3390 Associative arrays can be printed using the following function.
3392 #include <isl/id_to_ast_expr.h>
3393 __isl_give isl_printer *isl_printer_print_id_to_ast_expr(
3394 __isl_take isl_printer *p,
3395 __isl_keep id_to_ast_expr *id2expr);
3397 =head2 Multiple Values
3399 An C<isl_multi_val> object represents a sequence of zero or more values,
3400 living in a set space.
3402 An C<isl_multi_val> can be constructed from an C<isl_val_list>
3403 using the following function
3405 #include <isl/val.h>
3406 __isl_give isl_multi_val *isl_multi_val_from_val_list(
3407 __isl_take isl_space *space,
3408 __isl_take isl_val_list *list);
3410 The zero multiple value (with value zero for each set dimension)
3411 can be created using the following function.
3413 #include <isl/val.h>
3414 __isl_give isl_multi_val *isl_multi_val_zero(
3415 __isl_take isl_space *space);
3417 Multiple values can be copied and freed using
3419 #include <isl/val.h>
3420 __isl_give isl_multi_val *isl_multi_val_copy(
3421 __isl_keep isl_multi_val *mv);
3422 void *isl_multi_val_free(__isl_take isl_multi_val *mv);
3424 They can be inspected using
3426 #include <isl/val.h>
3427 isl_ctx *isl_multi_val_get_ctx(
3428 __isl_keep isl_multi_val *mv);
3429 unsigned isl_multi_val_dim(__isl_keep isl_multi_val *mv,
3430 enum isl_dim_type type);
3431 __isl_give isl_val *isl_multi_val_get_val(
3432 __isl_keep isl_multi_val *mv, int pos);
3433 int isl_multi_val_find_dim_by_id(
3434 __isl_keep isl_multi_val *mv,
3435 enum isl_dim_type type, __isl_keep isl_id *id);
3436 __isl_give isl_id *isl_multi_val_get_dim_id(
3437 __isl_keep isl_multi_val *mv,
3438 enum isl_dim_type type, unsigned pos);
3439 const char *isl_multi_val_get_tuple_name(
3440 __isl_keep isl_multi_val *mv,
3441 enum isl_dim_type type);
3442 int isl_multi_val_has_tuple_id(__isl_keep isl_multi_val *mv,
3443 enum isl_dim_type type);
3444 __isl_give isl_id *isl_multi_val_get_tuple_id(
3445 __isl_keep isl_multi_val *mv,
3446 enum isl_dim_type type);
3447 int isl_multi_val_range_is_wrapping(
3448 __isl_keep isl_multi_val *mv);
3450 They can be modified using
3452 #include <isl/val.h>
3453 __isl_give isl_multi_val *isl_multi_val_set_val(
3454 __isl_take isl_multi_val *mv, int pos,
3455 __isl_take isl_val *val);
3456 __isl_give isl_multi_val *isl_multi_val_set_dim_name(
3457 __isl_take isl_multi_val *mv,
3458 enum isl_dim_type type, unsigned pos, const char *s);
3459 __isl_give isl_multi_val *isl_multi_val_set_dim_id(
3460 __isl_take isl_multi_val *mv,
3461 enum isl_dim_type type, unsigned pos,
3462 __isl_take isl_id *id);
3463 __isl_give isl_multi_val *isl_multi_val_set_tuple_name(
3464 __isl_take isl_multi_val *mv,
3465 enum isl_dim_type type, const char *s);
3466 __isl_give isl_multi_val *isl_multi_val_set_tuple_id(
3467 __isl_take isl_multi_val *mv,
3468 enum isl_dim_type type, __isl_take isl_id *id);
3469 __isl_give isl_multi_val *isl_multi_val_reset_tuple_id(
3470 __isl_take isl_multi_val *mv,
3471 enum isl_dim_type type);
3472 __isl_give isl_multi_val *isl_multi_val_reset_user(
3473 __isl_take isl_multi_val *mv);
3475 __isl_give isl_multi_val *isl_multi_val_insert_dims(
3476 __isl_take isl_multi_val *mv,
3477 enum isl_dim_type type, unsigned first, unsigned n);
3478 __isl_give isl_multi_val *isl_multi_val_add_dims(
3479 __isl_take isl_multi_val *mv,
3480 enum isl_dim_type type, unsigned n);
3481 __isl_give isl_multi_val *isl_multi_val_drop_dims(
3482 __isl_take isl_multi_val *mv,
3483 enum isl_dim_type type, unsigned first, unsigned n);
3487 #include <isl/val.h>
3488 __isl_give isl_multi_val *isl_multi_val_align_params(
3489 __isl_take isl_multi_val *mv,
3490 __isl_take isl_space *model);
3491 __isl_give isl_multi_val *isl_multi_val_from_range(
3492 __isl_take isl_multi_val *mv);
3493 __isl_give isl_multi_val *isl_multi_val_range_splice(
3494 __isl_take isl_multi_val *mv1, unsigned pos,
3495 __isl_take isl_multi_val *mv2);
3496 __isl_give isl_multi_val *isl_multi_val_range_product(
3497 __isl_take isl_multi_val *mv1,
3498 __isl_take isl_multi_val *mv2);
3499 __isl_give isl_multi_val *
3500 isl_multi_val_range_factor_domain(
3501 __isl_take isl_multi_val *mv);
3502 __isl_give isl_multi_val *
3503 isl_multi_val_range_factor_range(
3504 __isl_take isl_multi_val *mv);
3505 __isl_give isl_multi_val *isl_multi_val_flat_range_product(
3506 __isl_take isl_multi_val *mv1,
3507 __isl_take isl_multi_aff *mv2);
3508 __isl_give isl_multi_val *isl_multi_val_product(
3509 __isl_take isl_multi_val *mv1,
3510 __isl_take isl_multi_val *mv2);
3511 __isl_give isl_multi_val *isl_multi_val_add_val(
3512 __isl_take isl_multi_val *mv,
3513 __isl_take isl_val *v);
3514 __isl_give isl_multi_val *isl_multi_val_mod_val(
3515 __isl_take isl_multi_val *mv,
3516 __isl_take isl_val *v);
3517 __isl_give isl_multi_val *isl_multi_val_scale_val(
3518 __isl_take isl_multi_val *mv,
3519 __isl_take isl_val *v);
3520 __isl_give isl_multi_val *isl_multi_val_scale_multi_val(
3521 __isl_take isl_multi_val *mv1,
3522 __isl_take isl_multi_val *mv2);
3523 __isl_give isl_multi_val *
3524 isl_multi_val_scale_down_multi_val(
3525 __isl_take isl_multi_val *mv1,
3526 __isl_take isl_multi_val *mv2);
3528 A multiple value can be printed using
3530 __isl_give isl_printer *isl_printer_print_multi_val(
3531 __isl_take isl_printer *p,
3532 __isl_keep isl_multi_val *mv);
3536 Vectors can be created, copied and freed using the following functions.
3538 #include <isl/vec.h>
3539 __isl_give isl_vec *isl_vec_alloc(isl_ctx *ctx,
3541 __isl_give isl_vec *isl_vec_copy(__isl_keep isl_vec *vec);
3542 void *isl_vec_free(__isl_take isl_vec *vec);
3544 Note that the elements of a newly created vector may have arbitrary values.
3545 The elements can be changed and inspected using the following functions.
3547 isl_ctx *isl_vec_get_ctx(__isl_keep isl_vec *vec);
3548 int isl_vec_size(__isl_keep isl_vec *vec);
3549 __isl_give isl_val *isl_vec_get_element_val(
3550 __isl_keep isl_vec *vec, int pos);
3551 __isl_give isl_vec *isl_vec_set_element_si(
3552 __isl_take isl_vec *vec, int pos, int v);
3553 __isl_give isl_vec *isl_vec_set_element_val(
3554 __isl_take isl_vec *vec, int pos,
3555 __isl_take isl_val *v);
3556 __isl_give isl_vec *isl_vec_set_si(__isl_take isl_vec *vec,
3558 __isl_give isl_vec *isl_vec_set_val(
3559 __isl_take isl_vec *vec, __isl_take isl_val *v);
3560 int isl_vec_cmp_element(__isl_keep isl_vec *vec1,
3561 __isl_keep isl_vec *vec2, int pos);
3563 C<isl_vec_get_element> will return a negative value if anything went wrong.
3564 In that case, the value of C<*v> is undefined.
3566 The following function can be used to concatenate two vectors.
3568 __isl_give isl_vec *isl_vec_concat(__isl_take isl_vec *vec1,
3569 __isl_take isl_vec *vec2);
3573 Matrices can be created, copied and freed using the following functions.
3575 #include <isl/mat.h>
3576 __isl_give isl_mat *isl_mat_alloc(isl_ctx *ctx,
3577 unsigned n_row, unsigned n_col);
3578 __isl_give isl_mat *isl_mat_copy(__isl_keep isl_mat *mat);
3579 void *isl_mat_free(__isl_take isl_mat *mat);
3581 Note that the elements of a newly created matrix may have arbitrary values.
3582 The elements can be changed and inspected using the following functions.
3584 isl_ctx *isl_mat_get_ctx(__isl_keep isl_mat *mat);
3585 int isl_mat_rows(__isl_keep isl_mat *mat);
3586 int isl_mat_cols(__isl_keep isl_mat *mat);
3587 __isl_give isl_val *isl_mat_get_element_val(
3588 __isl_keep isl_mat *mat, int row, int col);
3589 __isl_give isl_mat *isl_mat_set_element_si(__isl_take isl_mat *mat,
3590 int row, int col, int v);
3591 __isl_give isl_mat *isl_mat_set_element_val(
3592 __isl_take isl_mat *mat, int row, int col,
3593 __isl_take isl_val *v);
3595 C<isl_mat_get_element> will return a negative value if anything went wrong.
3596 In that case, the value of C<*v> is undefined.
3598 The following function can be used to compute the (right) inverse
3599 of a matrix, i.e., a matrix such that the product of the original
3600 and the inverse (in that order) is a multiple of the identity matrix.
3601 The input matrix is assumed to be of full row-rank.
3603 __isl_give isl_mat *isl_mat_right_inverse(__isl_take isl_mat *mat);
3605 The following function can be used to compute the (right) kernel
3606 (or null space) of a matrix, i.e., a matrix such that the product of
3607 the original and the kernel (in that order) is the zero matrix.
3609 __isl_give isl_mat *isl_mat_right_kernel(__isl_take isl_mat *mat);
3611 =head2 Piecewise Quasi Affine Expressions
3613 The zero quasi affine expression or the quasi affine expression
3614 that is equal to a given value or
3615 a specified dimension on a given domain can be created using
3617 __isl_give isl_aff *isl_aff_zero_on_domain(
3618 __isl_take isl_local_space *ls);
3619 __isl_give isl_pw_aff *isl_pw_aff_zero_on_domain(
3620 __isl_take isl_local_space *ls);
3621 __isl_give isl_aff *isl_aff_val_on_domain(
3622 __isl_take isl_local_space *ls,
3623 __isl_take isl_val *val);
3624 __isl_give isl_aff *isl_aff_var_on_domain(
3625 __isl_take isl_local_space *ls,
3626 enum isl_dim_type type, unsigned pos);
3627 __isl_give isl_pw_aff *isl_pw_aff_var_on_domain(
3628 __isl_take isl_local_space *ls,
3629 enum isl_dim_type type, unsigned pos);
3631 Note that the space in which the resulting objects live is a map space
3632 with the given space as domain and a one-dimensional range.
3634 An empty piecewise quasi affine expression (one with no cells)
3635 or a piecewise quasi affine expression with a single cell can
3636 be created using the following functions.
3638 #include <isl/aff.h>
3639 __isl_give isl_pw_aff *isl_pw_aff_empty(
3640 __isl_take isl_space *space);
3641 __isl_give isl_pw_aff *isl_pw_aff_alloc(
3642 __isl_take isl_set *set, __isl_take isl_aff *aff);
3643 __isl_give isl_pw_aff *isl_pw_aff_from_aff(
3644 __isl_take isl_aff *aff);
3646 A piecewise quasi affine expression that is equal to 1 on a set
3647 and 0 outside the set can be created using the following function.
3649 #include <isl/aff.h>
3650 __isl_give isl_pw_aff *isl_set_indicator_function(
3651 __isl_take isl_set *set);
3653 Quasi affine expressions can be copied and freed using
3655 #include <isl/aff.h>
3656 __isl_give isl_aff *isl_aff_copy(__isl_keep isl_aff *aff);
3657 void *isl_aff_free(__isl_take isl_aff *aff);
3659 __isl_give isl_pw_aff *isl_pw_aff_copy(
3660 __isl_keep isl_pw_aff *pwaff);
3661 void *isl_pw_aff_free(__isl_take isl_pw_aff *pwaff);
3663 A (rational) bound on a dimension can be extracted from an C<isl_constraint>
3664 using the following function. The constraint is required to have
3665 a non-zero coefficient for the specified dimension.
3667 #include <isl/constraint.h>
3668 __isl_give isl_aff *isl_constraint_get_bound(
3669 __isl_keep isl_constraint *constraint,
3670 enum isl_dim_type type, int pos);
3672 The entire affine expression of the constraint can also be extracted
3673 using the following function.
3675 #include <isl/constraint.h>
3676 __isl_give isl_aff *isl_constraint_get_aff(
3677 __isl_keep isl_constraint *constraint);
3679 Conversely, an equality constraint equating
3680 the affine expression to zero or an inequality constraint enforcing
3681 the affine expression to be non-negative, can be constructed using
3683 __isl_give isl_constraint *isl_equality_from_aff(
3684 __isl_take isl_aff *aff);
3685 __isl_give isl_constraint *isl_inequality_from_aff(
3686 __isl_take isl_aff *aff);
3688 The expression can be inspected using
3690 #include <isl/aff.h>
3691 isl_ctx *isl_aff_get_ctx(__isl_keep isl_aff *aff);
3692 int isl_aff_dim(__isl_keep isl_aff *aff,
3693 enum isl_dim_type type);
3694 __isl_give isl_local_space *isl_aff_get_domain_local_space(
3695 __isl_keep isl_aff *aff);
3696 __isl_give isl_local_space *isl_aff_get_local_space(
3697 __isl_keep isl_aff *aff);
3698 const char *isl_aff_get_dim_name(__isl_keep isl_aff *aff,
3699 enum isl_dim_type type, unsigned pos);
3700 const char *isl_pw_aff_get_dim_name(
3701 __isl_keep isl_pw_aff *pa,
3702 enum isl_dim_type type, unsigned pos);
3703 int isl_pw_aff_has_dim_id(__isl_keep isl_pw_aff *pa,
3704 enum isl_dim_type type, unsigned pos);
3705 __isl_give isl_id *isl_pw_aff_get_dim_id(
3706 __isl_keep isl_pw_aff *pa,
3707 enum isl_dim_type type, unsigned pos);
3708 int isl_pw_aff_has_tuple_id(__isl_keep isl_pw_aff *pa,
3709 enum isl_dim_type type);
3710 __isl_give isl_id *isl_pw_aff_get_tuple_id(
3711 __isl_keep isl_pw_aff *pa,
3712 enum isl_dim_type type);
3713 __isl_give isl_val *isl_aff_get_constant_val(
3714 __isl_keep isl_aff *aff);
3715 __isl_give isl_val *isl_aff_get_coefficient_val(
3716 __isl_keep isl_aff *aff,
3717 enum isl_dim_type type, int pos);
3718 __isl_give isl_val *isl_aff_get_denominator_val(
3719 __isl_keep isl_aff *aff);
3720 __isl_give isl_aff *isl_aff_get_div(
3721 __isl_keep isl_aff *aff, int pos);
3723 int isl_pw_aff_n_piece(__isl_keep isl_pw_aff *pwaff);
3724 int isl_pw_aff_foreach_piece(__isl_keep isl_pw_aff *pwaff,
3725 int (*fn)(__isl_take isl_set *set,
3726 __isl_take isl_aff *aff,
3727 void *user), void *user);
3729 int isl_aff_is_cst(__isl_keep isl_aff *aff);
3730 int isl_pw_aff_is_cst(__isl_keep isl_pw_aff *pwaff);
3732 int isl_aff_involves_dims(__isl_keep isl_aff *aff,
3733 enum isl_dim_type type, unsigned first, unsigned n);
3734 int isl_pw_aff_involves_dims(__isl_keep isl_pw_aff *pwaff,
3735 enum isl_dim_type type, unsigned first, unsigned n);
3737 isl_ctx *isl_pw_aff_get_ctx(__isl_keep isl_pw_aff *pwaff);
3738 unsigned isl_pw_aff_dim(__isl_keep isl_pw_aff *pwaff,
3739 enum isl_dim_type type);
3740 int isl_pw_aff_is_empty(__isl_keep isl_pw_aff *pwaff);
3742 It can be modified using
3744 #include <isl/aff.h>
3745 __isl_give isl_pw_aff *isl_pw_aff_set_tuple_id(
3746 __isl_take isl_pw_aff *pwaff,
3747 enum isl_dim_type type, __isl_take isl_id *id);
3748 __isl_give isl_aff *isl_aff_set_dim_name(
3749 __isl_take isl_aff *aff, enum isl_dim_type type,
3750 unsigned pos, const char *s);
3751 __isl_give isl_aff *isl_aff_set_dim_id(
3752 __isl_take isl_aff *aff, enum isl_dim_type type,
3753 unsigned pos, __isl_take isl_id *id);
3754 __isl_give isl_pw_aff *isl_pw_aff_set_dim_id(
3755 __isl_take isl_pw_aff *pma,
3756 enum isl_dim_type type, unsigned pos,
3757 __isl_take isl_id *id);
3758 __isl_give isl_aff *isl_aff_set_constant_si(
3759 __isl_take isl_aff *aff, int v);
3760 __isl_give isl_aff *isl_aff_set_constant_val(
3761 __isl_take isl_aff *aff, __isl_take isl_val *v);
3762 __isl_give isl_aff *isl_aff_set_coefficient_si(
3763 __isl_take isl_aff *aff,
3764 enum isl_dim_type type, int pos, int v);
3765 __isl_give isl_aff *isl_aff_set_coefficient_val(
3766 __isl_take isl_aff *aff,
3767 enum isl_dim_type type, int pos,
3768 __isl_take isl_val *v);
3770 __isl_give isl_aff *isl_aff_add_constant_si(
3771 __isl_take isl_aff *aff, int v);
3772 __isl_give isl_aff *isl_aff_add_constant_val(
3773 __isl_take isl_aff *aff, __isl_take isl_val *v);
3774 __isl_give isl_aff *isl_aff_add_constant_num_si(
3775 __isl_take isl_aff *aff, int v);
3776 __isl_give isl_aff *isl_aff_add_coefficient_si(
3777 __isl_take isl_aff *aff,
3778 enum isl_dim_type type, int pos, int v);
3779 __isl_give isl_aff *isl_aff_add_coefficient_val(
3780 __isl_take isl_aff *aff,
3781 enum isl_dim_type type, int pos,
3782 __isl_take isl_val *v);
3784 __isl_give isl_aff *isl_aff_insert_dims(
3785 __isl_take isl_aff *aff,
3786 enum isl_dim_type type, unsigned first, unsigned n);
3787 __isl_give isl_pw_aff *isl_pw_aff_insert_dims(
3788 __isl_take isl_pw_aff *pwaff,
3789 enum isl_dim_type type, unsigned first, unsigned n);
3790 __isl_give isl_aff *isl_aff_add_dims(
3791 __isl_take isl_aff *aff,
3792 enum isl_dim_type type, unsigned n);
3793 __isl_give isl_pw_aff *isl_pw_aff_add_dims(
3794 __isl_take isl_pw_aff *pwaff,
3795 enum isl_dim_type type, unsigned n);
3796 __isl_give isl_aff *isl_aff_drop_dims(
3797 __isl_take isl_aff *aff,
3798 enum isl_dim_type type, unsigned first, unsigned n);
3799 __isl_give isl_pw_aff *isl_pw_aff_drop_dims(
3800 __isl_take isl_pw_aff *pwaff,
3801 enum isl_dim_type type, unsigned first, unsigned n);
3802 __isl_give isl_aff *isl_aff_move_dims(
3803 __isl_take isl_aff *aff,
3804 enum isl_dim_type dst_type, unsigned dst_pos,
3805 enum isl_dim_type src_type, unsigned src_pos,
3807 __isl_give isl_pw_aff *isl_pw_aff_move_dims(
3808 __isl_take isl_pw_aff *pa,
3809 enum isl_dim_type dst_type, unsigned dst_pos,
3810 enum isl_dim_type src_type, unsigned src_pos,
3813 Note that C<isl_aff_set_constant_si> and C<isl_aff_set_coefficient_si>
3814 set the I<numerator> of the constant or coefficient, while
3815 C<isl_aff_set_constant_val> and C<isl_aff_set_coefficient_val> set
3816 the constant or coefficient as a whole.
3817 The C<add_constant> and C<add_coefficient> functions add an integer
3818 or rational value to
3819 the possibly rational constant or coefficient.
3820 The C<add_constant_num> functions add an integer value to
3823 To check whether an affine expressions is obviously zero
3824 or (obviously) equal to some other affine expression, use
3826 #include <isl/aff.h>
3827 int isl_aff_plain_is_zero(__isl_keep isl_aff *aff);
3828 int isl_aff_plain_is_equal(__isl_keep isl_aff *aff1,
3829 __isl_keep isl_aff *aff2);
3830 int isl_pw_aff_plain_is_equal(
3831 __isl_keep isl_pw_aff *pwaff1,
3832 __isl_keep isl_pw_aff *pwaff2);
3833 int isl_pw_aff_is_equal(__isl_keep isl_pw_aff *pa1,
3834 __isl_keep isl_pw_aff *pa2);
3838 #include <isl/aff.h>
3839 __isl_give isl_aff *isl_aff_add(__isl_take isl_aff *aff1,
3840 __isl_take isl_aff *aff2);
3841 __isl_give isl_pw_aff *isl_pw_aff_add(
3842 __isl_take isl_pw_aff *pwaff1,
3843 __isl_take isl_pw_aff *pwaff2);
3844 __isl_give isl_pw_aff *isl_pw_aff_min(
3845 __isl_take isl_pw_aff *pwaff1,
3846 __isl_take isl_pw_aff *pwaff2);
3847 __isl_give isl_pw_aff *isl_pw_aff_max(
3848 __isl_take isl_pw_aff *pwaff1,
3849 __isl_take isl_pw_aff *pwaff2);
3850 __isl_give isl_aff *isl_aff_sub(__isl_take isl_aff *aff1,
3851 __isl_take isl_aff *aff2);
3852 __isl_give isl_pw_aff *isl_pw_aff_sub(
3853 __isl_take isl_pw_aff *pwaff1,
3854 __isl_take isl_pw_aff *pwaff2);
3855 __isl_give isl_aff *isl_aff_neg(__isl_take isl_aff *aff);
3856 __isl_give isl_pw_aff *isl_pw_aff_neg(
3857 __isl_take isl_pw_aff *pwaff);
3858 __isl_give isl_aff *isl_aff_ceil(__isl_take isl_aff *aff);
3859 __isl_give isl_pw_aff *isl_pw_aff_ceil(
3860 __isl_take isl_pw_aff *pwaff);
3861 __isl_give isl_aff *isl_aff_floor(__isl_take isl_aff *aff);
3862 __isl_give isl_pw_aff *isl_pw_aff_floor(
3863 __isl_take isl_pw_aff *pwaff);
3864 __isl_give isl_aff *isl_aff_mod_val(__isl_take isl_aff *aff,
3865 __isl_take isl_val *mod);
3866 __isl_give isl_pw_aff *isl_pw_aff_mod_val(
3867 __isl_take isl_pw_aff *pa,
3868 __isl_take isl_val *mod);
3869 __isl_give isl_aff *isl_aff_scale_val(__isl_take isl_aff *aff,
3870 __isl_take isl_val *v);
3871 __isl_give isl_pw_aff *isl_pw_aff_scale_val(
3872 __isl_take isl_pw_aff *pa, __isl_take isl_val *v);
3873 __isl_give isl_aff *isl_aff_scale_down_ui(
3874 __isl_take isl_aff *aff, unsigned f);
3875 __isl_give isl_aff *isl_aff_scale_down_val(
3876 __isl_take isl_aff *aff, __isl_take isl_val *v);
3877 __isl_give isl_pw_aff *isl_pw_aff_scale_down_val(
3878 __isl_take isl_pw_aff *pa,
3879 __isl_take isl_val *f);
3881 __isl_give isl_pw_aff *isl_pw_aff_list_min(
3882 __isl_take isl_pw_aff_list *list);
3883 __isl_give isl_pw_aff *isl_pw_aff_list_max(
3884 __isl_take isl_pw_aff_list *list);
3886 __isl_give isl_pw_aff *isl_pw_aff_coalesce(
3887 __isl_take isl_pw_aff *pwqp);
3889 __isl_give isl_aff *isl_aff_align_params(
3890 __isl_take isl_aff *aff,
3891 __isl_take isl_space *model);
3892 __isl_give isl_pw_aff *isl_pw_aff_align_params(
3893 __isl_take isl_pw_aff *pwaff,
3894 __isl_take isl_space *model);
3896 __isl_give isl_aff *isl_aff_project_domain_on_params(
3897 __isl_take isl_aff *aff);
3898 __isl_give isl_pw_aff *isl_pw_aff_from_range(
3899 __isl_take isl_pw_aff *pwa);
3901 __isl_give isl_aff *isl_aff_gist_params(
3902 __isl_take isl_aff *aff,
3903 __isl_take isl_set *context);
3904 __isl_give isl_aff *isl_aff_gist(__isl_take isl_aff *aff,
3905 __isl_take isl_set *context);
3906 __isl_give isl_pw_aff *isl_pw_aff_gist_params(
3907 __isl_take isl_pw_aff *pwaff,
3908 __isl_take isl_set *context);
3909 __isl_give isl_pw_aff *isl_pw_aff_gist(
3910 __isl_take isl_pw_aff *pwaff,
3911 __isl_take isl_set *context);
3913 __isl_give isl_set *isl_pw_aff_domain(
3914 __isl_take isl_pw_aff *pwaff);
3915 __isl_give isl_set *isl_pw_aff_params(
3916 __isl_take isl_pw_aff *pwa);
3917 __isl_give isl_pw_aff *isl_pw_aff_intersect_domain(
3918 __isl_take isl_pw_aff *pa,
3919 __isl_take isl_set *set);
3920 __isl_give isl_pw_aff *isl_pw_aff_intersect_params(
3921 __isl_take isl_pw_aff *pa,
3922 __isl_take isl_set *set);
3924 __isl_give isl_aff *isl_aff_mul(__isl_take isl_aff *aff1,
3925 __isl_take isl_aff *aff2);
3926 __isl_give isl_aff *isl_aff_div(__isl_take isl_aff *aff1,
3927 __isl_take isl_aff *aff2);
3928 __isl_give isl_pw_aff *isl_pw_aff_mul(
3929 __isl_take isl_pw_aff *pwaff1,
3930 __isl_take isl_pw_aff *pwaff2);
3931 __isl_give isl_pw_aff *isl_pw_aff_div(
3932 __isl_take isl_pw_aff *pa1,
3933 __isl_take isl_pw_aff *pa2);
3934 __isl_give isl_pw_aff *isl_pw_aff_tdiv_q(
3935 __isl_take isl_pw_aff *pa1,
3936 __isl_take isl_pw_aff *pa2);
3937 __isl_give isl_pw_aff *isl_pw_aff_tdiv_r(
3938 __isl_take isl_pw_aff *pa1,
3939 __isl_take isl_pw_aff *pa2);
3941 When multiplying two affine expressions, at least one of the two needs
3942 to be a constant. Similarly, when dividing an affine expression by another,
3943 the second expression needs to be a constant.
3944 C<isl_pw_aff_tdiv_q> computes the quotient of an integer division with
3945 rounding towards zero. C<isl_pw_aff_tdiv_r> computes the corresponding
3948 #include <isl/aff.h>
3949 __isl_give isl_aff *isl_aff_pullback_aff(
3950 __isl_take isl_aff *aff1,
3951 __isl_take isl_aff *aff2);
3952 __isl_give isl_aff *isl_aff_pullback_multi_aff(
3953 __isl_take isl_aff *aff,
3954 __isl_take isl_multi_aff *ma);
3955 __isl_give isl_pw_aff *isl_pw_aff_pullback_multi_aff(
3956 __isl_take isl_pw_aff *pa,
3957 __isl_take isl_multi_aff *ma);
3958 __isl_give isl_pw_aff *isl_pw_aff_pullback_pw_multi_aff(
3959 __isl_take isl_pw_aff *pa,
3960 __isl_take isl_pw_multi_aff *pma);
3962 These functions precompose the input expression by the given
3963 C<isl_aff>, C<isl_multi_aff> or C<isl_pw_multi_aff>. In other words,
3964 the C<isl_aff>, C<isl_multi_aff> or C<isl_pw_multi_aff> is plugged
3965 into the (piecewise) affine expression.
3966 Objects of type C<isl_multi_aff> are described in
3967 L</"Piecewise Multiple Quasi Affine Expressions">.
3969 #include <isl/aff.h>
3970 __isl_give isl_basic_set *isl_aff_zero_basic_set(
3971 __isl_take isl_aff *aff);
3972 __isl_give isl_basic_set *isl_aff_neg_basic_set(
3973 __isl_take isl_aff *aff);
3974 __isl_give isl_basic_set *isl_aff_le_basic_set(
3975 __isl_take isl_aff *aff1, __isl_take isl_aff *aff2);
3976 __isl_give isl_basic_set *isl_aff_ge_basic_set(
3977 __isl_take isl_aff *aff1, __isl_take isl_aff *aff2);
3978 __isl_give isl_set *isl_pw_aff_eq_set(
3979 __isl_take isl_pw_aff *pwaff1,
3980 __isl_take isl_pw_aff *pwaff2);
3981 __isl_give isl_set *isl_pw_aff_ne_set(
3982 __isl_take isl_pw_aff *pwaff1,
3983 __isl_take isl_pw_aff *pwaff2);
3984 __isl_give isl_set *isl_pw_aff_le_set(
3985 __isl_take isl_pw_aff *pwaff1,
3986 __isl_take isl_pw_aff *pwaff2);
3987 __isl_give isl_set *isl_pw_aff_lt_set(
3988 __isl_take isl_pw_aff *pwaff1,
3989 __isl_take isl_pw_aff *pwaff2);
3990 __isl_give isl_set *isl_pw_aff_ge_set(
3991 __isl_take isl_pw_aff *pwaff1,
3992 __isl_take isl_pw_aff *pwaff2);
3993 __isl_give isl_set *isl_pw_aff_gt_set(
3994 __isl_take isl_pw_aff *pwaff1,
3995 __isl_take isl_pw_aff *pwaff2);
3997 __isl_give isl_set *isl_pw_aff_list_eq_set(
3998 __isl_take isl_pw_aff_list *list1,
3999 __isl_take isl_pw_aff_list *list2);
4000 __isl_give isl_set *isl_pw_aff_list_ne_set(
4001 __isl_take isl_pw_aff_list *list1,
4002 __isl_take isl_pw_aff_list *list2);
4003 __isl_give isl_set *isl_pw_aff_list_le_set(
4004 __isl_take isl_pw_aff_list *list1,
4005 __isl_take isl_pw_aff_list *list2);
4006 __isl_give isl_set *isl_pw_aff_list_lt_set(
4007 __isl_take isl_pw_aff_list *list1,
4008 __isl_take isl_pw_aff_list *list2);
4009 __isl_give isl_set *isl_pw_aff_list_ge_set(
4010 __isl_take isl_pw_aff_list *list1,
4011 __isl_take isl_pw_aff_list *list2);
4012 __isl_give isl_set *isl_pw_aff_list_gt_set(
4013 __isl_take isl_pw_aff_list *list1,
4014 __isl_take isl_pw_aff_list *list2);
4016 The function C<isl_aff_neg_basic_set> returns a basic set
4017 containing those elements in the domain space
4018 of C<aff> where C<aff> is negative.
4019 The function C<isl_aff_ge_basic_set> returns a basic set
4020 containing those elements in the shared space
4021 of C<aff1> and C<aff2> where C<aff1> is greater than or equal to C<aff2>.
4022 The function C<isl_pw_aff_ge_set> returns a set
4023 containing those elements in the shared domain
4024 of C<pwaff1> and C<pwaff2> where C<pwaff1> is greater than or equal to C<pwaff2>.
4025 The functions operating on C<isl_pw_aff_list> apply the corresponding
4026 C<isl_pw_aff> function to each pair of elements in the two lists.
4028 #include <isl/aff.h>
4029 __isl_give isl_set *isl_pw_aff_nonneg_set(
4030 __isl_take isl_pw_aff *pwaff);
4031 __isl_give isl_set *isl_pw_aff_zero_set(
4032 __isl_take isl_pw_aff *pwaff);
4033 __isl_give isl_set *isl_pw_aff_non_zero_set(
4034 __isl_take isl_pw_aff *pwaff);
4036 The function C<isl_pw_aff_nonneg_set> returns a set
4037 containing those elements in the domain
4038 of C<pwaff> where C<pwaff> is non-negative.
4040 #include <isl/aff.h>
4041 __isl_give isl_pw_aff *isl_pw_aff_cond(
4042 __isl_take isl_pw_aff *cond,
4043 __isl_take isl_pw_aff *pwaff_true,
4044 __isl_take isl_pw_aff *pwaff_false);
4046 The function C<isl_pw_aff_cond> performs a conditional operator
4047 and returns an expression that is equal to C<pwaff_true>
4048 for elements where C<cond> is non-zero and equal to C<pwaff_false> for elements
4049 where C<cond> is zero.
4051 #include <isl/aff.h>
4052 __isl_give isl_pw_aff *isl_pw_aff_union_min(
4053 __isl_take isl_pw_aff *pwaff1,
4054 __isl_take isl_pw_aff *pwaff2);
4055 __isl_give isl_pw_aff *isl_pw_aff_union_max(
4056 __isl_take isl_pw_aff *pwaff1,
4057 __isl_take isl_pw_aff *pwaff2);
4058 __isl_give isl_pw_aff *isl_pw_aff_union_add(
4059 __isl_take isl_pw_aff *pwaff1,
4060 __isl_take isl_pw_aff *pwaff2);
4062 The function C<isl_pw_aff_union_max> computes a piecewise quasi-affine
4063 expression with a domain that is the union of those of C<pwaff1> and
4064 C<pwaff2> and such that on each cell, the quasi-affine expression is
4065 the maximum of those of C<pwaff1> and C<pwaff2>. If only one of
4066 C<pwaff1> or C<pwaff2> is defined on a given cell, then the
4067 associated expression is the defined one.
4069 An expression can be read from input using
4071 #include <isl/aff.h>
4072 __isl_give isl_aff *isl_aff_read_from_str(
4073 isl_ctx *ctx, const char *str);
4074 __isl_give isl_pw_aff *isl_pw_aff_read_from_str(
4075 isl_ctx *ctx, const char *str);
4077 An expression can be printed using
4079 #include <isl/aff.h>
4080 __isl_give isl_printer *isl_printer_print_aff(
4081 __isl_take isl_printer *p, __isl_keep isl_aff *aff);
4083 __isl_give isl_printer *isl_printer_print_pw_aff(
4084 __isl_take isl_printer *p,
4085 __isl_keep isl_pw_aff *pwaff);
4087 =head2 Piecewise Multiple Quasi Affine Expressions
4089 An C<isl_multi_aff> object represents a sequence of
4090 zero or more affine expressions, all defined on the same domain space.
4091 Similarly, an C<isl_multi_pw_aff> object represents a sequence of
4092 zero or more piecewise affine expressions.
4094 An C<isl_multi_aff> can be constructed from a single
4095 C<isl_aff> or an C<isl_aff_list> using the
4096 following functions. Similarly for C<isl_multi_pw_aff>
4097 and C<isl_pw_multi_aff>.
4099 #include <isl/aff.h>
4100 __isl_give isl_multi_aff *isl_multi_aff_from_aff(
4101 __isl_take isl_aff *aff);
4102 __isl_give isl_multi_pw_aff *
4103 isl_multi_pw_aff_from_multi_aff(
4104 __isl_take isl_multi_aff *ma);
4105 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_pw_aff(
4106 __isl_take isl_pw_aff *pa);
4107 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_pw_aff(
4108 __isl_take isl_pw_aff *pa);
4109 __isl_give isl_multi_aff *isl_multi_aff_from_aff_list(
4110 __isl_take isl_space *space,
4111 __isl_take isl_aff_list *list);
4113 An C<isl_multi_pw_aff> can be converted to an C<isl_pw_multi_aff>
4114 using the function C<isl_pw_multi_aff_from_multi_pw_aff> below.
4115 Note however that the domain
4116 of the result is the intersection of the domains of the input.
4117 The reverse conversion is exact.
4119 #include <isl/aff.h>
4120 __isl_give isl_pw_multi_aff *
4121 isl_pw_multi_aff_from_multi_pw_aff(
4122 __isl_take isl_multi_pw_aff *mpa);
4123 __isl_give isl_multi_pw_aff *
4124 isl_multi_pw_aff_from_pw_multi_aff(
4125 __isl_take isl_pw_multi_aff *pma);
4127 An empty piecewise multiple quasi affine expression (one with no cells),
4128 the zero piecewise multiple quasi affine expression (with value zero
4129 for each output dimension),
4130 a piecewise multiple quasi affine expression with a single cell (with
4131 either a universe or a specified domain) or
4132 a zero-dimensional piecewise multiple quasi affine expression
4134 can be created using the following functions.
4136 #include <isl/aff.h>
4137 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_empty(
4138 __isl_take isl_space *space);
4139 __isl_give isl_multi_aff *isl_multi_aff_zero(
4140 __isl_take isl_space *space);
4141 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_zero(
4142 __isl_take isl_space *space);
4143 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_zero(
4144 __isl_take isl_space *space);
4145 __isl_give isl_multi_aff *isl_multi_aff_identity(
4146 __isl_take isl_space *space);
4147 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_identity(
4148 __isl_take isl_space *space);
4149 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_identity(
4150 __isl_take isl_space *space);
4151 __isl_give isl_multi_aff *isl_multi_aff_domain_map(
4152 __isl_take isl_space *space);
4153 __isl_give isl_multi_aff *isl_multi_aff_range_map(
4154 __isl_take isl_space *space);
4155 __isl_give isl_multi_aff *isl_multi_aff_project_out_map(
4156 __isl_take isl_space *space,
4157 enum isl_dim_type type,
4158 unsigned first, unsigned n);
4159 __isl_give isl_pw_multi_aff *
4160 isl_pw_multi_aff_project_out_map(
4161 __isl_take isl_space *space,
4162 enum isl_dim_type type,
4163 unsigned first, unsigned n);
4164 __isl_give isl_pw_multi_aff *
4165 isl_pw_multi_aff_from_multi_aff(
4166 __isl_take isl_multi_aff *ma);
4167 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_alloc(
4168 __isl_take isl_set *set,
4169 __isl_take isl_multi_aff *maff);
4170 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_domain(
4171 __isl_take isl_set *set);
4173 __isl_give isl_union_pw_multi_aff *
4174 isl_union_pw_multi_aff_empty(
4175 __isl_take isl_space *space);
4176 __isl_give isl_union_pw_multi_aff *
4177 isl_union_pw_multi_aff_add_pw_multi_aff(
4178 __isl_take isl_union_pw_multi_aff *upma,
4179 __isl_take isl_pw_multi_aff *pma);
4180 __isl_give isl_union_pw_multi_aff *
4181 isl_union_pw_multi_aff_from_domain(
4182 __isl_take isl_union_set *uset);
4184 A piecewise multiple quasi affine expression can also be initialized
4185 from an C<isl_set> or C<isl_map>, provided the C<isl_set> is a singleton
4186 and the C<isl_map> is single-valued.
4187 In case of a conversion from an C<isl_union_set> or an C<isl_union_map>
4188 to an C<isl_union_pw_multi_aff>, these properties need to hold in each space.
4190 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_set(
4191 __isl_take isl_set *set);
4192 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_map(
4193 __isl_take isl_map *map);
4195 __isl_give isl_union_pw_multi_aff *
4196 isl_union_pw_multi_aff_from_union_set(
4197 __isl_take isl_union_set *uset);
4198 __isl_give isl_union_pw_multi_aff *
4199 isl_union_pw_multi_aff_from_union_map(
4200 __isl_take isl_union_map *umap);
4202 Multiple quasi affine expressions can be copied and freed using
4204 #include <isl/aff.h>
4205 __isl_give isl_multi_aff *isl_multi_aff_copy(
4206 __isl_keep isl_multi_aff *maff);
4207 void *isl_multi_aff_free(__isl_take isl_multi_aff *maff);
4209 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_copy(
4210 __isl_keep isl_pw_multi_aff *pma);
4211 void *isl_pw_multi_aff_free(
4212 __isl_take isl_pw_multi_aff *pma);
4214 __isl_give isl_union_pw_multi_aff *
4215 isl_union_pw_multi_aff_copy(
4216 __isl_keep isl_union_pw_multi_aff *upma);
4217 void *isl_union_pw_multi_aff_free(
4218 __isl_take isl_union_pw_multi_aff *upma);
4220 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_copy(
4221 __isl_keep isl_multi_pw_aff *mpa);
4222 void *isl_multi_pw_aff_free(
4223 __isl_take isl_multi_pw_aff *mpa);
4225 The expression can be inspected using
4227 #include <isl/aff.h>
4228 isl_ctx *isl_multi_aff_get_ctx(
4229 __isl_keep isl_multi_aff *maff);
4230 isl_ctx *isl_pw_multi_aff_get_ctx(
4231 __isl_keep isl_pw_multi_aff *pma);
4232 isl_ctx *isl_union_pw_multi_aff_get_ctx(
4233 __isl_keep isl_union_pw_multi_aff *upma);
4234 isl_ctx *isl_multi_pw_aff_get_ctx(
4235 __isl_keep isl_multi_pw_aff *mpa);
4236 unsigned isl_multi_aff_dim(__isl_keep isl_multi_aff *maff,
4237 enum isl_dim_type type);
4238 unsigned isl_pw_multi_aff_dim(
4239 __isl_keep isl_pw_multi_aff *pma,
4240 enum isl_dim_type type);
4241 unsigned isl_multi_pw_aff_dim(
4242 __isl_keep isl_multi_pw_aff *mpa,
4243 enum isl_dim_type type);
4244 __isl_give isl_aff *isl_multi_aff_get_aff(
4245 __isl_keep isl_multi_aff *multi, int pos);
4246 __isl_give isl_pw_aff *isl_pw_multi_aff_get_pw_aff(
4247 __isl_keep isl_pw_multi_aff *pma, int pos);
4248 __isl_give isl_pw_aff *isl_multi_pw_aff_get_pw_aff(
4249 __isl_keep isl_multi_pw_aff *mpa, int pos);
4250 int isl_multi_aff_find_dim_by_id(
4251 __isl_keep isl_multi_aff *ma,
4252 enum isl_dim_type type, __isl_keep isl_id *id);
4253 int isl_multi_pw_aff_find_dim_by_id(
4254 __isl_keep isl_multi_pw_aff *mpa,
4255 enum isl_dim_type type, __isl_keep isl_id *id);
4256 const char *isl_pw_multi_aff_get_dim_name(
4257 __isl_keep isl_pw_multi_aff *pma,
4258 enum isl_dim_type type, unsigned pos);
4259 __isl_give isl_id *isl_multi_aff_get_dim_id(
4260 __isl_keep isl_multi_aff *ma,
4261 enum isl_dim_type type, unsigned pos);
4262 __isl_give isl_id *isl_pw_multi_aff_get_dim_id(
4263 __isl_keep isl_pw_multi_aff *pma,
4264 enum isl_dim_type type, unsigned pos);
4265 __isl_give isl_id *isl_multi_pw_aff_get_dim_id(
4266 __isl_keep isl_multi_pw_aff *mpa,
4267 enum isl_dim_type type, unsigned pos);
4268 const char *isl_multi_aff_get_tuple_name(
4269 __isl_keep isl_multi_aff *multi,
4270 enum isl_dim_type type);
4271 int isl_pw_multi_aff_has_tuple_name(
4272 __isl_keep isl_pw_multi_aff *pma,
4273 enum isl_dim_type type);
4274 const char *isl_pw_multi_aff_get_tuple_name(
4275 __isl_keep isl_pw_multi_aff *pma,
4276 enum isl_dim_type type);
4277 int isl_multi_aff_has_tuple_id(__isl_keep isl_multi_aff *ma,
4278 enum isl_dim_type type);
4279 int isl_pw_multi_aff_has_tuple_id(
4280 __isl_keep isl_pw_multi_aff *pma,
4281 enum isl_dim_type type);
4282 int isl_multi_pw_aff_has_tuple_id(
4283 __isl_keep isl_multi_pw_aff *mpa,
4284 enum isl_dim_type type);
4285 __isl_give isl_id *isl_multi_aff_get_tuple_id(
4286 __isl_keep isl_multi_aff *ma,
4287 enum isl_dim_type type);
4288 __isl_give isl_id *isl_pw_multi_aff_get_tuple_id(
4289 __isl_keep isl_pw_multi_aff *pma,
4290 enum isl_dim_type type);
4291 __isl_give isl_id *isl_multi_pw_aff_get_tuple_id(
4292 __isl_keep isl_multi_pw_aff *mpa,
4293 enum isl_dim_type type);
4294 int isl_multi_aff_range_is_wrapping(
4295 __isl_keep isl_multi_aff *ma);
4296 int isl_multi_pw_aff_range_is_wrapping(
4297 __isl_keep isl_multi_pw_aff *mpa);
4299 int isl_pw_multi_aff_foreach_piece(
4300 __isl_keep isl_pw_multi_aff *pma,
4301 int (*fn)(__isl_take isl_set *set,
4302 __isl_take isl_multi_aff *maff,
4303 void *user), void *user);
4305 int isl_union_pw_multi_aff_foreach_pw_multi_aff(
4306 __isl_keep isl_union_pw_multi_aff *upma,
4307 int (*fn)(__isl_take isl_pw_multi_aff *pma,
4308 void *user), void *user);
4310 It can be modified using
4312 #include <isl/aff.h>
4313 __isl_give isl_multi_aff *isl_multi_aff_set_aff(
4314 __isl_take isl_multi_aff *multi, int pos,
4315 __isl_take isl_aff *aff);
4316 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_pw_aff(
4317 __isl_take isl_pw_multi_aff *pma, unsigned pos,
4318 __isl_take isl_pw_aff *pa);
4319 __isl_give isl_multi_aff *isl_multi_aff_set_dim_name(
4320 __isl_take isl_multi_aff *maff,
4321 enum isl_dim_type type, unsigned pos, const char *s);
4322 __isl_give isl_multi_aff *isl_multi_aff_set_dim_id(
4323 __isl_take isl_multi_aff *maff,
4324 enum isl_dim_type type, unsigned pos,
4325 __isl_take isl_id *id);
4326 __isl_give isl_multi_aff *isl_multi_aff_set_tuple_name(
4327 __isl_take isl_multi_aff *maff,
4328 enum isl_dim_type type, const char *s);
4329 __isl_give isl_multi_aff *isl_multi_aff_set_tuple_id(
4330 __isl_take isl_multi_aff *maff,
4331 enum isl_dim_type type, __isl_take isl_id *id);
4332 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_tuple_id(
4333 __isl_take isl_pw_multi_aff *pma,
4334 enum isl_dim_type type, __isl_take isl_id *id);
4335 __isl_give isl_multi_aff *isl_multi_aff_reset_tuple_id(
4336 __isl_take isl_multi_aff *ma,
4337 enum isl_dim_type type);
4338 __isl_give isl_multi_pw_aff *
4339 isl_multi_pw_aff_reset_tuple_id(
4340 __isl_take isl_multi_pw_aff *mpa,
4341 enum isl_dim_type type);
4342 __isl_give isl_multi_aff *isl_multi_aff_reset_user(
4343 __isl_take isl_multi_aff *ma);
4344 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_reset_user(
4345 __isl_take isl_multi_pw_aff *mpa);
4347 __isl_give isl_multi_pw_aff *
4348 isl_multi_pw_aff_set_dim_name(
4349 __isl_take isl_multi_pw_aff *mpa,
4350 enum isl_dim_type type, unsigned pos, const char *s);
4351 __isl_give isl_multi_pw_aff *
4352 isl_multi_pw_aff_set_dim_id(
4353 __isl_take isl_multi_pw_aff *mpa,
4354 enum isl_dim_type type, unsigned pos,
4355 __isl_take isl_id *id);
4356 __isl_give isl_multi_pw_aff *
4357 isl_multi_pw_aff_set_tuple_name(
4358 __isl_take isl_multi_pw_aff *mpa,
4359 enum isl_dim_type type, const char *s);
4361 __isl_give isl_multi_aff *isl_multi_aff_insert_dims(
4362 __isl_take isl_multi_aff *ma,
4363 enum isl_dim_type type, unsigned first, unsigned n);
4364 __isl_give isl_multi_aff *isl_multi_aff_add_dims(
4365 __isl_take isl_multi_aff *ma,
4366 enum isl_dim_type type, unsigned n);
4367 __isl_give isl_multi_aff *isl_multi_aff_drop_dims(
4368 __isl_take isl_multi_aff *maff,
4369 enum isl_dim_type type, unsigned first, unsigned n);
4370 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_drop_dims(
4371 __isl_take isl_pw_multi_aff *pma,
4372 enum isl_dim_type type, unsigned first, unsigned n);
4374 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_insert_dims(
4375 __isl_take isl_multi_pw_aff *mpa,
4376 enum isl_dim_type type, unsigned first, unsigned n);
4377 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_add_dims(
4378 __isl_take isl_multi_pw_aff *mpa,
4379 enum isl_dim_type type, unsigned n);
4380 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_move_dims(
4381 __isl_take isl_multi_pw_aff *pma,
4382 enum isl_dim_type dst_type, unsigned dst_pos,
4383 enum isl_dim_type src_type, unsigned src_pos,
4386 To check whether two multiple affine expressions are
4387 (obviously) equal to each other, use
4389 int isl_multi_aff_plain_is_equal(__isl_keep isl_multi_aff *maff1,
4390 __isl_keep isl_multi_aff *maff2);
4391 int isl_pw_multi_aff_plain_is_equal(
4392 __isl_keep isl_pw_multi_aff *pma1,
4393 __isl_keep isl_pw_multi_aff *pma2);
4394 int isl_multi_pw_aff_plain_is_equal(
4395 __isl_keep isl_multi_pw_aff *mpa1,
4396 __isl_keep isl_multi_pw_aff *mpa2);
4397 int isl_multi_pw_aff_is_equal(
4398 __isl_keep isl_multi_pw_aff *mpa1,
4399 __isl_keep isl_multi_pw_aff *mpa2);
4403 #include <isl/aff.h>
4404 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmin(
4405 __isl_take isl_pw_multi_aff *pma1,
4406 __isl_take isl_pw_multi_aff *pma2);
4407 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmax(
4408 __isl_take isl_pw_multi_aff *pma1,
4409 __isl_take isl_pw_multi_aff *pma2);
4410 __isl_give isl_multi_aff *isl_multi_aff_add(
4411 __isl_take isl_multi_aff *maff1,
4412 __isl_take isl_multi_aff *maff2);
4413 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_add(
4414 __isl_take isl_pw_multi_aff *pma1,
4415 __isl_take isl_pw_multi_aff *pma2);
4416 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_add(
4417 __isl_take isl_union_pw_multi_aff *upma1,
4418 __isl_take isl_union_pw_multi_aff *upma2);
4419 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_add(
4420 __isl_take isl_pw_multi_aff *pma1,
4421 __isl_take isl_pw_multi_aff *pma2);
4422 __isl_give isl_multi_aff *isl_multi_aff_sub(
4423 __isl_take isl_multi_aff *ma1,
4424 __isl_take isl_multi_aff *ma2);
4425 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_sub(
4426 __isl_take isl_pw_multi_aff *pma1,
4427 __isl_take isl_pw_multi_aff *pma2);
4428 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_sub(
4429 __isl_take isl_union_pw_multi_aff *upma1,
4430 __isl_take isl_union_pw_multi_aff *upma2);
4432 C<isl_multi_aff_sub> subtracts the second argument from the first.
4434 __isl_give isl_multi_aff *isl_multi_aff_scale_val(
4435 __isl_take isl_multi_aff *ma,
4436 __isl_take isl_val *v);
4437 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_val(
4438 __isl_take isl_pw_multi_aff *pma,
4439 __isl_take isl_val *v);
4440 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_scale_val(
4441 __isl_take isl_multi_pw_aff *mpa,
4442 __isl_take isl_val *v);
4443 __isl_give isl_multi_aff *isl_multi_aff_scale_multi_val(
4444 __isl_take isl_multi_aff *ma,
4445 __isl_take isl_multi_val *mv);
4446 __isl_give isl_pw_multi_aff *
4447 isl_pw_multi_aff_scale_multi_val(
4448 __isl_take isl_pw_multi_aff *pma,
4449 __isl_take isl_multi_val *mv);
4450 __isl_give isl_multi_pw_aff *
4451 isl_multi_pw_aff_scale_multi_val(
4452 __isl_take isl_multi_pw_aff *mpa,
4453 __isl_take isl_multi_val *mv);
4454 __isl_give isl_union_pw_multi_aff *
4455 isl_union_pw_multi_aff_scale_multi_val(
4456 __isl_take isl_union_pw_multi_aff *upma,
4457 __isl_take isl_multi_val *mv);
4458 __isl_give isl_multi_aff *
4459 isl_multi_aff_scale_down_multi_val(
4460 __isl_take isl_multi_aff *ma,
4461 __isl_take isl_multi_val *mv);
4462 __isl_give isl_multi_pw_aff *
4463 isl_multi_pw_aff_scale_down_multi_val(
4464 __isl_take isl_multi_pw_aff *mpa,
4465 __isl_take isl_multi_val *mv);
4467 C<isl_multi_aff_scale_multi_val> scales the elements of C<ma>
4468 by the corresponding elements of C<mv>.
4470 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_fix_si(
4471 __isl_take isl_pw_multi_aff *pma,
4472 enum isl_dim_type type, unsigned pos, int value);
4473 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_params(
4474 __isl_take isl_pw_multi_aff *pma,
4475 __isl_take isl_set *set);
4476 __isl_give isl_set *isl_multi_pw_aff_domain(
4477 __isl_take isl_multi_pw_aff *mpa);
4478 __isl_give isl_multi_pw_aff *
4479 isl_multi_pw_aff_intersect_params(
4480 __isl_take isl_multi_pw_aff *mpa,
4481 __isl_take isl_set *set);
4482 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_domain(
4483 __isl_take isl_pw_multi_aff *pma,
4484 __isl_take isl_set *set);
4485 __isl_give isl_multi_pw_aff *
4486 isl_multi_pw_aff_intersect_domain(
4487 __isl_take isl_multi_pw_aff *mpa,
4488 __isl_take isl_set *domain);
4489 __isl_give isl_union_pw_multi_aff *
4490 isl_union_pw_multi_aff_intersect_domain(
4491 __isl_take isl_union_pw_multi_aff *upma,
4492 __isl_take isl_union_set *uset);
4493 __isl_give isl_multi_aff *isl_multi_aff_lift(
4494 __isl_take isl_multi_aff *maff,
4495 __isl_give isl_local_space **ls);
4496 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_coalesce(
4497 __isl_take isl_pw_multi_aff *pma);
4498 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_coalesce(
4499 __isl_take isl_multi_pw_aff *mpa);
4500 __isl_give isl_multi_aff *isl_multi_aff_align_params(
4501 __isl_take isl_multi_aff *multi,
4502 __isl_take isl_space *model);
4503 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_align_params(
4504 __isl_take isl_pw_multi_aff *pma,
4505 __isl_take isl_space *model);
4506 __isl_give isl_pw_multi_aff *
4507 isl_pw_multi_aff_project_domain_on_params(
4508 __isl_take isl_pw_multi_aff *pma);
4509 __isl_give isl_multi_aff *isl_multi_aff_gist_params(
4510 __isl_take isl_multi_aff *maff,
4511 __isl_take isl_set *context);
4512 __isl_give isl_multi_aff *isl_multi_aff_gist(
4513 __isl_take isl_multi_aff *maff,
4514 __isl_take isl_set *context);
4515 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist_params(
4516 __isl_take isl_pw_multi_aff *pma,
4517 __isl_take isl_set *set);
4518 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist(
4519 __isl_take isl_pw_multi_aff *pma,
4520 __isl_take isl_set *set);
4521 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_gist_params(
4522 __isl_take isl_multi_pw_aff *mpa,
4523 __isl_take isl_set *set);
4524 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_gist(
4525 __isl_take isl_multi_pw_aff *mpa,
4526 __isl_take isl_set *set);
4527 __isl_give isl_multi_aff *isl_multi_aff_from_range(
4528 __isl_take isl_multi_aff *ma);
4529 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_range(
4530 __isl_take isl_multi_pw_aff *mpa);
4531 __isl_give isl_set *isl_pw_multi_aff_domain(
4532 __isl_take isl_pw_multi_aff *pma);
4533 __isl_give isl_union_set *isl_union_pw_multi_aff_domain(
4534 __isl_take isl_union_pw_multi_aff *upma);
4535 __isl_give isl_multi_aff *isl_multi_aff_range_splice(
4536 __isl_take isl_multi_aff *ma1, unsigned pos,
4537 __isl_take isl_multi_aff *ma2);
4538 __isl_give isl_multi_aff *isl_multi_aff_splice(
4539 __isl_take isl_multi_aff *ma1,
4540 unsigned in_pos, unsigned out_pos,
4541 __isl_take isl_multi_aff *ma2);
4542 __isl_give isl_multi_aff *isl_multi_aff_range_product(
4543 __isl_take isl_multi_aff *ma1,
4544 __isl_take isl_multi_aff *ma2);
4545 __isl_give isl_multi_aff *
4546 isl_multi_aff_range_factor_domain(
4547 __isl_take isl_multi_aff *ma);
4548 __isl_give isl_multi_aff *
4549 isl_multi_aff_range_factor_range(
4550 __isl_take isl_multi_aff *ma);
4551 __isl_give isl_multi_aff *isl_multi_aff_flat_range_product(
4552 __isl_take isl_multi_aff *ma1,
4553 __isl_take isl_multi_aff *ma2);
4554 __isl_give isl_multi_aff *isl_multi_aff_product(
4555 __isl_take isl_multi_aff *ma1,
4556 __isl_take isl_multi_aff *ma2);
4557 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_product(
4558 __isl_take isl_multi_pw_aff *mpa1,
4559 __isl_take isl_multi_pw_aff *mpa2);
4560 __isl_give isl_pw_multi_aff *
4561 isl_pw_multi_aff_range_product(
4562 __isl_take isl_pw_multi_aff *pma1,
4563 __isl_take isl_pw_multi_aff *pma2);
4564 __isl_give isl_multi_pw_aff *
4565 isl_multi_pw_aff_range_factor_domain(
4566 __isl_take isl_multi_pw_aff *mpa);
4567 __isl_give isl_multi_pw_aff *
4568 isl_multi_pw_aff_range_factor_range(
4569 __isl_take isl_multi_pw_aff *mpa);
4570 __isl_give isl_pw_multi_aff *
4571 isl_pw_multi_aff_flat_range_product(
4572 __isl_take isl_pw_multi_aff *pma1,
4573 __isl_take isl_pw_multi_aff *pma2);
4574 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_product(
4575 __isl_take isl_pw_multi_aff *pma1,
4576 __isl_take isl_pw_multi_aff *pma2);
4577 __isl_give isl_union_pw_multi_aff *
4578 isl_union_pw_multi_aff_flat_range_product(
4579 __isl_take isl_union_pw_multi_aff *upma1,
4580 __isl_take isl_union_pw_multi_aff *upma2);
4581 __isl_give isl_multi_pw_aff *
4582 isl_multi_pw_aff_range_splice(
4583 __isl_take isl_multi_pw_aff *mpa1, unsigned pos,
4584 __isl_take isl_multi_pw_aff *mpa2);
4585 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_splice(
4586 __isl_take isl_multi_pw_aff *mpa1,
4587 unsigned in_pos, unsigned out_pos,
4588 __isl_take isl_multi_pw_aff *mpa2);
4589 __isl_give isl_multi_pw_aff *
4590 isl_multi_pw_aff_range_product(
4591 __isl_take isl_multi_pw_aff *mpa1,
4592 __isl_take isl_multi_pw_aff *mpa2);
4593 __isl_give isl_multi_pw_aff *
4594 isl_multi_pw_aff_flat_range_product(
4595 __isl_take isl_multi_pw_aff *mpa1,
4596 __isl_take isl_multi_pw_aff *mpa2);
4598 If the C<ls> argument of C<isl_multi_aff_lift> is not C<NULL>,
4599 then it is assigned the local space that lies at the basis of
4600 the lifting applied.
4602 #include <isl/aff.h>
4603 __isl_give isl_multi_aff *isl_multi_aff_pullback_multi_aff(
4604 __isl_take isl_multi_aff *ma1,
4605 __isl_take isl_multi_aff *ma2);
4606 __isl_give isl_pw_multi_aff *
4607 isl_pw_multi_aff_pullback_multi_aff(
4608 __isl_take isl_pw_multi_aff *pma,
4609 __isl_take isl_multi_aff *ma);
4610 __isl_give isl_multi_pw_aff *
4611 isl_multi_pw_aff_pullback_multi_aff(
4612 __isl_take isl_multi_pw_aff *mpa,
4613 __isl_take isl_multi_aff *ma);
4614 __isl_give isl_pw_multi_aff *
4615 isl_pw_multi_aff_pullback_pw_multi_aff(
4616 __isl_take isl_pw_multi_aff *pma1,
4617 __isl_take isl_pw_multi_aff *pma2);
4618 __isl_give isl_multi_pw_aff *
4619 isl_multi_pw_aff_pullback_pw_multi_aff(
4620 __isl_take isl_multi_pw_aff *mpa,
4621 __isl_take isl_pw_multi_aff *pma);
4622 __isl_give isl_multi_pw_aff *
4623 isl_multi_pw_aff_pullback_multi_pw_aff(
4624 __isl_take isl_multi_pw_aff *mpa1,
4625 __isl_take isl_multi_pw_aff *mpa2);
4627 The function C<isl_multi_aff_pullback_multi_aff> precomposes C<ma1> by C<ma2>.
4628 In other words, C<ma2> is plugged
4631 __isl_give isl_set *isl_multi_aff_lex_le_set(
4632 __isl_take isl_multi_aff *ma1,
4633 __isl_take isl_multi_aff *ma2);
4634 __isl_give isl_set *isl_multi_aff_lex_ge_set(
4635 __isl_take isl_multi_aff *ma1,
4636 __isl_take isl_multi_aff *ma2);
4638 The function C<isl_multi_aff_lex_le_set> returns a set
4639 containing those elements in the shared domain space
4640 where C<ma1> is lexicographically smaller than or
4643 An expression can be read from input using
4645 #include <isl/aff.h>
4646 __isl_give isl_multi_aff *isl_multi_aff_read_from_str(
4647 isl_ctx *ctx, const char *str);
4648 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_read_from_str(
4649 isl_ctx *ctx, const char *str);
4650 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_read_from_str(
4651 isl_ctx *ctx, const char *str);
4652 __isl_give isl_union_pw_multi_aff *
4653 isl_union_pw_multi_aff_read_from_str(
4654 isl_ctx *ctx, const char *str);
4656 An expression can be printed using
4658 #include <isl/aff.h>
4659 __isl_give isl_printer *isl_printer_print_multi_aff(
4660 __isl_take isl_printer *p,
4661 __isl_keep isl_multi_aff *maff);
4662 __isl_give isl_printer *isl_printer_print_pw_multi_aff(
4663 __isl_take isl_printer *p,
4664 __isl_keep isl_pw_multi_aff *pma);
4665 __isl_give isl_printer *isl_printer_print_union_pw_multi_aff(
4666 __isl_take isl_printer *p,
4667 __isl_keep isl_union_pw_multi_aff *upma);
4668 __isl_give isl_printer *isl_printer_print_multi_pw_aff(
4669 __isl_take isl_printer *p,
4670 __isl_keep isl_multi_pw_aff *mpa);
4674 Points are elements of a set. They can be used to construct
4675 simple sets (boxes) or they can be used to represent the
4676 individual elements of a set.
4677 The zero point (the origin) can be created using
4679 __isl_give isl_point *isl_point_zero(__isl_take isl_space *space);
4681 The coordinates of a point can be inspected, set and changed
4684 __isl_give isl_val *isl_point_get_coordinate_val(
4685 __isl_keep isl_point *pnt,
4686 enum isl_dim_type type, int pos);
4687 __isl_give isl_point *isl_point_set_coordinate_val(
4688 __isl_take isl_point *pnt,
4689 enum isl_dim_type type, int pos,
4690 __isl_take isl_val *v);
4692 __isl_give isl_point *isl_point_add_ui(
4693 __isl_take isl_point *pnt,
4694 enum isl_dim_type type, int pos, unsigned val);
4695 __isl_give isl_point *isl_point_sub_ui(
4696 __isl_take isl_point *pnt,
4697 enum isl_dim_type type, int pos, unsigned val);
4699 Other properties can be obtained using
4701 isl_ctx *isl_point_get_ctx(__isl_keep isl_point *pnt);
4703 Points can be copied or freed using
4705 __isl_give isl_point *isl_point_copy(
4706 __isl_keep isl_point *pnt);
4707 void isl_point_free(__isl_take isl_point *pnt);
4709 A singleton set can be created from a point using
4711 __isl_give isl_basic_set *isl_basic_set_from_point(
4712 __isl_take isl_point *pnt);
4713 __isl_give isl_set *isl_set_from_point(
4714 __isl_take isl_point *pnt);
4716 and a box can be created from two opposite extremal points using
4718 __isl_give isl_basic_set *isl_basic_set_box_from_points(
4719 __isl_take isl_point *pnt1,
4720 __isl_take isl_point *pnt2);
4721 __isl_give isl_set *isl_set_box_from_points(
4722 __isl_take isl_point *pnt1,
4723 __isl_take isl_point *pnt2);
4725 All elements of a B<bounded> (union) set can be enumerated using
4726 the following functions.
4728 int isl_set_foreach_point(__isl_keep isl_set *set,
4729 int (*fn)(__isl_take isl_point *pnt, void *user),
4731 int isl_union_set_foreach_point(__isl_keep isl_union_set *uset,
4732 int (*fn)(__isl_take isl_point *pnt, void *user),
4735 The function C<fn> is called for each integer point in
4736 C<set> with as second argument the last argument of
4737 the C<isl_set_foreach_point> call. The function C<fn>
4738 should return C<0> on success and C<-1> on failure.
4739 In the latter case, C<isl_set_foreach_point> will stop
4740 enumerating and return C<-1> as well.
4741 If the enumeration is performed successfully and to completion,
4742 then C<isl_set_foreach_point> returns C<0>.
4744 To obtain a single point of a (basic) set, use
4746 __isl_give isl_point *isl_basic_set_sample_point(
4747 __isl_take isl_basic_set *bset);
4748 __isl_give isl_point *isl_set_sample_point(
4749 __isl_take isl_set *set);
4751 If C<set> does not contain any (integer) points, then the
4752 resulting point will be ``void'', a property that can be
4755 int isl_point_is_void(__isl_keep isl_point *pnt);
4757 =head2 Piecewise Quasipolynomials
4759 A piecewise quasipolynomial is a particular kind of function that maps
4760 a parametric point to a rational value.
4761 More specifically, a quasipolynomial is a polynomial expression in greatest
4762 integer parts of affine expressions of parameters and variables.
4763 A piecewise quasipolynomial is a subdivision of a given parametric
4764 domain into disjoint cells with a quasipolynomial associated to
4765 each cell. The value of the piecewise quasipolynomial at a given
4766 point is the value of the quasipolynomial associated to the cell
4767 that contains the point. Outside of the union of cells,
4768 the value is assumed to be zero.
4769 For example, the piecewise quasipolynomial
4771 [n] -> { [x] -> ((1 + n) - x) : x <= n and x >= 0 }
4773 maps C<x> to C<1 + n - x> for values of C<x> between C<0> and C<n>.
4774 A given piecewise quasipolynomial has a fixed domain dimension.
4775 Union piecewise quasipolynomials are used to contain piecewise quasipolynomials
4776 defined over different domains.
4777 Piecewise quasipolynomials are mainly used by the C<barvinok>
4778 library for representing the number of elements in a parametric set or map.
4779 For example, the piecewise quasipolynomial above represents
4780 the number of points in the map
4782 [n] -> { [x] -> [y] : x,y >= 0 and 0 <= x + y <= n }
4784 =head3 Input and Output
4786 Piecewise quasipolynomials can be read from input using
4788 __isl_give isl_union_pw_qpolynomial *
4789 isl_union_pw_qpolynomial_read_from_str(
4790 isl_ctx *ctx, const char *str);
4792 Quasipolynomials and piecewise quasipolynomials can be printed
4793 using the following functions.
4795 __isl_give isl_printer *isl_printer_print_qpolynomial(
4796 __isl_take isl_printer *p,
4797 __isl_keep isl_qpolynomial *qp);
4799 __isl_give isl_printer *isl_printer_print_pw_qpolynomial(
4800 __isl_take isl_printer *p,
4801 __isl_keep isl_pw_qpolynomial *pwqp);
4803 __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial(
4804 __isl_take isl_printer *p,
4805 __isl_keep isl_union_pw_qpolynomial *upwqp);
4807 The output format of the printer
4808 needs to be set to either C<ISL_FORMAT_ISL> or C<ISL_FORMAT_C>.
4809 For C<isl_printer_print_union_pw_qpolynomial>, only C<ISL_FORMAT_ISL>
4811 In case of printing in C<ISL_FORMAT_C>, the user may want
4812 to set the names of all dimensions
4814 __isl_give isl_qpolynomial *isl_qpolynomial_set_dim_name(
4815 __isl_take isl_qpolynomial *qp,
4816 enum isl_dim_type type, unsigned pos,
4818 __isl_give isl_pw_qpolynomial *
4819 isl_pw_qpolynomial_set_dim_name(
4820 __isl_take isl_pw_qpolynomial *pwqp,
4821 enum isl_dim_type type, unsigned pos,
4824 =head3 Creating New (Piecewise) Quasipolynomials
4826 Some simple quasipolynomials can be created using the following functions.
4827 More complicated quasipolynomials can be created by applying
4828 operations such as addition and multiplication
4829 on the resulting quasipolynomials
4831 __isl_give isl_qpolynomial *isl_qpolynomial_zero_on_domain(
4832 __isl_take isl_space *domain);
4833 __isl_give isl_qpolynomial *isl_qpolynomial_one_on_domain(
4834 __isl_take isl_space *domain);
4835 __isl_give isl_qpolynomial *isl_qpolynomial_infty_on_domain(
4836 __isl_take isl_space *domain);
4837 __isl_give isl_qpolynomial *isl_qpolynomial_neginfty_on_domain(
4838 __isl_take isl_space *domain);
4839 __isl_give isl_qpolynomial *isl_qpolynomial_nan_on_domain(
4840 __isl_take isl_space *domain);
4841 __isl_give isl_qpolynomial *isl_qpolynomial_val_on_domain(
4842 __isl_take isl_space *domain,
4843 __isl_take isl_val *val);
4844 __isl_give isl_qpolynomial *isl_qpolynomial_var_on_domain(
4845 __isl_take isl_space *domain,
4846 enum isl_dim_type type, unsigned pos);
4847 __isl_give isl_qpolynomial *isl_qpolynomial_from_aff(
4848 __isl_take isl_aff *aff);
4850 Note that the space in which a quasipolynomial lives is a map space
4851 with a one-dimensional range. The C<domain> argument in some of
4852 the functions above corresponds to the domain of this map space.
4854 The zero piecewise quasipolynomial or a piecewise quasipolynomial
4855 with a single cell can be created using the following functions.
4856 Multiple of these single cell piecewise quasipolynomials can
4857 be combined to create more complicated piecewise quasipolynomials.
4859 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_zero(
4860 __isl_take isl_space *space);
4861 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_alloc(
4862 __isl_take isl_set *set,
4863 __isl_take isl_qpolynomial *qp);
4864 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_from_qpolynomial(
4865 __isl_take isl_qpolynomial *qp);
4866 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_from_pw_aff(
4867 __isl_take isl_pw_aff *pwaff);
4869 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_zero(
4870 __isl_take isl_space *space);
4871 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_from_pw_qpolynomial(
4872 __isl_take isl_pw_qpolynomial *pwqp);
4873 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add_pw_qpolynomial(
4874 __isl_take isl_union_pw_qpolynomial *upwqp,
4875 __isl_take isl_pw_qpolynomial *pwqp);
4877 Quasipolynomials can be copied and freed again using the following
4880 __isl_give isl_qpolynomial *isl_qpolynomial_copy(
4881 __isl_keep isl_qpolynomial *qp);
4882 void *isl_qpolynomial_free(__isl_take isl_qpolynomial *qp);
4884 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_copy(
4885 __isl_keep isl_pw_qpolynomial *pwqp);
4886 void *isl_pw_qpolynomial_free(
4887 __isl_take isl_pw_qpolynomial *pwqp);
4889 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_copy(
4890 __isl_keep isl_union_pw_qpolynomial *upwqp);
4891 void *isl_union_pw_qpolynomial_free(
4892 __isl_take isl_union_pw_qpolynomial *upwqp);
4894 =head3 Inspecting (Piecewise) Quasipolynomials
4896 To iterate over all piecewise quasipolynomials in a union
4897 piecewise quasipolynomial, use the following function
4899 int isl_union_pw_qpolynomial_foreach_pw_qpolynomial(
4900 __isl_keep isl_union_pw_qpolynomial *upwqp,
4901 int (*fn)(__isl_take isl_pw_qpolynomial *pwqp, void *user),
4904 To extract the piecewise quasipolynomial in a given space from a union, use
4906 __isl_give isl_pw_qpolynomial *
4907 isl_union_pw_qpolynomial_extract_pw_qpolynomial(
4908 __isl_keep isl_union_pw_qpolynomial *upwqp,
4909 __isl_take isl_space *space);
4911 To iterate over the cells in a piecewise quasipolynomial,
4912 use either of the following two functions
4914 int isl_pw_qpolynomial_foreach_piece(
4915 __isl_keep isl_pw_qpolynomial *pwqp,
4916 int (*fn)(__isl_take isl_set *set,
4917 __isl_take isl_qpolynomial *qp,
4918 void *user), void *user);
4919 int isl_pw_qpolynomial_foreach_lifted_piece(
4920 __isl_keep isl_pw_qpolynomial *pwqp,
4921 int (*fn)(__isl_take isl_set *set,
4922 __isl_take isl_qpolynomial *qp,
4923 void *user), void *user);
4925 As usual, the function C<fn> should return C<0> on success
4926 and C<-1> on failure. The difference between
4927 C<isl_pw_qpolynomial_foreach_piece> and
4928 C<isl_pw_qpolynomial_foreach_lifted_piece> is that
4929 C<isl_pw_qpolynomial_foreach_lifted_piece> will first
4930 compute unique representations for all existentially quantified
4931 variables and then turn these existentially quantified variables
4932 into extra set variables, adapting the associated quasipolynomial
4933 accordingly. This means that the C<set> passed to C<fn>
4934 will not have any existentially quantified variables, but that
4935 the dimensions of the sets may be different for different
4936 invocations of C<fn>.
4938 The constant term of a quasipolynomial can be extracted using
4940 __isl_give isl_val *isl_qpolynomial_get_constant_val(
4941 __isl_keep isl_qpolynomial *qp);
4943 To iterate over all terms in a quasipolynomial,
4946 int isl_qpolynomial_foreach_term(
4947 __isl_keep isl_qpolynomial *qp,
4948 int (*fn)(__isl_take isl_term *term,
4949 void *user), void *user);
4951 The terms themselves can be inspected and freed using
4954 unsigned isl_term_dim(__isl_keep isl_term *term,
4955 enum isl_dim_type type);
4956 __isl_give isl_val *isl_term_get_coefficient_val(
4957 __isl_keep isl_term *term);
4958 int isl_term_get_exp(__isl_keep isl_term *term,
4959 enum isl_dim_type type, unsigned pos);
4960 __isl_give isl_aff *isl_term_get_div(
4961 __isl_keep isl_term *term, unsigned pos);
4962 void isl_term_free(__isl_take isl_term *term);
4964 Each term is a product of parameters, set variables and
4965 integer divisions. The function C<isl_term_get_exp>
4966 returns the exponent of a given dimensions in the given term.
4968 =head3 Properties of (Piecewise) Quasipolynomials
4970 To check whether two union piecewise quasipolynomials are
4971 obviously equal, use
4973 int isl_union_pw_qpolynomial_plain_is_equal(
4974 __isl_keep isl_union_pw_qpolynomial *upwqp1,
4975 __isl_keep isl_union_pw_qpolynomial *upwqp2);
4977 =head3 Operations on (Piecewise) Quasipolynomials
4979 __isl_give isl_qpolynomial *isl_qpolynomial_scale_val(
4980 __isl_take isl_qpolynomial *qp,
4981 __isl_take isl_val *v);
4982 __isl_give isl_qpolynomial *isl_qpolynomial_neg(
4983 __isl_take isl_qpolynomial *qp);
4984 __isl_give isl_qpolynomial *isl_qpolynomial_add(
4985 __isl_take isl_qpolynomial *qp1,
4986 __isl_take isl_qpolynomial *qp2);
4987 __isl_give isl_qpolynomial *isl_qpolynomial_sub(
4988 __isl_take isl_qpolynomial *qp1,
4989 __isl_take isl_qpolynomial *qp2);
4990 __isl_give isl_qpolynomial *isl_qpolynomial_mul(
4991 __isl_take isl_qpolynomial *qp1,
4992 __isl_take isl_qpolynomial *qp2);
4993 __isl_give isl_qpolynomial *isl_qpolynomial_pow(
4994 __isl_take isl_qpolynomial *qp, unsigned exponent);
4996 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_fix_val(
4997 __isl_take isl_pw_qpolynomial *pwqp,
4998 enum isl_dim_type type, unsigned n,
4999 __isl_take isl_val *v);
5000 __isl_give isl_pw_qpolynomial *
5001 isl_pw_qpolynomial_scale_val(
5002 __isl_take isl_pw_qpolynomial *pwqp,
5003 __isl_take isl_val *v);
5004 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add(
5005 __isl_take isl_pw_qpolynomial *pwqp1,
5006 __isl_take isl_pw_qpolynomial *pwqp2);
5007 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_sub(
5008 __isl_take isl_pw_qpolynomial *pwqp1,
5009 __isl_take isl_pw_qpolynomial *pwqp2);
5010 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add_disjoint(
5011 __isl_take isl_pw_qpolynomial *pwqp1,
5012 __isl_take isl_pw_qpolynomial *pwqp2);
5013 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_neg(
5014 __isl_take isl_pw_qpolynomial *pwqp);
5015 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_mul(
5016 __isl_take isl_pw_qpolynomial *pwqp1,
5017 __isl_take isl_pw_qpolynomial *pwqp2);
5018 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_pow(
5019 __isl_take isl_pw_qpolynomial *pwqp, unsigned exponent);
5021 __isl_give isl_union_pw_qpolynomial *
5022 isl_union_pw_qpolynomial_scale_val(
5023 __isl_take isl_union_pw_qpolynomial *upwqp,
5024 __isl_take isl_val *v);
5025 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add(
5026 __isl_take isl_union_pw_qpolynomial *upwqp1,
5027 __isl_take isl_union_pw_qpolynomial *upwqp2);
5028 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_sub(
5029 __isl_take isl_union_pw_qpolynomial *upwqp1,
5030 __isl_take isl_union_pw_qpolynomial *upwqp2);
5031 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_mul(
5032 __isl_take isl_union_pw_qpolynomial *upwqp1,
5033 __isl_take isl_union_pw_qpolynomial *upwqp2);
5035 __isl_give isl_val *isl_pw_qpolynomial_eval(
5036 __isl_take isl_pw_qpolynomial *pwqp,
5037 __isl_take isl_point *pnt);
5039 __isl_give isl_val *isl_union_pw_qpolynomial_eval(
5040 __isl_take isl_union_pw_qpolynomial *upwqp,
5041 __isl_take isl_point *pnt);
5043 __isl_give isl_set *isl_pw_qpolynomial_domain(
5044 __isl_take isl_pw_qpolynomial *pwqp);
5045 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_intersect_domain(
5046 __isl_take isl_pw_qpolynomial *pwpq,
5047 __isl_take isl_set *set);
5048 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_intersect_params(
5049 __isl_take isl_pw_qpolynomial *pwpq,
5050 __isl_take isl_set *set);
5052 __isl_give isl_union_set *isl_union_pw_qpolynomial_domain(
5053 __isl_take isl_union_pw_qpolynomial *upwqp);
5054 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_intersect_domain(
5055 __isl_take isl_union_pw_qpolynomial *upwpq,
5056 __isl_take isl_union_set *uset);
5057 __isl_give isl_union_pw_qpolynomial *
5058 isl_union_pw_qpolynomial_intersect_params(
5059 __isl_take isl_union_pw_qpolynomial *upwpq,
5060 __isl_take isl_set *set);
5062 __isl_give isl_qpolynomial *isl_qpolynomial_align_params(
5063 __isl_take isl_qpolynomial *qp,
5064 __isl_take isl_space *model);
5066 __isl_give isl_qpolynomial *isl_qpolynomial_project_domain_on_params(
5067 __isl_take isl_qpolynomial *qp);
5068 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_project_domain_on_params(
5069 __isl_take isl_pw_qpolynomial *pwqp);
5071 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_coalesce(
5072 __isl_take isl_union_pw_qpolynomial *upwqp);
5074 __isl_give isl_qpolynomial *isl_qpolynomial_gist_params(
5075 __isl_take isl_qpolynomial *qp,
5076 __isl_take isl_set *context);
5077 __isl_give isl_qpolynomial *isl_qpolynomial_gist(
5078 __isl_take isl_qpolynomial *qp,
5079 __isl_take isl_set *context);
5081 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist_params(
5082 __isl_take isl_pw_qpolynomial *pwqp,
5083 __isl_take isl_set *context);
5084 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist(
5085 __isl_take isl_pw_qpolynomial *pwqp,
5086 __isl_take isl_set *context);
5088 __isl_give isl_union_pw_qpolynomial *
5089 isl_union_pw_qpolynomial_gist_params(
5090 __isl_take isl_union_pw_qpolynomial *upwqp,
5091 __isl_take isl_set *context);
5092 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_gist(
5093 __isl_take isl_union_pw_qpolynomial *upwqp,
5094 __isl_take isl_union_set *context);
5096 The gist operation applies the gist operation to each of
5097 the cells in the domain of the input piecewise quasipolynomial.
5098 The context is also exploited
5099 to simplify the quasipolynomials associated to each cell.
5101 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_to_polynomial(
5102 __isl_take isl_pw_qpolynomial *pwqp, int sign);
5103 __isl_give isl_union_pw_qpolynomial *
5104 isl_union_pw_qpolynomial_to_polynomial(
5105 __isl_take isl_union_pw_qpolynomial *upwqp, int sign);
5107 Approximate each quasipolynomial by a polynomial. If C<sign> is positive,
5108 the polynomial will be an overapproximation. If C<sign> is negative,
5109 it will be an underapproximation. If C<sign> is zero, the approximation
5110 will lie somewhere in between.
5112 =head2 Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions
5114 A piecewise quasipolynomial reduction is a piecewise
5115 reduction (or fold) of quasipolynomials.
5116 In particular, the reduction can be maximum or a minimum.
5117 The objects are mainly used to represent the result of
5118 an upper or lower bound on a quasipolynomial over its domain,
5119 i.e., as the result of the following function.
5121 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_bound(
5122 __isl_take isl_pw_qpolynomial *pwqp,
5123 enum isl_fold type, int *tight);
5125 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_bound(
5126 __isl_take isl_union_pw_qpolynomial *upwqp,
5127 enum isl_fold type, int *tight);
5129 The C<type> argument may be either C<isl_fold_min> or C<isl_fold_max>.
5130 If C<tight> is not C<NULL>, then C<*tight> is set to C<1>
5131 is the returned bound is known be tight, i.e., for each value
5132 of the parameters there is at least
5133 one element in the domain that reaches the bound.
5134 If the domain of C<pwqp> is not wrapping, then the bound is computed
5135 over all elements in that domain and the result has a purely parametric
5136 domain. If the domain of C<pwqp> is wrapping, then the bound is
5137 computed over the range of the wrapped relation. The domain of the
5138 wrapped relation becomes the domain of the result.
5140 A (piecewise) quasipolynomial reduction can be copied or freed using the
5141 following functions.
5143 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_copy(
5144 __isl_keep isl_qpolynomial_fold *fold);
5145 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_copy(
5146 __isl_keep isl_pw_qpolynomial_fold *pwf);
5147 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_copy(
5148 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
5149 void isl_qpolynomial_fold_free(
5150 __isl_take isl_qpolynomial_fold *fold);
5151 void *isl_pw_qpolynomial_fold_free(
5152 __isl_take isl_pw_qpolynomial_fold *pwf);
5153 void *isl_union_pw_qpolynomial_fold_free(
5154 __isl_take isl_union_pw_qpolynomial_fold *upwf);
5156 =head3 Printing Piecewise Quasipolynomial Reductions
5158 Piecewise quasipolynomial reductions can be printed
5159 using the following function.
5161 __isl_give isl_printer *isl_printer_print_pw_qpolynomial_fold(
5162 __isl_take isl_printer *p,
5163 __isl_keep isl_pw_qpolynomial_fold *pwf);
5164 __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial_fold(
5165 __isl_take isl_printer *p,
5166 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
5168 For C<isl_printer_print_pw_qpolynomial_fold>,
5169 output format of the printer
5170 needs to be set to either C<ISL_FORMAT_ISL> or C<ISL_FORMAT_C>.
5171 For C<isl_printer_print_union_pw_qpolynomial_fold>,
5172 output format of the printer
5173 needs to be set to C<ISL_FORMAT_ISL>.
5174 In case of printing in C<ISL_FORMAT_C>, the user may want
5175 to set the names of all dimensions
5177 __isl_give isl_pw_qpolynomial_fold *
5178 isl_pw_qpolynomial_fold_set_dim_name(
5179 __isl_take isl_pw_qpolynomial_fold *pwf,
5180 enum isl_dim_type type, unsigned pos,
5183 =head3 Inspecting (Piecewise) Quasipolynomial Reductions
5185 To iterate over all piecewise quasipolynomial reductions in a union
5186 piecewise quasipolynomial reduction, use the following function
5188 int isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(
5189 __isl_keep isl_union_pw_qpolynomial_fold *upwf,
5190 int (*fn)(__isl_take isl_pw_qpolynomial_fold *pwf,
5191 void *user), void *user);
5193 To iterate over the cells in a piecewise quasipolynomial reduction,
5194 use either of the following two functions
5196 int isl_pw_qpolynomial_fold_foreach_piece(
5197 __isl_keep isl_pw_qpolynomial_fold *pwf,
5198 int (*fn)(__isl_take isl_set *set,
5199 __isl_take isl_qpolynomial_fold *fold,
5200 void *user), void *user);
5201 int isl_pw_qpolynomial_fold_foreach_lifted_piece(
5202 __isl_keep isl_pw_qpolynomial_fold *pwf,
5203 int (*fn)(__isl_take isl_set *set,
5204 __isl_take isl_qpolynomial_fold *fold,
5205 void *user), void *user);
5207 See L<Inspecting (Piecewise) Quasipolynomials> for an explanation
5208 of the difference between these two functions.
5210 To iterate over all quasipolynomials in a reduction, use
5212 int isl_qpolynomial_fold_foreach_qpolynomial(
5213 __isl_keep isl_qpolynomial_fold *fold,
5214 int (*fn)(__isl_take isl_qpolynomial *qp,
5215 void *user), void *user);
5217 =head3 Properties of Piecewise Quasipolynomial Reductions
5219 To check whether two union piecewise quasipolynomial reductions are
5220 obviously equal, use
5222 int isl_union_pw_qpolynomial_fold_plain_is_equal(
5223 __isl_keep isl_union_pw_qpolynomial_fold *upwf1,
5224 __isl_keep isl_union_pw_qpolynomial_fold *upwf2);
5226 =head3 Operations on Piecewise Quasipolynomial Reductions
5228 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_scale_val(
5229 __isl_take isl_qpolynomial_fold *fold,
5230 __isl_take isl_val *v);
5231 __isl_give isl_pw_qpolynomial_fold *
5232 isl_pw_qpolynomial_fold_scale_val(
5233 __isl_take isl_pw_qpolynomial_fold *pwf,
5234 __isl_take isl_val *v);
5235 __isl_give isl_union_pw_qpolynomial_fold *
5236 isl_union_pw_qpolynomial_fold_scale_val(
5237 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5238 __isl_take isl_val *v);
5240 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_add(
5241 __isl_take isl_pw_qpolynomial_fold *pwf1,
5242 __isl_take isl_pw_qpolynomial_fold *pwf2);
5244 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_fold(
5245 __isl_take isl_pw_qpolynomial_fold *pwf1,
5246 __isl_take isl_pw_qpolynomial_fold *pwf2);
5248 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_fold(
5249 __isl_take isl_union_pw_qpolynomial_fold *upwf1,
5250 __isl_take isl_union_pw_qpolynomial_fold *upwf2);
5252 __isl_give isl_val *isl_pw_qpolynomial_fold_eval(
5253 __isl_take isl_pw_qpolynomial_fold *pwf,
5254 __isl_take isl_point *pnt);
5256 __isl_give isl_val *isl_union_pw_qpolynomial_fold_eval(
5257 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5258 __isl_take isl_point *pnt);
5260 __isl_give isl_pw_qpolynomial_fold *
5261 isl_pw_qpolynomial_fold_intersect_params(
5262 __isl_take isl_pw_qpolynomial_fold *pwf,
5263 __isl_take isl_set *set);
5265 __isl_give isl_union_set *isl_union_pw_qpolynomial_fold_domain(
5266 __isl_take isl_union_pw_qpolynomial_fold *upwf);
5267 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_intersect_domain(
5268 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5269 __isl_take isl_union_set *uset);
5270 __isl_give isl_union_pw_qpolynomial_fold *
5271 isl_union_pw_qpolynomial_fold_intersect_params(
5272 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5273 __isl_take isl_set *set);
5275 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_project_domain_on_params(
5276 __isl_take isl_pw_qpolynomial_fold *pwf);
5278 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_coalesce(
5279 __isl_take isl_pw_qpolynomial_fold *pwf);
5281 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_coalesce(
5282 __isl_take isl_union_pw_qpolynomial_fold *upwf);
5284 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist_params(
5285 __isl_take isl_qpolynomial_fold *fold,
5286 __isl_take isl_set *context);
5287 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist(
5288 __isl_take isl_qpolynomial_fold *fold,
5289 __isl_take isl_set *context);
5291 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_gist(
5292 __isl_take isl_pw_qpolynomial_fold *pwf,
5293 __isl_take isl_set *context);
5294 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_gist_params(
5295 __isl_take isl_pw_qpolynomial_fold *pwf,
5296 __isl_take isl_set *context);
5298 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_gist(
5299 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5300 __isl_take isl_union_set *context);
5301 __isl_give isl_union_pw_qpolynomial_fold *
5302 isl_union_pw_qpolynomial_fold_gist_params(
5303 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5304 __isl_take isl_set *context);
5306 The gist operation applies the gist operation to each of
5307 the cells in the domain of the input piecewise quasipolynomial reduction.
5308 In future, the operation will also exploit the context
5309 to simplify the quasipolynomial reductions associated to each cell.
5311 __isl_give isl_pw_qpolynomial_fold *
5312 isl_set_apply_pw_qpolynomial_fold(
5313 __isl_take isl_set *set,
5314 __isl_take isl_pw_qpolynomial_fold *pwf,
5316 __isl_give isl_pw_qpolynomial_fold *
5317 isl_map_apply_pw_qpolynomial_fold(
5318 __isl_take isl_map *map,
5319 __isl_take isl_pw_qpolynomial_fold *pwf,
5321 __isl_give isl_union_pw_qpolynomial_fold *
5322 isl_union_set_apply_union_pw_qpolynomial_fold(
5323 __isl_take isl_union_set *uset,
5324 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5326 __isl_give isl_union_pw_qpolynomial_fold *
5327 isl_union_map_apply_union_pw_qpolynomial_fold(
5328 __isl_take isl_union_map *umap,
5329 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5332 The functions taking a map
5333 compose the given map with the given piecewise quasipolynomial reduction.
5334 That is, compute a bound (of the same type as C<pwf> or C<upwf> itself)
5335 over all elements in the intersection of the range of the map
5336 and the domain of the piecewise quasipolynomial reduction
5337 as a function of an element in the domain of the map.
5338 The functions taking a set compute a bound over all elements in the
5339 intersection of the set and the domain of the
5340 piecewise quasipolynomial reduction.
5342 =head2 Parametric Vertex Enumeration
5344 The parametric vertex enumeration described in this section
5345 is mainly intended to be used internally and by the C<barvinok>
5348 #include <isl/vertices.h>
5349 __isl_give isl_vertices *isl_basic_set_compute_vertices(
5350 __isl_keep isl_basic_set *bset);
5352 The function C<isl_basic_set_compute_vertices> performs the
5353 actual computation of the parametric vertices and the chamber
5354 decomposition and store the result in an C<isl_vertices> object.
5355 This information can be queried by either iterating over all
5356 the vertices or iterating over all the chambers or cells
5357 and then iterating over all vertices that are active on the chamber.
5359 int isl_vertices_foreach_vertex(
5360 __isl_keep isl_vertices *vertices,
5361 int (*fn)(__isl_take isl_vertex *vertex, void *user),
5364 int isl_vertices_foreach_cell(
5365 __isl_keep isl_vertices *vertices,
5366 int (*fn)(__isl_take isl_cell *cell, void *user),
5368 int isl_cell_foreach_vertex(__isl_keep isl_cell *cell,
5369 int (*fn)(__isl_take isl_vertex *vertex, void *user),
5372 Other operations that can be performed on an C<isl_vertices> object are
5375 isl_ctx *isl_vertices_get_ctx(
5376 __isl_keep isl_vertices *vertices);
5377 int isl_vertices_get_n_vertices(
5378 __isl_keep isl_vertices *vertices);
5379 void isl_vertices_free(__isl_take isl_vertices *vertices);
5381 Vertices can be inspected and destroyed using the following functions.
5383 isl_ctx *isl_vertex_get_ctx(__isl_keep isl_vertex *vertex);
5384 int isl_vertex_get_id(__isl_keep isl_vertex *vertex);
5385 __isl_give isl_basic_set *isl_vertex_get_domain(
5386 __isl_keep isl_vertex *vertex);
5387 __isl_give isl_basic_set *isl_vertex_get_expr(
5388 __isl_keep isl_vertex *vertex);
5389 void isl_vertex_free(__isl_take isl_vertex *vertex);
5391 C<isl_vertex_get_expr> returns a singleton parametric set describing
5392 the vertex, while C<isl_vertex_get_domain> returns the activity domain
5394 Note that C<isl_vertex_get_domain> and C<isl_vertex_get_expr> return
5395 B<rational> basic sets, so they should mainly be used for inspection
5396 and should not be mixed with integer sets.
5398 Chambers can be inspected and destroyed using the following functions.
5400 isl_ctx *isl_cell_get_ctx(__isl_keep isl_cell *cell);
5401 __isl_give isl_basic_set *isl_cell_get_domain(
5402 __isl_keep isl_cell *cell);
5403 void isl_cell_free(__isl_take isl_cell *cell);
5405 =head1 Polyhedral Compilation Library
5407 This section collects functionality in C<isl> that has been specifically
5408 designed for use during polyhedral compilation.
5410 =head2 Dependence Analysis
5412 C<isl> contains specialized functionality for performing
5413 array dataflow analysis. That is, given a I<sink> access relation
5414 and a collection of possible I<source> access relations,
5415 C<isl> can compute relations that describe
5416 for each iteration of the sink access, which iteration
5417 of which of the source access relations was the last
5418 to access the same data element before the given iteration
5420 The resulting dependence relations map source iterations
5421 to the corresponding sink iterations.
5422 To compute standard flow dependences, the sink should be
5423 a read, while the sources should be writes.
5424 If any of the source accesses are marked as being I<may>
5425 accesses, then there will be a dependence from the last
5426 I<must> access B<and> from any I<may> access that follows
5427 this last I<must> access.
5428 In particular, if I<all> sources are I<may> accesses,
5429 then memory based dependence analysis is performed.
5430 If, on the other hand, all sources are I<must> accesses,
5431 then value based dependence analysis is performed.
5433 #include <isl/flow.h>
5435 typedef int (*isl_access_level_before)(void *first, void *second);
5437 __isl_give isl_access_info *isl_access_info_alloc(
5438 __isl_take isl_map *sink,
5439 void *sink_user, isl_access_level_before fn,
5441 __isl_give isl_access_info *isl_access_info_add_source(
5442 __isl_take isl_access_info *acc,
5443 __isl_take isl_map *source, int must,
5445 void *isl_access_info_free(__isl_take isl_access_info *acc);
5447 __isl_give isl_flow *isl_access_info_compute_flow(
5448 __isl_take isl_access_info *acc);
5450 int isl_flow_foreach(__isl_keep isl_flow *deps,
5451 int (*fn)(__isl_take isl_map *dep, int must,
5452 void *dep_user, void *user),
5454 __isl_give isl_map *isl_flow_get_no_source(
5455 __isl_keep isl_flow *deps, int must);
5456 void isl_flow_free(__isl_take isl_flow *deps);
5458 The function C<isl_access_info_compute_flow> performs the actual
5459 dependence analysis. The other functions are used to construct
5460 the input for this function or to read off the output.
5462 The input is collected in an C<isl_access_info>, which can
5463 be created through a call to C<isl_access_info_alloc>.
5464 The arguments to this functions are the sink access relation
5465 C<sink>, a token C<sink_user> used to identify the sink
5466 access to the user, a callback function for specifying the
5467 relative order of source and sink accesses, and the number
5468 of source access relations that will be added.
5469 The callback function has type C<int (*)(void *first, void *second)>.
5470 The function is called with two user supplied tokens identifying
5471 either a source or the sink and it should return the shared nesting
5472 level and the relative order of the two accesses.
5473 In particular, let I<n> be the number of loops shared by
5474 the two accesses. If C<first> precedes C<second> textually,
5475 then the function should return I<2 * n + 1>; otherwise,
5476 it should return I<2 * n>.
5477 The sources can be added to the C<isl_access_info> by performing
5478 (at most) C<max_source> calls to C<isl_access_info_add_source>.
5479 C<must> indicates whether the source is a I<must> access
5480 or a I<may> access. Note that a multi-valued access relation
5481 should only be marked I<must> if every iteration in the domain
5482 of the relation accesses I<all> elements in its image.
5483 The C<source_user> token is again used to identify
5484 the source access. The range of the source access relation
5485 C<source> should have the same dimension as the range
5486 of the sink access relation.
5487 The C<isl_access_info_free> function should usually not be
5488 called explicitly, because it is called implicitly by
5489 C<isl_access_info_compute_flow>.
5491 The result of the dependence analysis is collected in an
5492 C<isl_flow>. There may be elements of
5493 the sink access for which no preceding source access could be
5494 found or for which all preceding sources are I<may> accesses.
5495 The relations containing these elements can be obtained through
5496 calls to C<isl_flow_get_no_source>, the first with C<must> set
5497 and the second with C<must> unset.
5498 In the case of standard flow dependence analysis,
5499 with the sink a read and the sources I<must> writes,
5500 the first relation corresponds to the reads from uninitialized
5501 array elements and the second relation is empty.
5502 The actual flow dependences can be extracted using
5503 C<isl_flow_foreach>. This function will call the user-specified
5504 callback function C<fn> for each B<non-empty> dependence between
5505 a source and the sink. The callback function is called
5506 with four arguments, the actual flow dependence relation
5507 mapping source iterations to sink iterations, a boolean that
5508 indicates whether it is a I<must> or I<may> dependence, a token
5509 identifying the source and an additional C<void *> with value
5510 equal to the third argument of the C<isl_flow_foreach> call.
5511 A dependence is marked I<must> if it originates from a I<must>
5512 source and if it is not followed by any I<may> sources.
5514 After finishing with an C<isl_flow>, the user should call
5515 C<isl_flow_free> to free all associated memory.
5517 A higher-level interface to dependence analysis is provided
5518 by the following function.
5520 #include <isl/flow.h>
5522 int isl_union_map_compute_flow(__isl_take isl_union_map *sink,
5523 __isl_take isl_union_map *must_source,
5524 __isl_take isl_union_map *may_source,
5525 __isl_take isl_union_map *schedule,
5526 __isl_give isl_union_map **must_dep,
5527 __isl_give isl_union_map **may_dep,
5528 __isl_give isl_union_map **must_no_source,
5529 __isl_give isl_union_map **may_no_source);
5531 The arrays are identified by the tuple names of the ranges
5532 of the accesses. The iteration domains by the tuple names
5533 of the domains of the accesses and of the schedule.
5534 The relative order of the iteration domains is given by the
5535 schedule. The relations returned through C<must_no_source>
5536 and C<may_no_source> are subsets of C<sink>.
5537 Any of C<must_dep>, C<may_dep>, C<must_no_source>
5538 or C<may_no_source> may be C<NULL>, but a C<NULL> value for
5539 any of the other arguments is treated as an error.
5541 =head3 Interaction with Dependence Analysis
5543 During the dependence analysis, we frequently need to perform
5544 the following operation. Given a relation between sink iterations
5545 and potential source iterations from a particular source domain,
5546 what is the last potential source iteration corresponding to each
5547 sink iteration. It can sometimes be convenient to adjust
5548 the set of potential source iterations before or after each such operation.
5549 The prototypical example is fuzzy array dataflow analysis,
5550 where we need to analyze if, based on data-dependent constraints,
5551 the sink iteration can ever be executed without one or more of
5552 the corresponding potential source iterations being executed.
5553 If so, we can introduce extra parameters and select an unknown
5554 but fixed source iteration from the potential source iterations.
5555 To be able to perform such manipulations, C<isl> provides the following
5558 #include <isl/flow.h>
5560 typedef __isl_give isl_restriction *(*isl_access_restrict)(
5561 __isl_keep isl_map *source_map,
5562 __isl_keep isl_set *sink, void *source_user,
5564 __isl_give isl_access_info *isl_access_info_set_restrict(
5565 __isl_take isl_access_info *acc,
5566 isl_access_restrict fn, void *user);
5568 The function C<isl_access_info_set_restrict> should be called
5569 before calling C<isl_access_info_compute_flow> and registers a callback function
5570 that will be called any time C<isl> is about to compute the last
5571 potential source. The first argument is the (reverse) proto-dependence,
5572 mapping sink iterations to potential source iterations.
5573 The second argument represents the sink iterations for which
5574 we want to compute the last source iteration.
5575 The third argument is the token corresponding to the source
5576 and the final argument is the token passed to C<isl_access_info_set_restrict>.
5577 The callback is expected to return a restriction on either the input or
5578 the output of the operation computing the last potential source.
5579 If the input needs to be restricted then restrictions are needed
5580 for both the source and the sink iterations. The sink iterations
5581 and the potential source iterations will be intersected with these sets.
5582 If the output needs to be restricted then only a restriction on the source
5583 iterations is required.
5584 If any error occurs, the callback should return C<NULL>.
5585 An C<isl_restriction> object can be created, freed and inspected
5586 using the following functions.
5588 #include <isl/flow.h>
5590 __isl_give isl_restriction *isl_restriction_input(
5591 __isl_take isl_set *source_restr,
5592 __isl_take isl_set *sink_restr);
5593 __isl_give isl_restriction *isl_restriction_output(
5594 __isl_take isl_set *source_restr);
5595 __isl_give isl_restriction *isl_restriction_none(
5596 __isl_take isl_map *source_map);
5597 __isl_give isl_restriction *isl_restriction_empty(
5598 __isl_take isl_map *source_map);
5599 void *isl_restriction_free(
5600 __isl_take isl_restriction *restr);
5601 isl_ctx *isl_restriction_get_ctx(
5602 __isl_keep isl_restriction *restr);
5604 C<isl_restriction_none> and C<isl_restriction_empty> are special
5605 cases of C<isl_restriction_input>. C<isl_restriction_none>
5606 is essentially equivalent to
5608 isl_restriction_input(isl_set_universe(
5609 isl_space_range(isl_map_get_space(source_map))),
5611 isl_space_domain(isl_map_get_space(source_map))));
5613 whereas C<isl_restriction_empty> is essentially equivalent to
5615 isl_restriction_input(isl_set_empty(
5616 isl_space_range(isl_map_get_space(source_map))),
5618 isl_space_domain(isl_map_get_space(source_map))));
5622 B<The functionality described in this section is fairly new
5623 and may be subject to change.>
5625 The following function can be used to compute a schedule
5626 for a union of domains.
5627 By default, the algorithm used to construct the schedule is similar
5628 to that of C<Pluto>.
5629 Alternatively, Feautrier's multi-dimensional scheduling algorithm can
5631 The generated schedule respects all C<validity> dependences.
5632 That is, all dependence distances over these dependences in the
5633 scheduled space are lexicographically positive.
5634 The default algorithm tries to minimize the dependence distances over
5635 C<proximity> dependences.
5636 Moreover, it tries to obtain sequences (bands) of schedule dimensions
5637 for groups of domains where the dependence distances have only
5638 non-negative values.
5639 When using Feautrier's algorithm, the C<proximity> dependence
5640 distances are only minimized during the extension to a
5641 full-dimensional schedule.
5643 #include <isl/schedule.h>
5644 __isl_give isl_schedule *isl_union_set_compute_schedule(
5645 __isl_take isl_union_set *domain,
5646 __isl_take isl_union_map *validity,
5647 __isl_take isl_union_map *proximity);
5648 void *isl_schedule_free(__isl_take isl_schedule *sched);
5650 A mapping from the domains to the scheduled space can be obtained
5651 from an C<isl_schedule> using the following function.
5653 __isl_give isl_union_map *isl_schedule_get_map(
5654 __isl_keep isl_schedule *sched);
5656 A representation of the schedule can be printed using
5658 __isl_give isl_printer *isl_printer_print_schedule(
5659 __isl_take isl_printer *p,
5660 __isl_keep isl_schedule *schedule);
5662 A representation of the schedule as a forest of bands can be obtained
5663 using the following function.
5665 __isl_give isl_band_list *isl_schedule_get_band_forest(
5666 __isl_keep isl_schedule *schedule);
5668 The individual bands can be visited in depth-first post-order
5669 using the following function.
5671 #include <isl/schedule.h>
5672 int isl_schedule_foreach_band(
5673 __isl_keep isl_schedule *sched,
5674 int (*fn)(__isl_keep isl_band *band, void *user),
5677 The list can be manipulated as explained in L<"Lists">.
5678 The bands inside the list can be copied and freed using the following
5681 #include <isl/band.h>
5682 __isl_give isl_band *isl_band_copy(
5683 __isl_keep isl_band *band);
5684 void *isl_band_free(__isl_take isl_band *band);
5686 Each band contains zero or more scheduling dimensions.
5687 These are referred to as the members of the band.
5688 The section of the schedule that corresponds to the band is
5689 referred to as the partial schedule of the band.
5690 For those nodes that participate in a band, the outer scheduling
5691 dimensions form the prefix schedule, while the inner scheduling
5692 dimensions form the suffix schedule.
5693 That is, if we take a cut of the band forest, then the union of
5694 the concatenations of the prefix, partial and suffix schedules of
5695 each band in the cut is equal to the entire schedule (modulo
5696 some possible padding at the end with zero scheduling dimensions).
5697 The properties of a band can be inspected using the following functions.
5699 #include <isl/band.h>
5700 isl_ctx *isl_band_get_ctx(__isl_keep isl_band *band);
5702 int isl_band_has_children(__isl_keep isl_band *band);
5703 __isl_give isl_band_list *isl_band_get_children(
5704 __isl_keep isl_band *band);
5706 __isl_give isl_union_map *isl_band_get_prefix_schedule(
5707 __isl_keep isl_band *band);
5708 __isl_give isl_union_map *isl_band_get_partial_schedule(
5709 __isl_keep isl_band *band);
5710 __isl_give isl_union_map *isl_band_get_suffix_schedule(
5711 __isl_keep isl_band *band);
5713 int isl_band_n_member(__isl_keep isl_band *band);
5714 int isl_band_member_is_zero_distance(
5715 __isl_keep isl_band *band, int pos);
5717 int isl_band_list_foreach_band(
5718 __isl_keep isl_band_list *list,
5719 int (*fn)(__isl_keep isl_band *band, void *user),
5722 Note that a scheduling dimension is considered to be ``zero
5723 distance'' if it does not carry any proximity dependences
5725 That is, if the dependence distances of the proximity
5726 dependences are all zero in that direction (for fixed
5727 iterations of outer bands).
5728 Like C<isl_schedule_foreach_band>,
5729 the function C<isl_band_list_foreach_band> calls C<fn> on the bands
5730 in depth-first post-order.
5732 A band can be tiled using the following function.
5734 #include <isl/band.h>
5735 int isl_band_tile(__isl_keep isl_band *band,
5736 __isl_take isl_vec *sizes);
5738 int isl_options_set_tile_scale_tile_loops(isl_ctx *ctx,
5740 int isl_options_get_tile_scale_tile_loops(isl_ctx *ctx);
5741 int isl_options_set_tile_shift_point_loops(isl_ctx *ctx,
5743 int isl_options_get_tile_shift_point_loops(isl_ctx *ctx);
5745 The C<isl_band_tile> function tiles the band using the given tile sizes
5746 inside its schedule.
5747 A new child band is created to represent the point loops and it is
5748 inserted between the modified band and its children.
5749 The C<tile_scale_tile_loops> option specifies whether the tile
5750 loops iterators should be scaled by the tile sizes.
5751 If the C<tile_shift_point_loops> option is set, then the point loops
5752 are shifted to start at zero.
5754 A band can be split into two nested bands using the following function.
5756 int isl_band_split(__isl_keep isl_band *band, int pos);
5758 The resulting outer band contains the first C<pos> dimensions of C<band>
5759 while the inner band contains the remaining dimensions.
5761 A representation of the band can be printed using
5763 #include <isl/band.h>
5764 __isl_give isl_printer *isl_printer_print_band(
5765 __isl_take isl_printer *p,
5766 __isl_keep isl_band *band);
5770 #include <isl/schedule.h>
5771 int isl_options_set_schedule_max_coefficient(
5772 isl_ctx *ctx, int val);
5773 int isl_options_get_schedule_max_coefficient(
5775 int isl_options_set_schedule_max_constant_term(
5776 isl_ctx *ctx, int val);
5777 int isl_options_get_schedule_max_constant_term(
5779 int isl_options_set_schedule_fuse(isl_ctx *ctx, int val);
5780 int isl_options_get_schedule_fuse(isl_ctx *ctx);
5781 int isl_options_set_schedule_maximize_band_depth(
5782 isl_ctx *ctx, int val);
5783 int isl_options_get_schedule_maximize_band_depth(
5785 int isl_options_set_schedule_outer_zero_distance(
5786 isl_ctx *ctx, int val);
5787 int isl_options_get_schedule_outer_zero_distance(
5789 int isl_options_set_schedule_split_scaled(
5790 isl_ctx *ctx, int val);
5791 int isl_options_get_schedule_split_scaled(
5793 int isl_options_set_schedule_algorithm(
5794 isl_ctx *ctx, int val);
5795 int isl_options_get_schedule_algorithm(
5797 int isl_options_set_schedule_separate_components(
5798 isl_ctx *ctx, int val);
5799 int isl_options_get_schedule_separate_components(
5804 =item * schedule_max_coefficient
5806 This option enforces that the coefficients for variable and parameter
5807 dimensions in the calculated schedule are not larger than the specified value.
5808 This option can significantly increase the speed of the scheduling calculation
5809 and may also prevent fusing of unrelated dimensions. A value of -1 means that
5810 this option does not introduce bounds on the variable or parameter
5813 =item * schedule_max_constant_term
5815 This option enforces that the constant coefficients in the calculated schedule
5816 are not larger than the maximal constant term. This option can significantly
5817 increase the speed of the scheduling calculation and may also prevent fusing of
5818 unrelated dimensions. A value of -1 means that this option does not introduce
5819 bounds on the constant coefficients.
5821 =item * schedule_fuse
5823 This option controls the level of fusion.
5824 If this option is set to C<ISL_SCHEDULE_FUSE_MIN>, then loops in the
5825 resulting schedule will be distributed as much as possible.
5826 If this option is set to C<ISL_SCHEDULE_FUSE_MAX>, then C<isl> will
5827 try to fuse loops in the resulting schedule.
5829 =item * schedule_maximize_band_depth
5831 If this option is set, we do not split bands at the point
5832 where we detect splitting is necessary. Instead, we
5833 backtrack and split bands as early as possible. This
5834 reduces the number of splits and maximizes the width of
5835 the bands. Wider bands give more possibilities for tiling.
5836 Note that if the C<schedule_fuse> option is set to C<ISL_SCHEDULE_FUSE_MIN>,
5837 then bands will be split as early as possible, even if there is no need.
5838 The C<schedule_maximize_band_depth> option therefore has no effect in this case.
5840 =item * schedule_outer_zero_distance
5842 If this option is set, then we try to construct schedules
5843 where the outermost scheduling dimension in each band
5844 results in a zero dependence distance over the proximity
5847 =item * schedule_split_scaled
5849 If this option is set, then we try to construct schedules in which the
5850 constant term is split off from the linear part if the linear parts of
5851 the scheduling rows for all nodes in the graphs have a common non-trivial
5853 The constant term is then placed in a separate band and the linear
5856 =item * schedule_algorithm
5858 Selects the scheduling algorithm to be used.
5859 Available scheduling algorithms are C<ISL_SCHEDULE_ALGORITHM_ISL>
5860 and C<ISL_SCHEDULE_ALGORITHM_FEAUTRIER>.
5862 =item * schedule_separate_components
5864 If at any point the dependence graph contains any (weakly connected) components,
5865 then these components are scheduled separately.
5866 If this option is not set, then some iterations of the domains
5867 in these components may be scheduled together.
5868 If this option is set, then the components are given consecutive
5873 =head2 AST Generation
5875 This section describes the C<isl> functionality for generating
5876 ASTs that visit all the elements
5877 in a domain in an order specified by a schedule.
5878 In particular, given a C<isl_union_map>, an AST is generated
5879 that visits all the elements in the domain of the C<isl_union_map>
5880 according to the lexicographic order of the corresponding image
5881 element(s). If the range of the C<isl_union_map> consists of
5882 elements in more than one space, then each of these spaces is handled
5883 separately in an arbitrary order.
5884 It should be noted that the image elements only specify the I<order>
5885 in which the corresponding domain elements should be visited.
5886 No direct relation between the image elements and the loop iterators
5887 in the generated AST should be assumed.
5889 Each AST is generated within a build. The initial build
5890 simply specifies the constraints on the parameters (if any)
5891 and can be created, inspected, copied and freed using the following functions.
5893 #include <isl/ast_build.h>
5894 __isl_give isl_ast_build *isl_ast_build_from_context(
5895 __isl_take isl_set *set);
5896 isl_ctx *isl_ast_build_get_ctx(
5897 __isl_keep isl_ast_build *build);
5898 __isl_give isl_ast_build *isl_ast_build_copy(
5899 __isl_keep isl_ast_build *build);
5900 void *isl_ast_build_free(
5901 __isl_take isl_ast_build *build);
5903 The C<set> argument is usually a parameter set with zero or more parameters.
5904 More C<isl_ast_build> functions are described in L</"Nested AST Generation">
5905 and L</"Fine-grained Control over AST Generation">.
5906 Finally, the AST itself can be constructed using the following
5909 #include <isl/ast_build.h>
5910 __isl_give isl_ast_node *isl_ast_build_ast_from_schedule(
5911 __isl_keep isl_ast_build *build,
5912 __isl_take isl_union_map *schedule);
5914 =head3 Inspecting the AST
5916 The basic properties of an AST node can be obtained as follows.
5918 #include <isl/ast.h>
5919 isl_ctx *isl_ast_node_get_ctx(
5920 __isl_keep isl_ast_node *node);
5921 enum isl_ast_node_type isl_ast_node_get_type(
5922 __isl_keep isl_ast_node *node);
5924 The type of an AST node is one of
5925 C<isl_ast_node_for>,
5927 C<isl_ast_node_block> or
5928 C<isl_ast_node_user>.
5929 An C<isl_ast_node_for> represents a for node.
5930 An C<isl_ast_node_if> represents an if node.
5931 An C<isl_ast_node_block> represents a compound node.
5932 An C<isl_ast_node_user> represents an expression statement.
5933 An expression statement typically corresponds to a domain element, i.e.,
5934 one of the elements that is visited by the AST.
5936 Each type of node has its own additional properties.
5938 #include <isl/ast.h>
5939 __isl_give isl_ast_expr *isl_ast_node_for_get_iterator(
5940 __isl_keep isl_ast_node *node);
5941 __isl_give isl_ast_expr *isl_ast_node_for_get_init(
5942 __isl_keep isl_ast_node *node);
5943 __isl_give isl_ast_expr *isl_ast_node_for_get_cond(
5944 __isl_keep isl_ast_node *node);
5945 __isl_give isl_ast_expr *isl_ast_node_for_get_inc(
5946 __isl_keep isl_ast_node *node);
5947 __isl_give isl_ast_node *isl_ast_node_for_get_body(
5948 __isl_keep isl_ast_node *node);
5949 int isl_ast_node_for_is_degenerate(
5950 __isl_keep isl_ast_node *node);
5952 An C<isl_ast_for> is considered degenerate if it is known to execute
5955 #include <isl/ast.h>
5956 __isl_give isl_ast_expr *isl_ast_node_if_get_cond(
5957 __isl_keep isl_ast_node *node);
5958 __isl_give isl_ast_node *isl_ast_node_if_get_then(
5959 __isl_keep isl_ast_node *node);
5960 int isl_ast_node_if_has_else(
5961 __isl_keep isl_ast_node *node);
5962 __isl_give isl_ast_node *isl_ast_node_if_get_else(
5963 __isl_keep isl_ast_node *node);
5965 __isl_give isl_ast_node_list *
5966 isl_ast_node_block_get_children(
5967 __isl_keep isl_ast_node *node);
5969 __isl_give isl_ast_expr *isl_ast_node_user_get_expr(
5970 __isl_keep isl_ast_node *node);
5972 Each of the returned C<isl_ast_expr>s can in turn be inspected using
5973 the following functions.
5975 #include <isl/ast.h>
5976 isl_ctx *isl_ast_expr_get_ctx(
5977 __isl_keep isl_ast_expr *expr);
5978 enum isl_ast_expr_type isl_ast_expr_get_type(
5979 __isl_keep isl_ast_expr *expr);
5981 The type of an AST expression is one of
5983 C<isl_ast_expr_id> or
5984 C<isl_ast_expr_int>.
5985 An C<isl_ast_expr_op> represents the result of an operation.
5986 An C<isl_ast_expr_id> represents an identifier.
5987 An C<isl_ast_expr_int> represents an integer value.
5989 Each type of expression has its own additional properties.
5991 #include <isl/ast.h>
5992 enum isl_ast_op_type isl_ast_expr_get_op_type(
5993 __isl_keep isl_ast_expr *expr);
5994 int isl_ast_expr_get_op_n_arg(__isl_keep isl_ast_expr *expr);
5995 __isl_give isl_ast_expr *isl_ast_expr_get_op_arg(
5996 __isl_keep isl_ast_expr *expr, int pos);
5997 int isl_ast_node_foreach_ast_op_type(
5998 __isl_keep isl_ast_node *node,
5999 int (*fn)(enum isl_ast_op_type type, void *user),
6002 C<isl_ast_expr_get_op_type> returns the type of the operation
6003 performed. C<isl_ast_expr_get_op_n_arg> returns the number of
6004 arguments. C<isl_ast_expr_get_op_arg> returns the specified
6006 C<isl_ast_node_foreach_ast_op_type> calls C<fn> for each distinct
6007 C<isl_ast_op_type> that appears in C<node>.
6008 The operation type is one of the following.
6012 =item C<isl_ast_op_and>
6014 Logical I<and> of two arguments.
6015 Both arguments can be evaluated.
6017 =item C<isl_ast_op_and_then>
6019 Logical I<and> of two arguments.
6020 The second argument can only be evaluated if the first evaluates to true.
6022 =item C<isl_ast_op_or>
6024 Logical I<or> of two arguments.
6025 Both arguments can be evaluated.
6027 =item C<isl_ast_op_or_else>
6029 Logical I<or> of two arguments.
6030 The second argument can only be evaluated if the first evaluates to false.
6032 =item C<isl_ast_op_max>
6034 Maximum of two or more arguments.
6036 =item C<isl_ast_op_min>
6038 Minimum of two or more arguments.
6040 =item C<isl_ast_op_minus>
6044 =item C<isl_ast_op_add>
6046 Sum of two arguments.
6048 =item C<isl_ast_op_sub>
6050 Difference of two arguments.
6052 =item C<isl_ast_op_mul>
6054 Product of two arguments.
6056 =item C<isl_ast_op_div>
6058 Exact division. That is, the result is known to be an integer.
6060 =item C<isl_ast_op_fdiv_q>
6062 Result of integer division, rounded towards negative
6065 =item C<isl_ast_op_pdiv_q>
6067 Result of integer division, where dividend is known to be non-negative.
6069 =item C<isl_ast_op_pdiv_r>
6071 Remainder of integer division, where dividend is known to be non-negative.
6073 =item C<isl_ast_op_cond>
6075 Conditional operator defined on three arguments.
6076 If the first argument evaluates to true, then the result
6077 is equal to the second argument. Otherwise, the result
6078 is equal to the third argument.
6079 The second and third argument may only be evaluated if
6080 the first argument evaluates to true and false, respectively.
6081 Corresponds to C<a ? b : c> in C.
6083 =item C<isl_ast_op_select>
6085 Conditional operator defined on three arguments.
6086 If the first argument evaluates to true, then the result
6087 is equal to the second argument. Otherwise, the result
6088 is equal to the third argument.
6089 The second and third argument may be evaluated independently
6090 of the value of the first argument.
6091 Corresponds to C<a * b + (1 - a) * c> in C.
6093 =item C<isl_ast_op_eq>
6097 =item C<isl_ast_op_le>
6099 Less than or equal relation.
6101 =item C<isl_ast_op_lt>
6105 =item C<isl_ast_op_ge>
6107 Greater than or equal relation.
6109 =item C<isl_ast_op_gt>
6111 Greater than relation.
6113 =item C<isl_ast_op_call>
6116 The number of arguments of the C<isl_ast_expr> is one more than
6117 the number of arguments in the function call, the first argument
6118 representing the function being called.
6120 =item C<isl_ast_op_access>
6123 The number of arguments of the C<isl_ast_expr> is one more than
6124 the number of index expressions in the array access, the first argument
6125 representing the array being accessed.
6127 =item C<isl_ast_op_member>
6130 This operation has two arguments, a structure and the name of
6131 the member of the structure being accessed.
6135 #include <isl/ast.h>
6136 __isl_give isl_id *isl_ast_expr_get_id(
6137 __isl_keep isl_ast_expr *expr);
6139 Return the identifier represented by the AST expression.
6141 #include <isl/ast.h>
6142 __isl_give isl_val *isl_ast_expr_get_val(
6143 __isl_keep isl_ast_expr *expr);
6145 Return the integer represented by the AST expression.
6147 =head3 Properties of ASTs
6149 #include <isl/ast.h>
6150 int isl_ast_expr_is_equal(__isl_keep isl_ast_expr *expr1,
6151 __isl_keep isl_ast_expr *expr2);
6153 Check if two C<isl_ast_expr>s are equal to each other.
6155 =head3 Manipulating and printing the AST
6157 AST nodes can be copied and freed using the following functions.
6159 #include <isl/ast.h>
6160 __isl_give isl_ast_node *isl_ast_node_copy(
6161 __isl_keep isl_ast_node *node);
6162 void *isl_ast_node_free(__isl_take isl_ast_node *node);
6164 AST expressions can be copied and freed using the following functions.
6166 #include <isl/ast.h>
6167 __isl_give isl_ast_expr *isl_ast_expr_copy(
6168 __isl_keep isl_ast_expr *expr);
6169 void *isl_ast_expr_free(__isl_take isl_ast_expr *expr);
6171 New AST expressions can be created either directly or within
6172 the context of an C<isl_ast_build>.
6174 #include <isl/ast.h>
6175 __isl_give isl_ast_expr *isl_ast_expr_from_val(
6176 __isl_take isl_val *v);
6177 __isl_give isl_ast_expr *isl_ast_expr_from_id(
6178 __isl_take isl_id *id);
6179 __isl_give isl_ast_expr *isl_ast_expr_neg(
6180 __isl_take isl_ast_expr *expr);
6181 __isl_give isl_ast_expr *isl_ast_expr_add(
6182 __isl_take isl_ast_expr *expr1,
6183 __isl_take isl_ast_expr *expr2);
6184 __isl_give isl_ast_expr *isl_ast_expr_sub(
6185 __isl_take isl_ast_expr *expr1,
6186 __isl_take isl_ast_expr *expr2);
6187 __isl_give isl_ast_expr *isl_ast_expr_mul(
6188 __isl_take isl_ast_expr *expr1,
6189 __isl_take isl_ast_expr *expr2);
6190 __isl_give isl_ast_expr *isl_ast_expr_div(
6191 __isl_take isl_ast_expr *expr1,
6192 __isl_take isl_ast_expr *expr2);
6193 __isl_give isl_ast_expr *isl_ast_expr_and(
6194 __isl_take isl_ast_expr *expr1,
6195 __isl_take isl_ast_expr *expr2)
6196 __isl_give isl_ast_expr *isl_ast_expr_or(
6197 __isl_take isl_ast_expr *expr1,
6198 __isl_take isl_ast_expr *expr2)
6199 __isl_give isl_ast_expr *isl_ast_expr_access(
6200 __isl_take isl_ast_expr *array,
6201 __isl_take isl_ast_expr_list *indices);
6203 #include <isl/ast_build.h>
6204 __isl_give isl_ast_expr *isl_ast_build_expr_from_pw_aff(
6205 __isl_keep isl_ast_build *build,
6206 __isl_take isl_pw_aff *pa);
6207 __isl_give isl_ast_expr *
6208 isl_ast_build_access_from_pw_multi_aff(
6209 __isl_keep isl_ast_build *build,
6210 __isl_take isl_pw_multi_aff *pma);
6211 __isl_give isl_ast_expr *
6212 isl_ast_build_access_from_multi_pw_aff(
6213 __isl_keep isl_ast_build *build,
6214 __isl_take isl_multi_pw_aff *mpa);
6215 __isl_give isl_ast_expr *
6216 isl_ast_build_call_from_pw_multi_aff(
6217 __isl_keep isl_ast_build *build,
6218 __isl_take isl_pw_multi_aff *pma);
6219 __isl_give isl_ast_expr *
6220 isl_ast_build_call_from_multi_pw_aff(
6221 __isl_keep isl_ast_build *build,
6222 __isl_take isl_multi_pw_aff *mpa);
6224 The domains of C<pa>, C<mpa> and C<pma> should correspond
6225 to the schedule space of C<build>.
6226 The tuple id of C<mpa> or C<pma> is used as the array being accessed or
6227 the function being called.
6228 If the accessed space is a nested relation, then it is taken
6229 to represent an access of the member specified by the range
6230 of this nested relation of the structure specified by the domain
6231 of the nested relation.
6233 The following functions can be used to modify an C<isl_ast_expr>.
6235 #include <isl/ast.h>
6236 __isl_give isl_ast_expr *isl_ast_expr_set_op_arg(
6237 __isl_take isl_ast_expr *expr, int pos,
6238 __isl_take isl_ast_expr *arg);
6240 Replace the argument of C<expr> at position C<pos> by C<arg>.
6242 #include <isl/ast.h>
6243 __isl_give isl_ast_expr *isl_ast_expr_substitute_ids(
6244 __isl_take isl_ast_expr *expr,
6245 __isl_take isl_id_to_ast_expr *id2expr);
6247 The function C<isl_ast_expr_substitute_ids> replaces the
6248 subexpressions of C<expr> of type C<isl_ast_expr_id>
6249 by the corresponding expression in C<id2expr>, if there is any.
6252 User specified data can be attached to an C<isl_ast_node> and obtained
6253 from the same C<isl_ast_node> using the following functions.
6255 #include <isl/ast.h>
6256 __isl_give isl_ast_node *isl_ast_node_set_annotation(
6257 __isl_take isl_ast_node *node,
6258 __isl_take isl_id *annotation);
6259 __isl_give isl_id *isl_ast_node_get_annotation(
6260 __isl_keep isl_ast_node *node);
6262 Basic printing can be performed using the following functions.
6264 #include <isl/ast.h>
6265 __isl_give isl_printer *isl_printer_print_ast_expr(
6266 __isl_take isl_printer *p,
6267 __isl_keep isl_ast_expr *expr);
6268 __isl_give isl_printer *isl_printer_print_ast_node(
6269 __isl_take isl_printer *p,
6270 __isl_keep isl_ast_node *node);
6272 More advanced printing can be performed using the following functions.
6274 #include <isl/ast.h>
6275 __isl_give isl_printer *isl_ast_op_type_print_macro(
6276 enum isl_ast_op_type type,
6277 __isl_take isl_printer *p);
6278 __isl_give isl_printer *isl_ast_node_print_macros(
6279 __isl_keep isl_ast_node *node,
6280 __isl_take isl_printer *p);
6281 __isl_give isl_printer *isl_ast_node_print(
6282 __isl_keep isl_ast_node *node,
6283 __isl_take isl_printer *p,
6284 __isl_take isl_ast_print_options *options);
6285 __isl_give isl_printer *isl_ast_node_for_print(
6286 __isl_keep isl_ast_node *node,
6287 __isl_take isl_printer *p,
6288 __isl_take isl_ast_print_options *options);
6289 __isl_give isl_printer *isl_ast_node_if_print(
6290 __isl_keep isl_ast_node *node,
6291 __isl_take isl_printer *p,
6292 __isl_take isl_ast_print_options *options);
6294 While printing an C<isl_ast_node> in C<ISL_FORMAT_C>,
6295 C<isl> may print out an AST that makes use of macros such
6296 as C<floord>, C<min> and C<max>.
6297 C<isl_ast_op_type_print_macro> prints out the macro
6298 corresponding to a specific C<isl_ast_op_type>.
6299 C<isl_ast_node_print_macros> scans the C<isl_ast_node>
6300 for expressions where these macros would be used and prints
6301 out the required macro definitions.
6302 Essentially, C<isl_ast_node_print_macros> calls
6303 C<isl_ast_node_foreach_ast_op_type> with C<isl_ast_op_type_print_macro>
6304 as function argument.
6305 C<isl_ast_node_print>, C<isl_ast_node_for_print> and
6306 C<isl_ast_node_if_print> print an C<isl_ast_node>
6307 in C<ISL_FORMAT_C>, but allow for some extra control
6308 through an C<isl_ast_print_options> object.
6309 This object can be created using the following functions.
6311 #include <isl/ast.h>
6312 __isl_give isl_ast_print_options *
6313 isl_ast_print_options_alloc(isl_ctx *ctx);
6314 __isl_give isl_ast_print_options *
6315 isl_ast_print_options_copy(
6316 __isl_keep isl_ast_print_options *options);
6317 void *isl_ast_print_options_free(
6318 __isl_take isl_ast_print_options *options);
6320 __isl_give isl_ast_print_options *
6321 isl_ast_print_options_set_print_user(
6322 __isl_take isl_ast_print_options *options,
6323 __isl_give isl_printer *(*print_user)(
6324 __isl_take isl_printer *p,
6325 __isl_take isl_ast_print_options *options,
6326 __isl_keep isl_ast_node *node, void *user),
6328 __isl_give isl_ast_print_options *
6329 isl_ast_print_options_set_print_for(
6330 __isl_take isl_ast_print_options *options,
6331 __isl_give isl_printer *(*print_for)(
6332 __isl_take isl_printer *p,
6333 __isl_take isl_ast_print_options *options,
6334 __isl_keep isl_ast_node *node, void *user),
6337 The callback set by C<isl_ast_print_options_set_print_user>
6338 is called whenever a node of type C<isl_ast_node_user> needs to
6340 The callback set by C<isl_ast_print_options_set_print_for>
6341 is called whenever a node of type C<isl_ast_node_for> needs to
6343 Note that C<isl_ast_node_for_print> will I<not> call the
6344 callback set by C<isl_ast_print_options_set_print_for> on the node
6345 on which C<isl_ast_node_for_print> is called, but only on nested
6346 nodes of type C<isl_ast_node_for>. It is therefore safe to
6347 call C<isl_ast_node_for_print> from within the callback set by
6348 C<isl_ast_print_options_set_print_for>.
6350 The following option determines the type to be used for iterators
6351 while printing the AST.
6353 int isl_options_set_ast_iterator_type(
6354 isl_ctx *ctx, const char *val);
6355 const char *isl_options_get_ast_iterator_type(
6360 #include <isl/ast_build.h>
6361 int isl_options_set_ast_build_atomic_upper_bound(
6362 isl_ctx *ctx, int val);
6363 int isl_options_get_ast_build_atomic_upper_bound(
6365 int isl_options_set_ast_build_prefer_pdiv(isl_ctx *ctx,
6367 int isl_options_get_ast_build_prefer_pdiv(isl_ctx *ctx);
6368 int isl_options_set_ast_build_exploit_nested_bounds(
6369 isl_ctx *ctx, int val);
6370 int isl_options_get_ast_build_exploit_nested_bounds(
6372 int isl_options_set_ast_build_group_coscheduled(
6373 isl_ctx *ctx, int val);
6374 int isl_options_get_ast_build_group_coscheduled(
6376 int isl_options_set_ast_build_scale_strides(
6377 isl_ctx *ctx, int val);
6378 int isl_options_get_ast_build_scale_strides(
6380 int isl_options_set_ast_build_allow_else(isl_ctx *ctx,
6382 int isl_options_get_ast_build_allow_else(isl_ctx *ctx);
6383 int isl_options_set_ast_build_allow_or(isl_ctx *ctx,
6385 int isl_options_get_ast_build_allow_or(isl_ctx *ctx);
6389 =item * ast_build_atomic_upper_bound
6391 Generate loop upper bounds that consist of the current loop iterator,
6392 an operator and an expression not involving the iterator.
6393 If this option is not set, then the current loop iterator may appear
6394 several times in the upper bound.
6395 For example, when this option is turned off, AST generation
6398 [n] -> { A[i] -> [i] : 0 <= i <= 100, n }
6402 for (int c0 = 0; c0 <= 100 && n >= c0; c0 += 1)
6405 When the option is turned on, the following AST is generated
6407 for (int c0 = 0; c0 <= min(100, n); c0 += 1)
6410 =item * ast_build_prefer_pdiv
6412 If this option is turned off, then the AST generation will
6413 produce ASTs that may only contain C<isl_ast_op_fdiv_q>
6414 operators, but no C<isl_ast_op_pdiv_q> or
6415 C<isl_ast_op_pdiv_r> operators.
6416 If this options is turned on, then C<isl> will try to convert
6417 some of the C<isl_ast_op_fdiv_q> operators to (expressions containing)
6418 C<isl_ast_op_pdiv_q> or C<isl_ast_op_pdiv_r> operators.
6420 =item * ast_build_exploit_nested_bounds
6422 Simplify conditions based on bounds of nested for loops.
6423 In particular, remove conditions that are implied by the fact
6424 that one or more nested loops have at least one iteration,
6425 meaning that the upper bound is at least as large as the lower bound.
6426 For example, when this option is turned off, AST generation
6429 [N,M] -> { A[i,j] -> [i,j] : 0 <= i <= N and
6435 for (int c0 = 0; c0 <= N; c0 += 1)
6436 for (int c1 = 0; c1 <= M; c1 += 1)
6439 When the option is turned on, the following AST is generated
6441 for (int c0 = 0; c0 <= N; c0 += 1)
6442 for (int c1 = 0; c1 <= M; c1 += 1)
6445 =item * ast_build_group_coscheduled
6447 If two domain elements are assigned the same schedule point, then
6448 they may be executed in any order and they may even appear in different
6449 loops. If this options is set, then the AST generator will make
6450 sure that coscheduled domain elements do not appear in separate parts
6451 of the AST. This is useful in case of nested AST generation
6452 if the outer AST generation is given only part of a schedule
6453 and the inner AST generation should handle the domains that are
6454 coscheduled by this initial part of the schedule together.
6455 For example if an AST is generated for a schedule
6457 { A[i] -> [0]; B[i] -> [0] }
6459 then the C<isl_ast_build_set_create_leaf> callback described
6460 below may get called twice, once for each domain.
6461 Setting this option ensures that the callback is only called once
6462 on both domains together.
6464 =item * ast_build_separation_bounds
6466 This option specifies which bounds to use during separation.
6467 If this option is set to C<ISL_AST_BUILD_SEPARATION_BOUNDS_IMPLICIT>
6468 then all (possibly implicit) bounds on the current dimension will
6469 be used during separation.
6470 If this option is set to C<ISL_AST_BUILD_SEPARATION_BOUNDS_EXPLICIT>
6471 then only those bounds that are explicitly available will
6472 be used during separation.
6474 =item * ast_build_scale_strides
6476 This option specifies whether the AST generator is allowed
6477 to scale down iterators of strided loops.
6479 =item * ast_build_allow_else
6481 This option specifies whether the AST generator is allowed
6482 to construct if statements with else branches.
6484 =item * ast_build_allow_or
6486 This option specifies whether the AST generator is allowed
6487 to construct if conditions with disjunctions.
6491 =head3 Fine-grained Control over AST Generation
6493 Besides specifying the constraints on the parameters,
6494 an C<isl_ast_build> object can be used to control
6495 various aspects of the AST generation process.
6496 The most prominent way of control is through ``options'',
6497 which can be set using the following function.
6499 #include <isl/ast_build.h>
6500 __isl_give isl_ast_build *
6501 isl_ast_build_set_options(
6502 __isl_take isl_ast_build *control,
6503 __isl_take isl_union_map *options);
6505 The options are encoded in an <isl_union_map>.
6506 The domain of this union relation refers to the schedule domain,
6507 i.e., the range of the schedule passed to C<isl_ast_build_ast_from_schedule>.
6508 In the case of nested AST generation (see L</"Nested AST Generation">),
6509 the domain of C<options> should refer to the extra piece of the schedule.
6510 That is, it should be equal to the range of the wrapped relation in the
6511 range of the schedule.
6512 The range of the options can consist of elements in one or more spaces,
6513 the names of which determine the effect of the option.
6514 The values of the range typically also refer to the schedule dimension
6515 to which the option applies. In case of nested AST generation
6516 (see L</"Nested AST Generation">), these values refer to the position
6517 of the schedule dimension within the innermost AST generation.
6518 The constraints on the domain elements of
6519 the option should only refer to this dimension and earlier dimensions.
6520 We consider the following spaces.
6524 =item C<separation_class>
6526 This space is a wrapped relation between two one dimensional spaces.
6527 The input space represents the schedule dimension to which the option
6528 applies and the output space represents the separation class.
6529 While constructing a loop corresponding to the specified schedule
6530 dimension(s), the AST generator will try to generate separate loops
6531 for domain elements that are assigned different classes.
6532 If only some of the elements are assigned a class, then those elements
6533 that are not assigned any class will be treated as belonging to a class
6534 that is separate from the explicitly assigned classes.
6535 The typical use case for this option is to separate full tiles from
6537 The other options, described below, are applied after the separation
6540 As an example, consider the separation into full and partial tiles
6541 of a tiling of a triangular domain.
6542 Take, for example, the domain
6544 { A[i,j] : 0 <= i,j and i + j <= 100 }
6546 and a tiling into tiles of 10 by 10. The input to the AST generator
6547 is then the schedule
6549 { A[i,j] -> [([i/10]),[j/10],i,j] : 0 <= i,j and
6552 Without any options, the following AST is generated
6554 for (int c0 = 0; c0 <= 10; c0 += 1)
6555 for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
6556 for (int c2 = 10 * c0;
6557 c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
6559 for (int c3 = 10 * c1;
6560 c3 <= min(10 * c1 + 9, -c2 + 100);
6564 Separation into full and partial tiles can be obtained by assigning
6565 a class, say C<0>, to the full tiles. The full tiles are represented by those
6566 values of the first and second schedule dimensions for which there are
6567 values of the third and fourth dimensions to cover an entire tile.
6568 That is, we need to specify the following option
6570 { [a,b,c,d] -> separation_class[[0]->[0]] :
6571 exists b': 0 <= 10a,10b' and
6572 10a+9+10b'+9 <= 100;
6573 [a,b,c,d] -> separation_class[[1]->[0]] :
6574 0 <= 10a,10b and 10a+9+10b+9 <= 100 }
6578 { [a, b, c, d] -> separation_class[[1] -> [0]] :
6579 a >= 0 and b >= 0 and b <= 8 - a;
6580 [a, b, c, d] -> separation_class[[0] -> [0]] :
6583 With this option, the generated AST is as follows
6586 for (int c0 = 0; c0 <= 8; c0 += 1) {
6587 for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
6588 for (int c2 = 10 * c0;
6589 c2 <= 10 * c0 + 9; c2 += 1)
6590 for (int c3 = 10 * c1;
6591 c3 <= 10 * c1 + 9; c3 += 1)
6593 for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
6594 for (int c2 = 10 * c0;
6595 c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
6597 for (int c3 = 10 * c1;
6598 c3 <= min(-c2 + 100, 10 * c1 + 9);
6602 for (int c0 = 9; c0 <= 10; c0 += 1)
6603 for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
6604 for (int c2 = 10 * c0;
6605 c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
6607 for (int c3 = 10 * c1;
6608 c3 <= min(10 * c1 + 9, -c2 + 100);
6615 This is a single-dimensional space representing the schedule dimension(s)
6616 to which ``separation'' should be applied. Separation tries to split
6617 a loop into several pieces if this can avoid the generation of guards
6619 See also the C<atomic> option.
6623 This is a single-dimensional space representing the schedule dimension(s)
6624 for which the domains should be considered ``atomic''. That is, the
6625 AST generator will make sure that any given domain space will only appear
6626 in a single loop at the specified level.
6628 Consider the following schedule
6630 { a[i] -> [i] : 0 <= i < 10;
6631 b[i] -> [i+1] : 0 <= i < 10 }
6633 If the following option is specified
6635 { [i] -> separate[x] }
6637 then the following AST will be generated
6641 for (int c0 = 1; c0 <= 9; c0 += 1) {
6648 If, on the other hand, the following option is specified
6650 { [i] -> atomic[x] }
6652 then the following AST will be generated
6654 for (int c0 = 0; c0 <= 10; c0 += 1) {
6661 If neither C<atomic> nor C<separate> is specified, then the AST generator
6662 may produce either of these two results or some intermediate form.
6666 This is a single-dimensional space representing the schedule dimension(s)
6667 that should be I<completely> unrolled.
6668 To obtain a partial unrolling, the user should apply an additional
6669 strip-mining to the schedule and fully unroll the inner loop.
6673 Additional control is available through the following functions.
6675 #include <isl/ast_build.h>
6676 __isl_give isl_ast_build *
6677 isl_ast_build_set_iterators(
6678 __isl_take isl_ast_build *control,
6679 __isl_take isl_id_list *iterators);
6681 The function C<isl_ast_build_set_iterators> allows the user to
6682 specify a list of iterator C<isl_id>s to be used as iterators.
6683 If the input schedule is injective, then
6684 the number of elements in this list should be as large as the dimension
6685 of the schedule space, but no direct correspondence should be assumed
6686 between dimensions and elements.
6687 If the input schedule is not injective, then an additional number
6688 of C<isl_id>s equal to the largest dimension of the input domains
6690 If the number of provided C<isl_id>s is insufficient, then additional
6691 names are automatically generated.
6693 #include <isl/ast_build.h>
6694 __isl_give isl_ast_build *
6695 isl_ast_build_set_create_leaf(
6696 __isl_take isl_ast_build *control,
6697 __isl_give isl_ast_node *(*fn)(
6698 __isl_take isl_ast_build *build,
6699 void *user), void *user);
6702 C<isl_ast_build_set_create_leaf> function allows for the
6703 specification of a callback that should be called whenever the AST
6704 generator arrives at an element of the schedule domain.
6705 The callback should return an AST node that should be inserted
6706 at the corresponding position of the AST. The default action (when
6707 the callback is not set) is to continue generating parts of the AST to scan
6708 all the domain elements associated to the schedule domain element
6709 and to insert user nodes, ``calling'' the domain element, for each of them.
6710 The C<build> argument contains the current state of the C<isl_ast_build>.
6711 To ease nested AST generation (see L</"Nested AST Generation">),
6712 all control information that is
6713 specific to the current AST generation such as the options and
6714 the callbacks has been removed from this C<isl_ast_build>.
6715 The callback would typically return the result of a nested
6717 user defined node created using the following function.
6719 #include <isl/ast.h>
6720 __isl_give isl_ast_node *isl_ast_node_alloc_user(
6721 __isl_take isl_ast_expr *expr);
6723 #include <isl/ast_build.h>
6724 __isl_give isl_ast_build *
6725 isl_ast_build_set_at_each_domain(
6726 __isl_take isl_ast_build *build,
6727 __isl_give isl_ast_node *(*fn)(
6728 __isl_take isl_ast_node *node,
6729 __isl_keep isl_ast_build *build,
6730 void *user), void *user);
6731 __isl_give isl_ast_build *
6732 isl_ast_build_set_before_each_for(
6733 __isl_take isl_ast_build *build,
6734 __isl_give isl_id *(*fn)(
6735 __isl_keep isl_ast_build *build,
6736 void *user), void *user);
6737 __isl_give isl_ast_build *
6738 isl_ast_build_set_after_each_for(
6739 __isl_take isl_ast_build *build,
6740 __isl_give isl_ast_node *(*fn)(
6741 __isl_take isl_ast_node *node,
6742 __isl_keep isl_ast_build *build,
6743 void *user), void *user);
6745 The callback set by C<isl_ast_build_set_at_each_domain> will
6746 be called for each domain AST node.
6747 The callbacks set by C<isl_ast_build_set_before_each_for>
6748 and C<isl_ast_build_set_after_each_for> will be called
6749 for each for AST node. The first will be called in depth-first
6750 pre-order, while the second will be called in depth-first post-order.
6751 Since C<isl_ast_build_set_before_each_for> is called before the for
6752 node is actually constructed, it is only passed an C<isl_ast_build>.
6753 The returned C<isl_id> will be added as an annotation (using
6754 C<isl_ast_node_set_annotation>) to the constructed for node.
6755 In particular, if the user has also specified an C<after_each_for>
6756 callback, then the annotation can be retrieved from the node passed to
6757 that callback using C<isl_ast_node_get_annotation>.
6758 All callbacks should C<NULL> on failure.
6759 The given C<isl_ast_build> can be used to create new
6760 C<isl_ast_expr> objects using C<isl_ast_build_expr_from_pw_aff>
6761 or C<isl_ast_build_call_from_pw_multi_aff>.
6763 =head3 Nested AST Generation
6765 C<isl> allows the user to create an AST within the context
6766 of another AST. These nested ASTs are created using the
6767 same C<isl_ast_build_ast_from_schedule> function that is used to create the
6768 outer AST. The C<build> argument should be an C<isl_ast_build>
6769 passed to a callback set by
6770 C<isl_ast_build_set_create_leaf>.
6771 The space of the range of the C<schedule> argument should refer
6772 to this build. In particular, the space should be a wrapped
6773 relation and the domain of this wrapped relation should be the
6774 same as that of the range of the schedule returned by
6775 C<isl_ast_build_get_schedule> below.
6776 In practice, the new schedule is typically
6777 created by calling C<isl_union_map_range_product> on the old schedule
6778 and some extra piece of the schedule.
6779 The space of the schedule domain is also available from
6780 the C<isl_ast_build>.
6782 #include <isl/ast_build.h>
6783 __isl_give isl_union_map *isl_ast_build_get_schedule(
6784 __isl_keep isl_ast_build *build);
6785 __isl_give isl_space *isl_ast_build_get_schedule_space(
6786 __isl_keep isl_ast_build *build);
6787 __isl_give isl_ast_build *isl_ast_build_restrict(
6788 __isl_take isl_ast_build *build,
6789 __isl_take isl_set *set);
6791 The C<isl_ast_build_get_schedule> function returns a (partial)
6792 schedule for the domains elements for which part of the AST still needs to
6793 be generated in the current build.
6794 In particular, the domain elements are mapped to those iterations of the loops
6795 enclosing the current point of the AST generation inside which
6796 the domain elements are executed.
6797 No direct correspondence between
6798 the input schedule and this schedule should be assumed.
6799 The space obtained from C<isl_ast_build_get_schedule_space> can be used
6800 to create a set for C<isl_ast_build_restrict> to intersect
6801 with the current build. In particular, the set passed to
6802 C<isl_ast_build_restrict> can have additional parameters.
6803 The ids of the set dimensions in the space returned by
6804 C<isl_ast_build_get_schedule_space> correspond to the
6805 iterators of the already generated loops.
6806 The user should not rely on the ids of the output dimensions
6807 of the relations in the union relation returned by
6808 C<isl_ast_build_get_schedule> having any particular value.
6812 Although C<isl> is mainly meant to be used as a library,
6813 it also contains some basic applications that use some
6814 of the functionality of C<isl>.
6815 The input may be specified in either the L<isl format>
6816 or the L<PolyLib format>.
6818 =head2 C<isl_polyhedron_sample>
6820 C<isl_polyhedron_sample> takes a polyhedron as input and prints
6821 an integer element of the polyhedron, if there is any.
6822 The first column in the output is the denominator and is always
6823 equal to 1. If the polyhedron contains no integer points,
6824 then a vector of length zero is printed.
6828 C<isl_pip> takes the same input as the C<example> program
6829 from the C<piplib> distribution, i.e., a set of constraints
6830 on the parameters, a line containing only -1 and finally a set
6831 of constraints on a parametric polyhedron.
6832 The coefficients of the parameters appear in the last columns
6833 (but before the final constant column).
6834 The output is the lexicographic minimum of the parametric polyhedron.
6835 As C<isl> currently does not have its own output format, the output
6836 is just a dump of the internal state.
6838 =head2 C<isl_polyhedron_minimize>
6840 C<isl_polyhedron_minimize> computes the minimum of some linear
6841 or affine objective function over the integer points in a polyhedron.
6842 If an affine objective function
6843 is given, then the constant should appear in the last column.
6845 =head2 C<isl_polytope_scan>
6847 Given a polytope, C<isl_polytope_scan> prints
6848 all integer points in the polytope.
6850 =head2 C<isl_codegen>
6852 Given a schedule, a context set and an options relation,
6853 C<isl_codegen> prints out an AST that scans the domain elements
6854 of the schedule in the order of their image(s) taking into account
6855 the constraints in the context set.