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 Spaces can be nested. In particular, the domain of a set or
902 the domain or range of a relation can be a nested relation.
903 The following functions can be used to construct and deconstruct
906 #include <isl/space.h>
907 int isl_space_is_wrapping(__isl_keep isl_space *space);
908 __isl_give isl_space *isl_space_wrap(__isl_take isl_space *space);
909 __isl_give isl_space *isl_space_unwrap(__isl_take isl_space *space);
911 The input to C<isl_space_is_wrapping> and C<isl_space_unwrap> should
912 be the space of a set, while that of
913 C<isl_space_wrap> should be the space of a relation.
914 Conversely, the output of C<isl_space_unwrap> is the space
915 of a relation, while that of C<isl_space_wrap> is the space of a set.
917 Spaces can be created from other spaces
918 using the following functions.
920 __isl_give isl_space *isl_space_domain(__isl_take isl_space *space);
921 __isl_give isl_space *isl_space_from_domain(__isl_take isl_space *space);
922 __isl_give isl_space *isl_space_range(__isl_take isl_space *space);
923 __isl_give isl_space *isl_space_from_range(__isl_take isl_space *space);
924 __isl_give isl_space *isl_space_domain_map(
925 __isl_take isl_space *space);
926 __isl_give isl_space *isl_space_params(
927 __isl_take isl_space *space);
928 __isl_give isl_space *isl_space_set_from_params(
929 __isl_take isl_space *space);
930 __isl_give isl_space *isl_space_reverse(__isl_take isl_space *space);
931 __isl_give isl_space *isl_space_join(__isl_take isl_space *left,
932 __isl_take isl_space *right);
933 __isl_give isl_space *isl_space_align_params(
934 __isl_take isl_space *space1, __isl_take isl_space *space2)
935 __isl_give isl_space *isl_space_insert_dims(__isl_take isl_space *space,
936 enum isl_dim_type type, unsigned pos, unsigned n);
937 __isl_give isl_space *isl_space_add_dims(__isl_take isl_space *space,
938 enum isl_dim_type type, unsigned n);
939 __isl_give isl_space *isl_space_drop_dims(__isl_take isl_space *space,
940 enum isl_dim_type type, unsigned first, unsigned n);
941 __isl_give isl_space *isl_space_move_dims(__isl_take isl_space *space,
942 enum isl_dim_type dst_type, unsigned dst_pos,
943 enum isl_dim_type src_type, unsigned src_pos,
945 __isl_give isl_space *isl_space_map_from_set(
946 __isl_take isl_space *space);
947 __isl_give isl_space *isl_space_map_from_domain_and_range(
948 __isl_take isl_space *domain,
949 __isl_take isl_space *range);
950 __isl_give isl_space *isl_space_zip(__isl_take isl_space *space);
951 __isl_give isl_space *isl_space_curry(
952 __isl_take isl_space *space);
953 __isl_give isl_space *isl_space_uncurry(
954 __isl_take isl_space *space);
956 Note that if dimensions are added or removed from a space, then
957 the name and the internal structure are lost.
961 A local space is essentially a space with
962 zero or more existentially quantified variables.
963 The local space of a (constraint of a) basic set or relation can be obtained
964 using the following functions.
966 #include <isl/constraint.h>
967 __isl_give isl_local_space *isl_constraint_get_local_space(
968 __isl_keep isl_constraint *constraint);
971 __isl_give isl_local_space *isl_basic_set_get_local_space(
972 __isl_keep isl_basic_set *bset);
975 __isl_give isl_local_space *isl_basic_map_get_local_space(
976 __isl_keep isl_basic_map *bmap);
978 A new local space can be created from a space using
980 #include <isl/local_space.h>
981 __isl_give isl_local_space *isl_local_space_from_space(
982 __isl_take isl_space *space);
984 They can be inspected, modified, copied and freed using the following functions.
986 #include <isl/local_space.h>
987 isl_ctx *isl_local_space_get_ctx(
988 __isl_keep isl_local_space *ls);
989 int isl_local_space_is_set(__isl_keep isl_local_space *ls);
990 int isl_local_space_dim(__isl_keep isl_local_space *ls,
991 enum isl_dim_type type);
992 int isl_local_space_has_dim_id(
993 __isl_keep isl_local_space *ls,
994 enum isl_dim_type type, unsigned pos);
995 __isl_give isl_id *isl_local_space_get_dim_id(
996 __isl_keep isl_local_space *ls,
997 enum isl_dim_type type, unsigned pos);
998 int isl_local_space_has_dim_name(
999 __isl_keep isl_local_space *ls,
1000 enum isl_dim_type type, unsigned pos)
1001 const char *isl_local_space_get_dim_name(
1002 __isl_keep isl_local_space *ls,
1003 enum isl_dim_type type, unsigned pos);
1004 __isl_give isl_local_space *isl_local_space_set_dim_name(
1005 __isl_take isl_local_space *ls,
1006 enum isl_dim_type type, unsigned pos, const char *s);
1007 __isl_give isl_local_space *isl_local_space_set_dim_id(
1008 __isl_take isl_local_space *ls,
1009 enum isl_dim_type type, unsigned pos,
1010 __isl_take isl_id *id);
1011 __isl_give isl_space *isl_local_space_get_space(
1012 __isl_keep isl_local_space *ls);
1013 __isl_give isl_aff *isl_local_space_get_div(
1014 __isl_keep isl_local_space *ls, int pos);
1015 __isl_give isl_local_space *isl_local_space_copy(
1016 __isl_keep isl_local_space *ls);
1017 void *isl_local_space_free(__isl_take isl_local_space *ls);
1019 Note that C<isl_local_space_get_div> can only be used on local spaces
1022 Two local spaces can be compared using
1024 int isl_local_space_is_equal(__isl_keep isl_local_space *ls1,
1025 __isl_keep isl_local_space *ls2);
1027 Local spaces can be created from other local spaces
1028 using the following functions.
1030 __isl_give isl_local_space *isl_local_space_domain(
1031 __isl_take isl_local_space *ls);
1032 __isl_give isl_local_space *isl_local_space_range(
1033 __isl_take isl_local_space *ls);
1034 __isl_give isl_local_space *isl_local_space_from_domain(
1035 __isl_take isl_local_space *ls);
1036 __isl_give isl_local_space *isl_local_space_intersect(
1037 __isl_take isl_local_space *ls1,
1038 __isl_take isl_local_space *ls2);
1039 __isl_give isl_local_space *isl_local_space_add_dims(
1040 __isl_take isl_local_space *ls,
1041 enum isl_dim_type type, unsigned n);
1042 __isl_give isl_local_space *isl_local_space_insert_dims(
1043 __isl_take isl_local_space *ls,
1044 enum isl_dim_type type, unsigned first, unsigned n);
1045 __isl_give isl_local_space *isl_local_space_drop_dims(
1046 __isl_take isl_local_space *ls,
1047 enum isl_dim_type type, unsigned first, unsigned n);
1049 =head2 Input and Output
1051 C<isl> supports its own input/output format, which is similar
1052 to the C<Omega> format, but also supports the C<PolyLib> format
1055 =head3 C<isl> format
1057 The C<isl> format is similar to that of C<Omega>, but has a different
1058 syntax for describing the parameters and allows for the definition
1059 of an existentially quantified variable as the integer division
1060 of an affine expression.
1061 For example, the set of integers C<i> between C<0> and C<n>
1062 such that C<i % 10 <= 6> can be described as
1064 [n] -> { [i] : exists (a = [i/10] : 0 <= i and i <= n and
1067 A set or relation can have several disjuncts, separated
1068 by the keyword C<or>. Each disjunct is either a conjunction
1069 of constraints or a projection (C<exists>) of a conjunction
1070 of constraints. The constraints are separated by the keyword
1073 =head3 C<PolyLib> format
1075 If the represented set is a union, then the first line
1076 contains a single number representing the number of disjuncts.
1077 Otherwise, a line containing the number C<1> is optional.
1079 Each disjunct is represented by a matrix of constraints.
1080 The first line contains two numbers representing
1081 the number of rows and columns,
1082 where the number of rows is equal to the number of constraints
1083 and the number of columns is equal to two plus the number of variables.
1084 The following lines contain the actual rows of the constraint matrix.
1085 In each row, the first column indicates whether the constraint
1086 is an equality (C<0>) or inequality (C<1>). The final column
1087 corresponds to the constant term.
1089 If the set is parametric, then the coefficients of the parameters
1090 appear in the last columns before the constant column.
1091 The coefficients of any existentially quantified variables appear
1092 between those of the set variables and those of the parameters.
1094 =head3 Extended C<PolyLib> format
1096 The extended C<PolyLib> format is nearly identical to the
1097 C<PolyLib> format. The only difference is that the line
1098 containing the number of rows and columns of a constraint matrix
1099 also contains four additional numbers:
1100 the number of output dimensions, the number of input dimensions,
1101 the number of local dimensions (i.e., the number of existentially
1102 quantified variables) and the number of parameters.
1103 For sets, the number of ``output'' dimensions is equal
1104 to the number of set dimensions, while the number of ``input''
1109 #include <isl/set.h>
1110 __isl_give isl_basic_set *isl_basic_set_read_from_file(
1111 isl_ctx *ctx, FILE *input);
1112 __isl_give isl_basic_set *isl_basic_set_read_from_str(
1113 isl_ctx *ctx, const char *str);
1114 __isl_give isl_set *isl_set_read_from_file(isl_ctx *ctx,
1116 __isl_give isl_set *isl_set_read_from_str(isl_ctx *ctx,
1119 #include <isl/map.h>
1120 __isl_give isl_basic_map *isl_basic_map_read_from_file(
1121 isl_ctx *ctx, FILE *input);
1122 __isl_give isl_basic_map *isl_basic_map_read_from_str(
1123 isl_ctx *ctx, const char *str);
1124 __isl_give isl_map *isl_map_read_from_file(
1125 isl_ctx *ctx, FILE *input);
1126 __isl_give isl_map *isl_map_read_from_str(isl_ctx *ctx,
1129 #include <isl/union_set.h>
1130 __isl_give isl_union_set *isl_union_set_read_from_file(
1131 isl_ctx *ctx, FILE *input);
1132 __isl_give isl_union_set *isl_union_set_read_from_str(
1133 isl_ctx *ctx, const char *str);
1135 #include <isl/union_map.h>
1136 __isl_give isl_union_map *isl_union_map_read_from_file(
1137 isl_ctx *ctx, FILE *input);
1138 __isl_give isl_union_map *isl_union_map_read_from_str(
1139 isl_ctx *ctx, const char *str);
1141 The input format is autodetected and may be either the C<PolyLib> format
1142 or the C<isl> format.
1146 Before anything can be printed, an C<isl_printer> needs to
1149 __isl_give isl_printer *isl_printer_to_file(isl_ctx *ctx,
1151 __isl_give isl_printer *isl_printer_to_str(isl_ctx *ctx);
1152 void *isl_printer_free(__isl_take isl_printer *printer);
1153 __isl_give char *isl_printer_get_str(
1154 __isl_keep isl_printer *printer);
1156 The printer can be inspected using the following functions.
1158 FILE *isl_printer_get_file(
1159 __isl_keep isl_printer *printer);
1160 int isl_printer_get_output_format(
1161 __isl_keep isl_printer *p);
1163 The behavior of the printer can be modified in various ways
1165 __isl_give isl_printer *isl_printer_set_output_format(
1166 __isl_take isl_printer *p, int output_format);
1167 __isl_give isl_printer *isl_printer_set_indent(
1168 __isl_take isl_printer *p, int indent);
1169 __isl_give isl_printer *isl_printer_indent(
1170 __isl_take isl_printer *p, int indent);
1171 __isl_give isl_printer *isl_printer_set_prefix(
1172 __isl_take isl_printer *p, const char *prefix);
1173 __isl_give isl_printer *isl_printer_set_suffix(
1174 __isl_take isl_printer *p, const char *suffix);
1176 The C<output_format> may be either C<ISL_FORMAT_ISL>, C<ISL_FORMAT_OMEGA>,
1177 C<ISL_FORMAT_POLYLIB>, C<ISL_FORMAT_EXT_POLYLIB> or C<ISL_FORMAT_LATEX>
1178 and defaults to C<ISL_FORMAT_ISL>.
1179 Each line in the output is indented by C<indent> (set by
1180 C<isl_printer_set_indent>) spaces
1181 (default: 0), prefixed by C<prefix> and suffixed by C<suffix>.
1182 In the C<PolyLib> format output,
1183 the coefficients of the existentially quantified variables
1184 appear between those of the set variables and those
1186 The function C<isl_printer_indent> increases the indentation
1187 by the specified amount (which may be negative).
1189 To actually print something, use
1191 #include <isl/printer.h>
1192 __isl_give isl_printer *isl_printer_print_double(
1193 __isl_take isl_printer *p, double d);
1195 #include <isl/set.h>
1196 __isl_give isl_printer *isl_printer_print_basic_set(
1197 __isl_take isl_printer *printer,
1198 __isl_keep isl_basic_set *bset);
1199 __isl_give isl_printer *isl_printer_print_set(
1200 __isl_take isl_printer *printer,
1201 __isl_keep isl_set *set);
1203 #include <isl/map.h>
1204 __isl_give isl_printer *isl_printer_print_basic_map(
1205 __isl_take isl_printer *printer,
1206 __isl_keep isl_basic_map *bmap);
1207 __isl_give isl_printer *isl_printer_print_map(
1208 __isl_take isl_printer *printer,
1209 __isl_keep isl_map *map);
1211 #include <isl/union_set.h>
1212 __isl_give isl_printer *isl_printer_print_union_set(
1213 __isl_take isl_printer *p,
1214 __isl_keep isl_union_set *uset);
1216 #include <isl/union_map.h>
1217 __isl_give isl_printer *isl_printer_print_union_map(
1218 __isl_take isl_printer *p,
1219 __isl_keep isl_union_map *umap);
1221 When called on a file printer, the following function flushes
1222 the file. When called on a string printer, the buffer is cleared.
1224 __isl_give isl_printer *isl_printer_flush(
1225 __isl_take isl_printer *p);
1227 =head2 Creating New Sets and Relations
1229 C<isl> has functions for creating some standard sets and relations.
1233 =item * Empty sets and relations
1235 __isl_give isl_basic_set *isl_basic_set_empty(
1236 __isl_take isl_space *space);
1237 __isl_give isl_basic_map *isl_basic_map_empty(
1238 __isl_take isl_space *space);
1239 __isl_give isl_set *isl_set_empty(
1240 __isl_take isl_space *space);
1241 __isl_give isl_map *isl_map_empty(
1242 __isl_take isl_space *space);
1243 __isl_give isl_union_set *isl_union_set_empty(
1244 __isl_take isl_space *space);
1245 __isl_give isl_union_map *isl_union_map_empty(
1246 __isl_take isl_space *space);
1248 For C<isl_union_set>s and C<isl_union_map>s, the space
1249 is only used to specify the parameters.
1251 =item * Universe sets and relations
1253 __isl_give isl_basic_set *isl_basic_set_universe(
1254 __isl_take isl_space *space);
1255 __isl_give isl_basic_map *isl_basic_map_universe(
1256 __isl_take isl_space *space);
1257 __isl_give isl_set *isl_set_universe(
1258 __isl_take isl_space *space);
1259 __isl_give isl_map *isl_map_universe(
1260 __isl_take isl_space *space);
1261 __isl_give isl_union_set *isl_union_set_universe(
1262 __isl_take isl_union_set *uset);
1263 __isl_give isl_union_map *isl_union_map_universe(
1264 __isl_take isl_union_map *umap);
1266 The sets and relations constructed by the functions above
1267 contain all integer values, while those constructed by the
1268 functions below only contain non-negative values.
1270 __isl_give isl_basic_set *isl_basic_set_nat_universe(
1271 __isl_take isl_space *space);
1272 __isl_give isl_basic_map *isl_basic_map_nat_universe(
1273 __isl_take isl_space *space);
1274 __isl_give isl_set *isl_set_nat_universe(
1275 __isl_take isl_space *space);
1276 __isl_give isl_map *isl_map_nat_universe(
1277 __isl_take isl_space *space);
1279 =item * Identity relations
1281 __isl_give isl_basic_map *isl_basic_map_identity(
1282 __isl_take isl_space *space);
1283 __isl_give isl_map *isl_map_identity(
1284 __isl_take isl_space *space);
1286 The number of input and output dimensions in C<space> needs
1289 =item * Lexicographic order
1291 __isl_give isl_map *isl_map_lex_lt(
1292 __isl_take isl_space *set_space);
1293 __isl_give isl_map *isl_map_lex_le(
1294 __isl_take isl_space *set_space);
1295 __isl_give isl_map *isl_map_lex_gt(
1296 __isl_take isl_space *set_space);
1297 __isl_give isl_map *isl_map_lex_ge(
1298 __isl_take isl_space *set_space);
1299 __isl_give isl_map *isl_map_lex_lt_first(
1300 __isl_take isl_space *space, unsigned n);
1301 __isl_give isl_map *isl_map_lex_le_first(
1302 __isl_take isl_space *space, unsigned n);
1303 __isl_give isl_map *isl_map_lex_gt_first(
1304 __isl_take isl_space *space, unsigned n);
1305 __isl_give isl_map *isl_map_lex_ge_first(
1306 __isl_take isl_space *space, unsigned n);
1308 The first four functions take a space for a B<set>
1309 and return relations that express that the elements in the domain
1310 are lexicographically less
1311 (C<isl_map_lex_lt>), less or equal (C<isl_map_lex_le>),
1312 greater (C<isl_map_lex_gt>) or greater or equal (C<isl_map_lex_ge>)
1313 than the elements in the range.
1314 The last four functions take a space for a map
1315 and return relations that express that the first C<n> dimensions
1316 in the domain are lexicographically less
1317 (C<isl_map_lex_lt_first>), less or equal (C<isl_map_lex_le_first>),
1318 greater (C<isl_map_lex_gt_first>) or greater or equal (C<isl_map_lex_ge_first>)
1319 than the first C<n> dimensions in the range.
1323 A basic set or relation can be converted to a set or relation
1324 using the following functions.
1326 __isl_give isl_set *isl_set_from_basic_set(
1327 __isl_take isl_basic_set *bset);
1328 __isl_give isl_map *isl_map_from_basic_map(
1329 __isl_take isl_basic_map *bmap);
1331 Sets and relations can be converted to union sets and relations
1332 using the following functions.
1334 __isl_give isl_union_set *isl_union_set_from_basic_set(
1335 __isl_take isl_basic_set *bset);
1336 __isl_give isl_union_map *isl_union_map_from_basic_map(
1337 __isl_take isl_basic_map *bmap);
1338 __isl_give isl_union_set *isl_union_set_from_set(
1339 __isl_take isl_set *set);
1340 __isl_give isl_union_map *isl_union_map_from_map(
1341 __isl_take isl_map *map);
1343 The inverse conversions below can only be used if the input
1344 union set or relation is known to contain elements in exactly one
1347 __isl_give isl_set *isl_set_from_union_set(
1348 __isl_take isl_union_set *uset);
1349 __isl_give isl_map *isl_map_from_union_map(
1350 __isl_take isl_union_map *umap);
1352 A zero-dimensional (basic) set can be constructed on a given parameter domain
1353 using the following function.
1355 __isl_give isl_basic_set *isl_basic_set_from_params(
1356 __isl_take isl_basic_set *bset);
1357 __isl_give isl_set *isl_set_from_params(
1358 __isl_take isl_set *set);
1360 Sets and relations can be copied and freed again using the following
1363 __isl_give isl_basic_set *isl_basic_set_copy(
1364 __isl_keep isl_basic_set *bset);
1365 __isl_give isl_set *isl_set_copy(__isl_keep isl_set *set);
1366 __isl_give isl_union_set *isl_union_set_copy(
1367 __isl_keep isl_union_set *uset);
1368 __isl_give isl_basic_map *isl_basic_map_copy(
1369 __isl_keep isl_basic_map *bmap);
1370 __isl_give isl_map *isl_map_copy(__isl_keep isl_map *map);
1371 __isl_give isl_union_map *isl_union_map_copy(
1372 __isl_keep isl_union_map *umap);
1373 void *isl_basic_set_free(__isl_take isl_basic_set *bset);
1374 void *isl_set_free(__isl_take isl_set *set);
1375 void *isl_union_set_free(__isl_take isl_union_set *uset);
1376 void *isl_basic_map_free(__isl_take isl_basic_map *bmap);
1377 void *isl_map_free(__isl_take isl_map *map);
1378 void *isl_union_map_free(__isl_take isl_union_map *umap);
1380 Other sets and relations can be constructed by starting
1381 from a universe set or relation, adding equality and/or
1382 inequality constraints and then projecting out the
1383 existentially quantified variables, if any.
1384 Constraints can be constructed, manipulated and
1385 added to (or removed from) (basic) sets and relations
1386 using the following functions.
1388 #include <isl/constraint.h>
1389 __isl_give isl_constraint *isl_equality_alloc(
1390 __isl_take isl_local_space *ls);
1391 __isl_give isl_constraint *isl_inequality_alloc(
1392 __isl_take isl_local_space *ls);
1393 __isl_give isl_constraint *isl_constraint_set_constant_si(
1394 __isl_take isl_constraint *constraint, int v);
1395 __isl_give isl_constraint *isl_constraint_set_constant_val(
1396 __isl_take isl_constraint *constraint,
1397 __isl_take isl_val *v);
1398 __isl_give isl_constraint *isl_constraint_set_coefficient_si(
1399 __isl_take isl_constraint *constraint,
1400 enum isl_dim_type type, int pos, int v);
1401 __isl_give isl_constraint *
1402 isl_constraint_set_coefficient_val(
1403 __isl_take isl_constraint *constraint,
1404 enum isl_dim_type type, int pos, isl_val *v);
1405 __isl_give isl_basic_map *isl_basic_map_add_constraint(
1406 __isl_take isl_basic_map *bmap,
1407 __isl_take isl_constraint *constraint);
1408 __isl_give isl_basic_set *isl_basic_set_add_constraint(
1409 __isl_take isl_basic_set *bset,
1410 __isl_take isl_constraint *constraint);
1411 __isl_give isl_map *isl_map_add_constraint(
1412 __isl_take isl_map *map,
1413 __isl_take isl_constraint *constraint);
1414 __isl_give isl_set *isl_set_add_constraint(
1415 __isl_take isl_set *set,
1416 __isl_take isl_constraint *constraint);
1417 __isl_give isl_basic_set *isl_basic_set_drop_constraint(
1418 __isl_take isl_basic_set *bset,
1419 __isl_take isl_constraint *constraint);
1421 For example, to create a set containing the even integers
1422 between 10 and 42, you would use the following code.
1425 isl_local_space *ls;
1427 isl_basic_set *bset;
1429 space = isl_space_set_alloc(ctx, 0, 2);
1430 bset = isl_basic_set_universe(isl_space_copy(space));
1431 ls = isl_local_space_from_space(space);
1433 c = isl_equality_alloc(isl_local_space_copy(ls));
1434 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
1435 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 2);
1436 bset = isl_basic_set_add_constraint(bset, c);
1438 c = isl_inequality_alloc(isl_local_space_copy(ls));
1439 c = isl_constraint_set_constant_si(c, -10);
1440 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
1441 bset = isl_basic_set_add_constraint(bset, c);
1443 c = isl_inequality_alloc(ls);
1444 c = isl_constraint_set_constant_si(c, 42);
1445 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
1446 bset = isl_basic_set_add_constraint(bset, c);
1448 bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 1);
1452 isl_basic_set *bset;
1453 bset = isl_basic_set_read_from_str(ctx,
1454 "{[i] : exists (a : i = 2a and i >= 10 and i <= 42)}");
1456 A basic set or relation can also be constructed from two matrices
1457 describing the equalities and the inequalities.
1459 __isl_give isl_basic_set *isl_basic_set_from_constraint_matrices(
1460 __isl_take isl_space *space,
1461 __isl_take isl_mat *eq, __isl_take isl_mat *ineq,
1462 enum isl_dim_type c1,
1463 enum isl_dim_type c2, enum isl_dim_type c3,
1464 enum isl_dim_type c4);
1465 __isl_give isl_basic_map *isl_basic_map_from_constraint_matrices(
1466 __isl_take isl_space *space,
1467 __isl_take isl_mat *eq, __isl_take isl_mat *ineq,
1468 enum isl_dim_type c1,
1469 enum isl_dim_type c2, enum isl_dim_type c3,
1470 enum isl_dim_type c4, enum isl_dim_type c5);
1472 The C<isl_dim_type> arguments indicate the order in which
1473 different kinds of variables appear in the input matrices
1474 and should be a permutation of C<isl_dim_cst>, C<isl_dim_param>,
1475 C<isl_dim_set> and C<isl_dim_div> for sets and
1476 of C<isl_dim_cst>, C<isl_dim_param>,
1477 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div> for relations.
1479 A (basic or union) set or relation can also be constructed from a
1480 (union) (piecewise) (multiple) affine expression
1481 or a list of affine expressions
1482 (See L<"Piecewise Quasi Affine Expressions"> and
1483 L<"Piecewise Multiple Quasi Affine Expressions">).
1485 __isl_give isl_basic_map *isl_basic_map_from_aff(
1486 __isl_take isl_aff *aff);
1487 __isl_give isl_map *isl_map_from_aff(
1488 __isl_take isl_aff *aff);
1489 __isl_give isl_set *isl_set_from_pw_aff(
1490 __isl_take isl_pw_aff *pwaff);
1491 __isl_give isl_map *isl_map_from_pw_aff(
1492 __isl_take isl_pw_aff *pwaff);
1493 __isl_give isl_basic_map *isl_basic_map_from_aff_list(
1494 __isl_take isl_space *domain_space,
1495 __isl_take isl_aff_list *list);
1496 __isl_give isl_basic_map *isl_basic_map_from_multi_aff(
1497 __isl_take isl_multi_aff *maff)
1498 __isl_give isl_map *isl_map_from_multi_aff(
1499 __isl_take isl_multi_aff *maff)
1500 __isl_give isl_set *isl_set_from_pw_multi_aff(
1501 __isl_take isl_pw_multi_aff *pma);
1502 __isl_give isl_map *isl_map_from_pw_multi_aff(
1503 __isl_take isl_pw_multi_aff *pma);
1504 __isl_give isl_union_map *
1505 isl_union_map_from_union_pw_multi_aff(
1506 __isl_take isl_union_pw_multi_aff *upma);
1508 The C<domain_dim> argument describes the domain of the resulting
1509 basic relation. It is required because the C<list> may consist
1510 of zero affine expressions.
1512 =head2 Inspecting Sets and Relations
1514 Usually, the user should not have to care about the actual constraints
1515 of the sets and maps, but should instead apply the abstract operations
1516 explained in the following sections.
1517 Occasionally, however, it may be required to inspect the individual
1518 coefficients of the constraints. This section explains how to do so.
1519 In these cases, it may also be useful to have C<isl> compute
1520 an explicit representation of the existentially quantified variables.
1522 __isl_give isl_set *isl_set_compute_divs(
1523 __isl_take isl_set *set);
1524 __isl_give isl_map *isl_map_compute_divs(
1525 __isl_take isl_map *map);
1526 __isl_give isl_union_set *isl_union_set_compute_divs(
1527 __isl_take isl_union_set *uset);
1528 __isl_give isl_union_map *isl_union_map_compute_divs(
1529 __isl_take isl_union_map *umap);
1531 This explicit representation defines the existentially quantified
1532 variables as integer divisions of the other variables, possibly
1533 including earlier existentially quantified variables.
1534 An explicitly represented existentially quantified variable therefore
1535 has a unique value when the values of the other variables are known.
1536 If, furthermore, the same existentials, i.e., existentials
1537 with the same explicit representations, should appear in the
1538 same order in each of the disjuncts of a set or map, then the user should call
1539 either of the following functions.
1541 __isl_give isl_set *isl_set_align_divs(
1542 __isl_take isl_set *set);
1543 __isl_give isl_map *isl_map_align_divs(
1544 __isl_take isl_map *map);
1546 Alternatively, the existentially quantified variables can be removed
1547 using the following functions, which compute an overapproximation.
1549 __isl_give isl_basic_set *isl_basic_set_remove_divs(
1550 __isl_take isl_basic_set *bset);
1551 __isl_give isl_basic_map *isl_basic_map_remove_divs(
1552 __isl_take isl_basic_map *bmap);
1553 __isl_give isl_set *isl_set_remove_divs(
1554 __isl_take isl_set *set);
1555 __isl_give isl_map *isl_map_remove_divs(
1556 __isl_take isl_map *map);
1558 It is also possible to only remove those divs that are defined
1559 in terms of a given range of dimensions or only those for which
1560 no explicit representation is known.
1562 __isl_give isl_basic_set *
1563 isl_basic_set_remove_divs_involving_dims(
1564 __isl_take isl_basic_set *bset,
1565 enum isl_dim_type type,
1566 unsigned first, unsigned n);
1567 __isl_give isl_basic_map *
1568 isl_basic_map_remove_divs_involving_dims(
1569 __isl_take isl_basic_map *bmap,
1570 enum isl_dim_type type,
1571 unsigned first, unsigned n);
1572 __isl_give isl_set *isl_set_remove_divs_involving_dims(
1573 __isl_take isl_set *set, enum isl_dim_type type,
1574 unsigned first, unsigned n);
1575 __isl_give isl_map *isl_map_remove_divs_involving_dims(
1576 __isl_take isl_map *map, enum isl_dim_type type,
1577 unsigned first, unsigned n);
1579 __isl_give isl_basic_set *
1580 isl_basic_set_remove_unknown_divs(
1581 __isl_take isl_basic_set *bset);
1582 __isl_give isl_set *isl_set_remove_unknown_divs(
1583 __isl_take isl_set *set);
1584 __isl_give isl_map *isl_map_remove_unknown_divs(
1585 __isl_take isl_map *map);
1587 To iterate over all the sets or maps in a union set or map, use
1589 int isl_union_set_foreach_set(__isl_keep isl_union_set *uset,
1590 int (*fn)(__isl_take isl_set *set, void *user),
1592 int isl_union_map_foreach_map(__isl_keep isl_union_map *umap,
1593 int (*fn)(__isl_take isl_map *map, void *user),
1596 The number of sets or maps in a union set or map can be obtained
1599 int isl_union_set_n_set(__isl_keep isl_union_set *uset);
1600 int isl_union_map_n_map(__isl_keep isl_union_map *umap);
1602 To extract the set or map in a given space from a union, use
1604 __isl_give isl_set *isl_union_set_extract_set(
1605 __isl_keep isl_union_set *uset,
1606 __isl_take isl_space *space);
1607 __isl_give isl_map *isl_union_map_extract_map(
1608 __isl_keep isl_union_map *umap,
1609 __isl_take isl_space *space);
1611 To iterate over all the basic sets or maps in a set or map, use
1613 int isl_set_foreach_basic_set(__isl_keep isl_set *set,
1614 int (*fn)(__isl_take isl_basic_set *bset, void *user),
1616 int isl_map_foreach_basic_map(__isl_keep isl_map *map,
1617 int (*fn)(__isl_take isl_basic_map *bmap, void *user),
1620 The callback function C<fn> should return 0 if successful and
1621 -1 if an error occurs. In the latter case, or if any other error
1622 occurs, the above functions will return -1.
1624 It should be noted that C<isl> does not guarantee that
1625 the basic sets or maps passed to C<fn> are disjoint.
1626 If this is required, then the user should call one of
1627 the following functions first.
1629 __isl_give isl_set *isl_set_make_disjoint(
1630 __isl_take isl_set *set);
1631 __isl_give isl_map *isl_map_make_disjoint(
1632 __isl_take isl_map *map);
1634 The number of basic sets in a set can be obtained
1637 int isl_set_n_basic_set(__isl_keep isl_set *set);
1639 To iterate over the constraints of a basic set or map, use
1641 #include <isl/constraint.h>
1643 int isl_basic_set_n_constraint(
1644 __isl_keep isl_basic_set *bset);
1645 int isl_basic_set_foreach_constraint(
1646 __isl_keep isl_basic_set *bset,
1647 int (*fn)(__isl_take isl_constraint *c, void *user),
1649 int isl_basic_map_foreach_constraint(
1650 __isl_keep isl_basic_map *bmap,
1651 int (*fn)(__isl_take isl_constraint *c, void *user),
1653 void *isl_constraint_free(__isl_take isl_constraint *c);
1655 Again, the callback function C<fn> should return 0 if successful and
1656 -1 if an error occurs. In the latter case, or if any other error
1657 occurs, the above functions will return -1.
1658 The constraint C<c> represents either an equality or an inequality.
1659 Use the following function to find out whether a constraint
1660 represents an equality. If not, it represents an inequality.
1662 int isl_constraint_is_equality(
1663 __isl_keep isl_constraint *constraint);
1665 The coefficients of the constraints can be inspected using
1666 the following functions.
1668 int isl_constraint_is_lower_bound(
1669 __isl_keep isl_constraint *constraint,
1670 enum isl_dim_type type, unsigned pos);
1671 int isl_constraint_is_upper_bound(
1672 __isl_keep isl_constraint *constraint,
1673 enum isl_dim_type type, unsigned pos);
1674 __isl_give isl_val *isl_constraint_get_constant_val(
1675 __isl_keep isl_constraint *constraint);
1676 __isl_give isl_val *isl_constraint_get_coefficient_val(
1677 __isl_keep isl_constraint *constraint,
1678 enum isl_dim_type type, int pos);
1679 int isl_constraint_involves_dims(
1680 __isl_keep isl_constraint *constraint,
1681 enum isl_dim_type type, unsigned first, unsigned n);
1683 The explicit representations of the existentially quantified
1684 variables can be inspected using the following function.
1685 Note that the user is only allowed to use this function
1686 if the inspected set or map is the result of a call
1687 to C<isl_set_compute_divs> or C<isl_map_compute_divs>.
1688 The existentially quantified variable is equal to the floor
1689 of the returned affine expression. The affine expression
1690 itself can be inspected using the functions in
1691 L<"Piecewise Quasi Affine Expressions">.
1693 __isl_give isl_aff *isl_constraint_get_div(
1694 __isl_keep isl_constraint *constraint, int pos);
1696 To obtain the constraints of a basic set or map in matrix
1697 form, use the following functions.
1699 __isl_give isl_mat *isl_basic_set_equalities_matrix(
1700 __isl_keep isl_basic_set *bset,
1701 enum isl_dim_type c1, enum isl_dim_type c2,
1702 enum isl_dim_type c3, enum isl_dim_type c4);
1703 __isl_give isl_mat *isl_basic_set_inequalities_matrix(
1704 __isl_keep isl_basic_set *bset,
1705 enum isl_dim_type c1, enum isl_dim_type c2,
1706 enum isl_dim_type c3, enum isl_dim_type c4);
1707 __isl_give isl_mat *isl_basic_map_equalities_matrix(
1708 __isl_keep isl_basic_map *bmap,
1709 enum isl_dim_type c1,
1710 enum isl_dim_type c2, enum isl_dim_type c3,
1711 enum isl_dim_type c4, enum isl_dim_type c5);
1712 __isl_give isl_mat *isl_basic_map_inequalities_matrix(
1713 __isl_keep isl_basic_map *bmap,
1714 enum isl_dim_type c1,
1715 enum isl_dim_type c2, enum isl_dim_type c3,
1716 enum isl_dim_type c4, enum isl_dim_type c5);
1718 The C<isl_dim_type> arguments dictate the order in which
1719 different kinds of variables appear in the resulting matrix
1720 and should be a permutation of C<isl_dim_cst>, C<isl_dim_param>,
1721 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div>.
1723 The number of parameters, input, output or set dimensions can
1724 be obtained using the following functions.
1726 unsigned isl_basic_set_dim(__isl_keep isl_basic_set *bset,
1727 enum isl_dim_type type);
1728 unsigned isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
1729 enum isl_dim_type type);
1730 unsigned isl_set_dim(__isl_keep isl_set *set,
1731 enum isl_dim_type type);
1732 unsigned isl_map_dim(__isl_keep isl_map *map,
1733 enum isl_dim_type type);
1735 To check whether the description of a set or relation depends
1736 on one or more given dimensions, it is not necessary to iterate over all
1737 constraints. Instead the following functions can be used.
1739 int isl_basic_set_involves_dims(
1740 __isl_keep isl_basic_set *bset,
1741 enum isl_dim_type type, unsigned first, unsigned n);
1742 int isl_set_involves_dims(__isl_keep isl_set *set,
1743 enum isl_dim_type type, unsigned first, unsigned n);
1744 int isl_basic_map_involves_dims(
1745 __isl_keep isl_basic_map *bmap,
1746 enum isl_dim_type type, unsigned first, unsigned n);
1747 int isl_map_involves_dims(__isl_keep isl_map *map,
1748 enum isl_dim_type type, unsigned first, unsigned n);
1750 Similarly, the following functions can be used to check whether
1751 a given dimension is involved in any lower or upper bound.
1753 int isl_set_dim_has_any_lower_bound(__isl_keep isl_set *set,
1754 enum isl_dim_type type, unsigned pos);
1755 int isl_set_dim_has_any_upper_bound(__isl_keep isl_set *set,
1756 enum isl_dim_type type, unsigned pos);
1758 Note that these functions return true even if there is a bound on
1759 the dimension on only some of the basic sets of C<set>.
1760 To check if they have a bound for all of the basic sets in C<set>,
1761 use the following functions instead.
1763 int isl_set_dim_has_lower_bound(__isl_keep isl_set *set,
1764 enum isl_dim_type type, unsigned pos);
1765 int isl_set_dim_has_upper_bound(__isl_keep isl_set *set,
1766 enum isl_dim_type type, unsigned pos);
1768 The identifiers or names of the domain and range spaces of a set
1769 or relation can be read off or set using the following functions.
1771 __isl_give isl_set *isl_set_set_tuple_id(
1772 __isl_take isl_set *set, __isl_take isl_id *id);
1773 __isl_give isl_set *isl_set_reset_tuple_id(
1774 __isl_take isl_set *set);
1775 int isl_set_has_tuple_id(__isl_keep isl_set *set);
1776 __isl_give isl_id *isl_set_get_tuple_id(
1777 __isl_keep isl_set *set);
1778 __isl_give isl_map *isl_map_set_tuple_id(
1779 __isl_take isl_map *map, enum isl_dim_type type,
1780 __isl_take isl_id *id);
1781 __isl_give isl_map *isl_map_reset_tuple_id(
1782 __isl_take isl_map *map, enum isl_dim_type type);
1783 int isl_map_has_tuple_id(__isl_keep isl_map *map,
1784 enum isl_dim_type type);
1785 __isl_give isl_id *isl_map_get_tuple_id(
1786 __isl_keep isl_map *map, enum isl_dim_type type);
1788 const char *isl_basic_set_get_tuple_name(
1789 __isl_keep isl_basic_set *bset);
1790 __isl_give isl_basic_set *isl_basic_set_set_tuple_name(
1791 __isl_take isl_basic_set *set, const char *s);
1792 int isl_set_has_tuple_name(__isl_keep isl_set *set);
1793 const char *isl_set_get_tuple_name(
1794 __isl_keep isl_set *set);
1795 const char *isl_basic_map_get_tuple_name(
1796 __isl_keep isl_basic_map *bmap,
1797 enum isl_dim_type type);
1798 __isl_give isl_basic_map *isl_basic_map_set_tuple_name(
1799 __isl_take isl_basic_map *bmap,
1800 enum isl_dim_type type, const char *s);
1801 int isl_map_has_tuple_name(__isl_keep isl_map *map,
1802 enum isl_dim_type type);
1803 const char *isl_map_get_tuple_name(
1804 __isl_keep isl_map *map,
1805 enum isl_dim_type type);
1807 As with C<isl_space_get_tuple_name>, the value returned points to
1808 an internal data structure.
1809 The identifiers, positions or names of individual dimensions can be
1810 read off using the following functions.
1812 __isl_give isl_id *isl_basic_set_get_dim_id(
1813 __isl_keep isl_basic_set *bset,
1814 enum isl_dim_type type, unsigned pos);
1815 __isl_give isl_set *isl_set_set_dim_id(
1816 __isl_take isl_set *set, enum isl_dim_type type,
1817 unsigned pos, __isl_take isl_id *id);
1818 int isl_set_has_dim_id(__isl_keep isl_set *set,
1819 enum isl_dim_type type, unsigned pos);
1820 __isl_give isl_id *isl_set_get_dim_id(
1821 __isl_keep isl_set *set, enum isl_dim_type type,
1823 int isl_basic_map_has_dim_id(
1824 __isl_keep isl_basic_map *bmap,
1825 enum isl_dim_type type, unsigned pos);
1826 __isl_give isl_map *isl_map_set_dim_id(
1827 __isl_take isl_map *map, enum isl_dim_type type,
1828 unsigned pos, __isl_take isl_id *id);
1829 int isl_map_has_dim_id(__isl_keep isl_map *map,
1830 enum isl_dim_type type, unsigned pos);
1831 __isl_give isl_id *isl_map_get_dim_id(
1832 __isl_keep isl_map *map, enum isl_dim_type type,
1835 int isl_set_find_dim_by_id(__isl_keep isl_set *set,
1836 enum isl_dim_type type, __isl_keep isl_id *id);
1837 int isl_map_find_dim_by_id(__isl_keep isl_map *map,
1838 enum isl_dim_type type, __isl_keep isl_id *id);
1839 int isl_set_find_dim_by_name(__isl_keep isl_set *set,
1840 enum isl_dim_type type, const char *name);
1841 int isl_map_find_dim_by_name(__isl_keep isl_map *map,
1842 enum isl_dim_type type, const char *name);
1844 const char *isl_constraint_get_dim_name(
1845 __isl_keep isl_constraint *constraint,
1846 enum isl_dim_type type, unsigned pos);
1847 const char *isl_basic_set_get_dim_name(
1848 __isl_keep isl_basic_set *bset,
1849 enum isl_dim_type type, unsigned pos);
1850 int isl_set_has_dim_name(__isl_keep isl_set *set,
1851 enum isl_dim_type type, unsigned pos);
1852 const char *isl_set_get_dim_name(
1853 __isl_keep isl_set *set,
1854 enum isl_dim_type type, unsigned pos);
1855 const char *isl_basic_map_get_dim_name(
1856 __isl_keep isl_basic_map *bmap,
1857 enum isl_dim_type type, unsigned pos);
1858 int isl_map_has_dim_name(__isl_keep isl_map *map,
1859 enum isl_dim_type type, unsigned pos);
1860 const char *isl_map_get_dim_name(
1861 __isl_keep isl_map *map,
1862 enum isl_dim_type type, unsigned pos);
1864 These functions are mostly useful to obtain the identifiers, positions
1865 or names of the parameters. Identifiers of individual dimensions are
1866 essentially only useful for printing. They are ignored by all other
1867 operations and may not be preserved across those operations.
1871 =head3 Unary Properties
1877 The following functions test whether the given set or relation
1878 contains any integer points. The ``plain'' variants do not perform
1879 any computations, but simply check if the given set or relation
1880 is already known to be empty.
1882 int isl_basic_set_plain_is_empty(__isl_keep isl_basic_set *bset);
1883 int isl_basic_set_is_empty(__isl_keep isl_basic_set *bset);
1884 int isl_set_plain_is_empty(__isl_keep isl_set *set);
1885 int isl_set_is_empty(__isl_keep isl_set *set);
1886 int isl_union_set_is_empty(__isl_keep isl_union_set *uset);
1887 int isl_basic_map_plain_is_empty(__isl_keep isl_basic_map *bmap);
1888 int isl_basic_map_is_empty(__isl_keep isl_basic_map *bmap);
1889 int isl_map_plain_is_empty(__isl_keep isl_map *map);
1890 int isl_map_is_empty(__isl_keep isl_map *map);
1891 int isl_union_map_is_empty(__isl_keep isl_union_map *umap);
1893 =item * Universality
1895 int isl_basic_set_is_universe(__isl_keep isl_basic_set *bset);
1896 int isl_basic_map_is_universe(__isl_keep isl_basic_map *bmap);
1897 int isl_set_plain_is_universe(__isl_keep isl_set *set);
1899 =item * Single-valuedness
1901 int isl_basic_map_is_single_valued(
1902 __isl_keep isl_basic_map *bmap);
1903 int isl_map_plain_is_single_valued(
1904 __isl_keep isl_map *map);
1905 int isl_map_is_single_valued(__isl_keep isl_map *map);
1906 int isl_union_map_is_single_valued(__isl_keep isl_union_map *umap);
1910 int isl_map_plain_is_injective(__isl_keep isl_map *map);
1911 int isl_map_is_injective(__isl_keep isl_map *map);
1912 int isl_union_map_plain_is_injective(
1913 __isl_keep isl_union_map *umap);
1914 int isl_union_map_is_injective(
1915 __isl_keep isl_union_map *umap);
1919 int isl_map_is_bijective(__isl_keep isl_map *map);
1920 int isl_union_map_is_bijective(__isl_keep isl_union_map *umap);
1924 __isl_give isl_val *
1925 isl_basic_map_plain_get_val_if_fixed(
1926 __isl_keep isl_basic_map *bmap,
1927 enum isl_dim_type type, unsigned pos);
1928 __isl_give isl_val *isl_set_plain_get_val_if_fixed(
1929 __isl_keep isl_set *set,
1930 enum isl_dim_type type, unsigned pos);
1931 __isl_give isl_val *isl_map_plain_get_val_if_fixed(
1932 __isl_keep isl_map *map,
1933 enum isl_dim_type type, unsigned pos);
1935 If the set or relation obviously lies on a hyperplane where the given dimension
1936 has a fixed value, then return that value.
1937 Otherwise return NaN.
1941 int isl_set_dim_residue_class_val(
1942 __isl_keep isl_set *set,
1943 int pos, __isl_give isl_val **modulo,
1944 __isl_give isl_val **residue);
1946 Check if the values of the given set dimension are equal to a fixed
1947 value modulo some integer value. If so, assign the modulo to C<*modulo>
1948 and the fixed value to C<*residue>. If the given dimension attains only
1949 a single value, then assign C<0> to C<*modulo> and the fixed value to
1951 If the dimension does not attain only a single value and if no modulo
1952 can be found then assign C<1> to C<*modulo> and C<1> to C<*residue>.
1956 To check whether a set is a parameter domain, use this function:
1958 int isl_set_is_params(__isl_keep isl_set *set);
1959 int isl_union_set_is_params(
1960 __isl_keep isl_union_set *uset);
1964 The following functions check whether the domain of the given
1965 (basic) set is a wrapped relation.
1967 int isl_basic_set_is_wrapping(
1968 __isl_keep isl_basic_set *bset);
1969 int isl_set_is_wrapping(__isl_keep isl_set *set);
1971 =item * Internal Product
1973 int isl_basic_map_can_zip(
1974 __isl_keep isl_basic_map *bmap);
1975 int isl_map_can_zip(__isl_keep isl_map *map);
1977 Check whether the product of domain and range of the given relation
1979 i.e., whether both domain and range are nested relations.
1983 int isl_basic_map_can_curry(
1984 __isl_keep isl_basic_map *bmap);
1985 int isl_map_can_curry(__isl_keep isl_map *map);
1987 Check whether the domain of the (basic) relation is a wrapped relation.
1989 int isl_basic_map_can_uncurry(
1990 __isl_keep isl_basic_map *bmap);
1991 int isl_map_can_uncurry(__isl_keep isl_map *map);
1993 Check whether the range of the (basic) relation is a wrapped relation.
1997 =head3 Binary Properties
2003 int isl_set_plain_is_equal(__isl_keep isl_set *set1,
2004 __isl_keep isl_set *set2);
2005 int isl_set_is_equal(__isl_keep isl_set *set1,
2006 __isl_keep isl_set *set2);
2007 int isl_union_set_is_equal(
2008 __isl_keep isl_union_set *uset1,
2009 __isl_keep isl_union_set *uset2);
2010 int isl_basic_map_is_equal(
2011 __isl_keep isl_basic_map *bmap1,
2012 __isl_keep isl_basic_map *bmap2);
2013 int isl_map_is_equal(__isl_keep isl_map *map1,
2014 __isl_keep isl_map *map2);
2015 int isl_map_plain_is_equal(__isl_keep isl_map *map1,
2016 __isl_keep isl_map *map2);
2017 int isl_union_map_is_equal(
2018 __isl_keep isl_union_map *umap1,
2019 __isl_keep isl_union_map *umap2);
2021 =item * Disjointness
2023 int isl_basic_set_is_disjoint(
2024 __isl_keep isl_basic_set *bset1,
2025 __isl_keep isl_basic_set *bset2);
2026 int isl_set_plain_is_disjoint(__isl_keep isl_set *set1,
2027 __isl_keep isl_set *set2);
2028 int isl_set_is_disjoint(__isl_keep isl_set *set1,
2029 __isl_keep isl_set *set2);
2030 int isl_basic_map_is_disjoint(
2031 __isl_keep isl_basic_map *bmap1,
2032 __isl_keep isl_basic_map *bmap2);
2033 int isl_map_is_disjoint(__isl_keep isl_map *map1,
2034 __isl_keep isl_map *map2);
2038 int isl_basic_set_is_subset(
2039 __isl_keep isl_basic_set *bset1,
2040 __isl_keep isl_basic_set *bset2);
2041 int isl_set_is_subset(__isl_keep isl_set *set1,
2042 __isl_keep isl_set *set2);
2043 int isl_set_is_strict_subset(
2044 __isl_keep isl_set *set1,
2045 __isl_keep isl_set *set2);
2046 int isl_union_set_is_subset(
2047 __isl_keep isl_union_set *uset1,
2048 __isl_keep isl_union_set *uset2);
2049 int isl_union_set_is_strict_subset(
2050 __isl_keep isl_union_set *uset1,
2051 __isl_keep isl_union_set *uset2);
2052 int isl_basic_map_is_subset(
2053 __isl_keep isl_basic_map *bmap1,
2054 __isl_keep isl_basic_map *bmap2);
2055 int isl_basic_map_is_strict_subset(
2056 __isl_keep isl_basic_map *bmap1,
2057 __isl_keep isl_basic_map *bmap2);
2058 int isl_map_is_subset(
2059 __isl_keep isl_map *map1,
2060 __isl_keep isl_map *map2);
2061 int isl_map_is_strict_subset(
2062 __isl_keep isl_map *map1,
2063 __isl_keep isl_map *map2);
2064 int isl_union_map_is_subset(
2065 __isl_keep isl_union_map *umap1,
2066 __isl_keep isl_union_map *umap2);
2067 int isl_union_map_is_strict_subset(
2068 __isl_keep isl_union_map *umap1,
2069 __isl_keep isl_union_map *umap2);
2071 Check whether the first argument is a (strict) subset of the
2076 int isl_set_plain_cmp(__isl_keep isl_set *set1,
2077 __isl_keep isl_set *set2);
2079 This function is useful for sorting C<isl_set>s.
2080 The order depends on the internal representation of the inputs.
2081 The order is fixed over different calls to the function (assuming
2082 the internal representation of the inputs has not changed), but may
2083 change over different versions of C<isl>.
2087 =head2 Unary Operations
2093 __isl_give isl_set *isl_set_complement(
2094 __isl_take isl_set *set);
2095 __isl_give isl_map *isl_map_complement(
2096 __isl_take isl_map *map);
2100 __isl_give isl_basic_map *isl_basic_map_reverse(
2101 __isl_take isl_basic_map *bmap);
2102 __isl_give isl_map *isl_map_reverse(
2103 __isl_take isl_map *map);
2104 __isl_give isl_union_map *isl_union_map_reverse(
2105 __isl_take isl_union_map *umap);
2109 __isl_give isl_basic_set *isl_basic_set_project_out(
2110 __isl_take isl_basic_set *bset,
2111 enum isl_dim_type type, unsigned first, unsigned n);
2112 __isl_give isl_basic_map *isl_basic_map_project_out(
2113 __isl_take isl_basic_map *bmap,
2114 enum isl_dim_type type, unsigned first, unsigned n);
2115 __isl_give isl_set *isl_set_project_out(__isl_take isl_set *set,
2116 enum isl_dim_type type, unsigned first, unsigned n);
2117 __isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
2118 enum isl_dim_type type, unsigned first, unsigned n);
2119 __isl_give isl_basic_set *isl_basic_set_params(
2120 __isl_take isl_basic_set *bset);
2121 __isl_give isl_basic_set *isl_basic_map_domain(
2122 __isl_take isl_basic_map *bmap);
2123 __isl_give isl_basic_set *isl_basic_map_range(
2124 __isl_take isl_basic_map *bmap);
2125 __isl_give isl_set *isl_set_params(__isl_take isl_set *set);
2126 __isl_give isl_set *isl_map_params(__isl_take isl_map *map);
2127 __isl_give isl_set *isl_map_domain(
2128 __isl_take isl_map *bmap);
2129 __isl_give isl_set *isl_map_range(
2130 __isl_take isl_map *map);
2131 __isl_give isl_set *isl_union_set_params(
2132 __isl_take isl_union_set *uset);
2133 __isl_give isl_set *isl_union_map_params(
2134 __isl_take isl_union_map *umap);
2135 __isl_give isl_union_set *isl_union_map_domain(
2136 __isl_take isl_union_map *umap);
2137 __isl_give isl_union_set *isl_union_map_range(
2138 __isl_take isl_union_map *umap);
2140 __isl_give isl_basic_map *isl_basic_map_domain_map(
2141 __isl_take isl_basic_map *bmap);
2142 __isl_give isl_basic_map *isl_basic_map_range_map(
2143 __isl_take isl_basic_map *bmap);
2144 __isl_give isl_map *isl_map_domain_map(__isl_take isl_map *map);
2145 __isl_give isl_map *isl_map_range_map(__isl_take isl_map *map);
2146 __isl_give isl_union_map *isl_union_map_domain_map(
2147 __isl_take isl_union_map *umap);
2148 __isl_give isl_union_map *isl_union_map_range_map(
2149 __isl_take isl_union_map *umap);
2151 The functions above construct a (basic, regular or union) relation
2152 that maps (a wrapped version of) the input relation to its domain or range.
2156 __isl_give isl_basic_set *isl_basic_set_eliminate(
2157 __isl_take isl_basic_set *bset,
2158 enum isl_dim_type type,
2159 unsigned first, unsigned n);
2160 __isl_give isl_set *isl_set_eliminate(
2161 __isl_take isl_set *set, enum isl_dim_type type,
2162 unsigned first, unsigned n);
2163 __isl_give isl_basic_map *isl_basic_map_eliminate(
2164 __isl_take isl_basic_map *bmap,
2165 enum isl_dim_type type,
2166 unsigned first, unsigned n);
2167 __isl_give isl_map *isl_map_eliminate(
2168 __isl_take isl_map *map, enum isl_dim_type type,
2169 unsigned first, unsigned n);
2171 Eliminate the coefficients for the given dimensions from the constraints,
2172 without removing the dimensions.
2176 __isl_give isl_basic_set *isl_basic_set_fix_si(
2177 __isl_take isl_basic_set *bset,
2178 enum isl_dim_type type, unsigned pos, int value);
2179 __isl_give isl_basic_set *isl_basic_set_fix_val(
2180 __isl_take isl_basic_set *bset,
2181 enum isl_dim_type type, unsigned pos,
2182 __isl_take isl_val *v);
2183 __isl_give isl_set *isl_set_fix_si(__isl_take isl_set *set,
2184 enum isl_dim_type type, unsigned pos, int value);
2185 __isl_give isl_set *isl_set_fix_val(
2186 __isl_take isl_set *set,
2187 enum isl_dim_type type, unsigned pos,
2188 __isl_take isl_val *v);
2189 __isl_give isl_basic_map *isl_basic_map_fix_si(
2190 __isl_take isl_basic_map *bmap,
2191 enum isl_dim_type type, unsigned pos, int value);
2192 __isl_give isl_basic_map *isl_basic_map_fix_val(
2193 __isl_take isl_basic_map *bmap,
2194 enum isl_dim_type type, unsigned pos,
2195 __isl_take isl_val *v);
2196 __isl_give isl_map *isl_map_fix_si(__isl_take isl_map *map,
2197 enum isl_dim_type type, unsigned pos, int value);
2198 __isl_give isl_map *isl_map_fix_val(
2199 __isl_take isl_map *map,
2200 enum isl_dim_type type, unsigned pos,
2201 __isl_take isl_val *v);
2203 Intersect the set or relation with the hyperplane where the given
2204 dimension has the fixed given value.
2206 __isl_give isl_basic_map *isl_basic_map_lower_bound_si(
2207 __isl_take isl_basic_map *bmap,
2208 enum isl_dim_type type, unsigned pos, int value);
2209 __isl_give isl_basic_map *isl_basic_map_upper_bound_si(
2210 __isl_take isl_basic_map *bmap,
2211 enum isl_dim_type type, unsigned pos, int value);
2212 __isl_give isl_set *isl_set_lower_bound_si(
2213 __isl_take isl_set *set,
2214 enum isl_dim_type type, unsigned pos, int value);
2215 __isl_give isl_set *isl_set_lower_bound_val(
2216 __isl_take isl_set *set,
2217 enum isl_dim_type type, unsigned pos,
2218 __isl_take isl_val *value);
2219 __isl_give isl_map *isl_map_lower_bound_si(
2220 __isl_take isl_map *map,
2221 enum isl_dim_type type, unsigned pos, int value);
2222 __isl_give isl_set *isl_set_upper_bound_si(
2223 __isl_take isl_set *set,
2224 enum isl_dim_type type, unsigned pos, int value);
2225 __isl_give isl_set *isl_set_upper_bound_val(
2226 __isl_take isl_set *set,
2227 enum isl_dim_type type, unsigned pos,
2228 __isl_take isl_val *value);
2229 __isl_give isl_map *isl_map_upper_bound_si(
2230 __isl_take isl_map *map,
2231 enum isl_dim_type type, unsigned pos, int value);
2233 Intersect the set or relation with the half-space where the given
2234 dimension has a value bounded by the fixed given integer value.
2236 __isl_give isl_set *isl_set_equate(__isl_take isl_set *set,
2237 enum isl_dim_type type1, int pos1,
2238 enum isl_dim_type type2, int pos2);
2239 __isl_give isl_basic_map *isl_basic_map_equate(
2240 __isl_take isl_basic_map *bmap,
2241 enum isl_dim_type type1, int pos1,
2242 enum isl_dim_type type2, int pos2);
2243 __isl_give isl_map *isl_map_equate(__isl_take isl_map *map,
2244 enum isl_dim_type type1, int pos1,
2245 enum isl_dim_type type2, int pos2);
2247 Intersect the set or relation with the hyperplane where the given
2248 dimensions are equal to each other.
2250 __isl_give isl_map *isl_map_oppose(__isl_take isl_map *map,
2251 enum isl_dim_type type1, int pos1,
2252 enum isl_dim_type type2, int pos2);
2254 Intersect the relation with the hyperplane where the given
2255 dimensions have opposite values.
2257 __isl_give isl_basic_map *isl_basic_map_order_ge(
2258 __isl_take isl_basic_map *bmap,
2259 enum isl_dim_type type1, int pos1,
2260 enum isl_dim_type type2, int pos2);
2261 __isl_give isl_map *isl_map_order_lt(__isl_take isl_map *map,
2262 enum isl_dim_type type1, int pos1,
2263 enum isl_dim_type type2, int pos2);
2264 __isl_give isl_basic_map *isl_basic_map_order_gt(
2265 __isl_take isl_basic_map *bmap,
2266 enum isl_dim_type type1, int pos1,
2267 enum isl_dim_type type2, int pos2);
2268 __isl_give isl_map *isl_map_order_gt(__isl_take isl_map *map,
2269 enum isl_dim_type type1, int pos1,
2270 enum isl_dim_type type2, int pos2);
2272 Intersect the relation with the half-space where the given
2273 dimensions satisfy the given ordering.
2277 __isl_give isl_map *isl_set_identity(
2278 __isl_take isl_set *set);
2279 __isl_give isl_union_map *isl_union_set_identity(
2280 __isl_take isl_union_set *uset);
2282 Construct an identity relation on the given (union) set.
2286 __isl_give isl_basic_set *isl_basic_map_deltas(
2287 __isl_take isl_basic_map *bmap);
2288 __isl_give isl_set *isl_map_deltas(__isl_take isl_map *map);
2289 __isl_give isl_union_set *isl_union_map_deltas(
2290 __isl_take isl_union_map *umap);
2292 These functions return a (basic) set containing the differences
2293 between image elements and corresponding domain elements in the input.
2295 __isl_give isl_basic_map *isl_basic_map_deltas_map(
2296 __isl_take isl_basic_map *bmap);
2297 __isl_give isl_map *isl_map_deltas_map(
2298 __isl_take isl_map *map);
2299 __isl_give isl_union_map *isl_union_map_deltas_map(
2300 __isl_take isl_union_map *umap);
2302 The functions above construct a (basic, regular or union) relation
2303 that maps (a wrapped version of) the input relation to its delta set.
2307 Simplify the representation of a set or relation by trying
2308 to combine pairs of basic sets or relations into a single
2309 basic set or relation.
2311 __isl_give isl_set *isl_set_coalesce(__isl_take isl_set *set);
2312 __isl_give isl_map *isl_map_coalesce(__isl_take isl_map *map);
2313 __isl_give isl_union_set *isl_union_set_coalesce(
2314 __isl_take isl_union_set *uset);
2315 __isl_give isl_union_map *isl_union_map_coalesce(
2316 __isl_take isl_union_map *umap);
2318 One of the methods for combining pairs of basic sets or relations
2319 can result in coefficients that are much larger than those that appear
2320 in the constraints of the input. By default, the coefficients are
2321 not allowed to grow larger, but this can be changed by unsetting
2322 the following option.
2324 int isl_options_set_coalesce_bounded_wrapping(
2325 isl_ctx *ctx, int val);
2326 int isl_options_get_coalesce_bounded_wrapping(
2329 =item * Detecting equalities
2331 __isl_give isl_basic_set *isl_basic_set_detect_equalities(
2332 __isl_take isl_basic_set *bset);
2333 __isl_give isl_basic_map *isl_basic_map_detect_equalities(
2334 __isl_take isl_basic_map *bmap);
2335 __isl_give isl_set *isl_set_detect_equalities(
2336 __isl_take isl_set *set);
2337 __isl_give isl_map *isl_map_detect_equalities(
2338 __isl_take isl_map *map);
2339 __isl_give isl_union_set *isl_union_set_detect_equalities(
2340 __isl_take isl_union_set *uset);
2341 __isl_give isl_union_map *isl_union_map_detect_equalities(
2342 __isl_take isl_union_map *umap);
2344 Simplify the representation of a set or relation by detecting implicit
2347 =item * Removing redundant constraints
2349 __isl_give isl_basic_set *isl_basic_set_remove_redundancies(
2350 __isl_take isl_basic_set *bset);
2351 __isl_give isl_set *isl_set_remove_redundancies(
2352 __isl_take isl_set *set);
2353 __isl_give isl_basic_map *isl_basic_map_remove_redundancies(
2354 __isl_take isl_basic_map *bmap);
2355 __isl_give isl_map *isl_map_remove_redundancies(
2356 __isl_take isl_map *map);
2360 __isl_give isl_basic_set *isl_set_convex_hull(
2361 __isl_take isl_set *set);
2362 __isl_give isl_basic_map *isl_map_convex_hull(
2363 __isl_take isl_map *map);
2365 If the input set or relation has any existentially quantified
2366 variables, then the result of these operations is currently undefined.
2370 __isl_give isl_basic_set *
2371 isl_set_unshifted_simple_hull(
2372 __isl_take isl_set *set);
2373 __isl_give isl_basic_map *
2374 isl_map_unshifted_simple_hull(
2375 __isl_take isl_map *map);
2376 __isl_give isl_basic_set *isl_set_simple_hull(
2377 __isl_take isl_set *set);
2378 __isl_give isl_basic_map *isl_map_simple_hull(
2379 __isl_take isl_map *map);
2380 __isl_give isl_union_map *isl_union_map_simple_hull(
2381 __isl_take isl_union_map *umap);
2383 These functions compute a single basic set or relation
2384 that contains the whole input set or relation.
2385 In particular, the output is described by translates
2386 of the constraints describing the basic sets or relations in the input.
2387 In case of C<isl_set_unshifted_simple_hull>, only the original
2388 constraints are used, without any translation.
2392 (See \autoref{s:simple hull}.)
2398 __isl_give isl_basic_set *isl_basic_set_affine_hull(
2399 __isl_take isl_basic_set *bset);
2400 __isl_give isl_basic_set *isl_set_affine_hull(
2401 __isl_take isl_set *set);
2402 __isl_give isl_union_set *isl_union_set_affine_hull(
2403 __isl_take isl_union_set *uset);
2404 __isl_give isl_basic_map *isl_basic_map_affine_hull(
2405 __isl_take isl_basic_map *bmap);
2406 __isl_give isl_basic_map *isl_map_affine_hull(
2407 __isl_take isl_map *map);
2408 __isl_give isl_union_map *isl_union_map_affine_hull(
2409 __isl_take isl_union_map *umap);
2411 In case of union sets and relations, the affine hull is computed
2414 =item * Polyhedral hull
2416 __isl_give isl_basic_set *isl_set_polyhedral_hull(
2417 __isl_take isl_set *set);
2418 __isl_give isl_basic_map *isl_map_polyhedral_hull(
2419 __isl_take isl_map *map);
2420 __isl_give isl_union_set *isl_union_set_polyhedral_hull(
2421 __isl_take isl_union_set *uset);
2422 __isl_give isl_union_map *isl_union_map_polyhedral_hull(
2423 __isl_take isl_union_map *umap);
2425 These functions compute a single basic set or relation
2426 not involving any existentially quantified variables
2427 that contains the whole input set or relation.
2428 In case of union sets and relations, the polyhedral hull is computed
2431 =item * Other approximations
2433 __isl_give isl_basic_set *
2434 isl_basic_set_drop_constraints_involving_dims(
2435 __isl_take isl_basic_set *bset,
2436 enum isl_dim_type type,
2437 unsigned first, unsigned n);
2438 __isl_give isl_basic_map *
2439 isl_basic_map_drop_constraints_involving_dims(
2440 __isl_take isl_basic_map *bmap,
2441 enum isl_dim_type type,
2442 unsigned first, unsigned n);
2443 __isl_give isl_basic_set *
2444 isl_basic_set_drop_constraints_not_involving_dims(
2445 __isl_take isl_basic_set *bset,
2446 enum isl_dim_type type,
2447 unsigned first, unsigned n);
2448 __isl_give isl_set *
2449 isl_set_drop_constraints_involving_dims(
2450 __isl_take isl_set *set,
2451 enum isl_dim_type type,
2452 unsigned first, unsigned n);
2453 __isl_give isl_map *
2454 isl_map_drop_constraints_involving_dims(
2455 __isl_take isl_map *map,
2456 enum isl_dim_type type,
2457 unsigned first, unsigned n);
2459 These functions drop any constraints (not) involving the specified dimensions.
2460 Note that the result depends on the representation of the input.
2464 __isl_give isl_basic_set *isl_basic_set_sample(
2465 __isl_take isl_basic_set *bset);
2466 __isl_give isl_basic_set *isl_set_sample(
2467 __isl_take isl_set *set);
2468 __isl_give isl_basic_map *isl_basic_map_sample(
2469 __isl_take isl_basic_map *bmap);
2470 __isl_give isl_basic_map *isl_map_sample(
2471 __isl_take isl_map *map);
2473 If the input (basic) set or relation is non-empty, then return
2474 a singleton subset of the input. Otherwise, return an empty set.
2476 =item * Optimization
2478 #include <isl/ilp.h>
2479 __isl_give isl_val *isl_basic_set_max_val(
2480 __isl_keep isl_basic_set *bset,
2481 __isl_keep isl_aff *obj);
2482 __isl_give isl_val *isl_set_min_val(
2483 __isl_keep isl_set *set,
2484 __isl_keep isl_aff *obj);
2485 __isl_give isl_val *isl_set_max_val(
2486 __isl_keep isl_set *set,
2487 __isl_keep isl_aff *obj);
2489 Compute the minimum or maximum of the integer affine expression C<obj>
2490 over the points in C<set>, returning the result in C<opt>.
2491 The result is C<NULL> in case of an error, the optimal value in case
2492 there is one, negative infinity or infinity if the problem is unbounded and
2493 NaN if the problem is empty.
2495 =item * Parametric optimization
2497 __isl_give isl_pw_aff *isl_set_dim_min(
2498 __isl_take isl_set *set, int pos);
2499 __isl_give isl_pw_aff *isl_set_dim_max(
2500 __isl_take isl_set *set, int pos);
2501 __isl_give isl_pw_aff *isl_map_dim_max(
2502 __isl_take isl_map *map, int pos);
2504 Compute the minimum or maximum of the given set or output dimension
2505 as a function of the parameters (and input dimensions), but independently
2506 of the other set or output dimensions.
2507 For lexicographic optimization, see L<"Lexicographic Optimization">.
2511 The following functions compute either the set of (rational) coefficient
2512 values of valid constraints for the given set or the set of (rational)
2513 values satisfying the constraints with coefficients from the given set.
2514 Internally, these two sets of functions perform essentially the
2515 same operations, except that the set of coefficients is assumed to
2516 be a cone, while the set of values may be any polyhedron.
2517 The current implementation is based on the Farkas lemma and
2518 Fourier-Motzkin elimination, but this may change or be made optional
2519 in future. In particular, future implementations may use different
2520 dualization algorithms or skip the elimination step.
2522 __isl_give isl_basic_set *isl_basic_set_coefficients(
2523 __isl_take isl_basic_set *bset);
2524 __isl_give isl_basic_set *isl_set_coefficients(
2525 __isl_take isl_set *set);
2526 __isl_give isl_union_set *isl_union_set_coefficients(
2527 __isl_take isl_union_set *bset);
2528 __isl_give isl_basic_set *isl_basic_set_solutions(
2529 __isl_take isl_basic_set *bset);
2530 __isl_give isl_basic_set *isl_set_solutions(
2531 __isl_take isl_set *set);
2532 __isl_give isl_union_set *isl_union_set_solutions(
2533 __isl_take isl_union_set *bset);
2537 __isl_give isl_map *isl_map_fixed_power_val(
2538 __isl_take isl_map *map,
2539 __isl_take isl_val *exp);
2540 __isl_give isl_union_map *
2541 isl_union_map_fixed_power_val(
2542 __isl_take isl_union_map *umap,
2543 __isl_take isl_val *exp);
2545 Compute the given power of C<map>, where C<exp> is assumed to be non-zero.
2546 If the exponent C<exp> is negative, then the -C<exp> th power of the inverse
2547 of C<map> is computed.
2549 __isl_give isl_map *isl_map_power(__isl_take isl_map *map,
2551 __isl_give isl_union_map *isl_union_map_power(
2552 __isl_take isl_union_map *umap, int *exact);
2554 Compute a parametric representation for all positive powers I<k> of C<map>.
2555 The result maps I<k> to a nested relation corresponding to the
2556 I<k>th power of C<map>.
2557 The result may be an overapproximation. If the result is known to be exact,
2558 then C<*exact> is set to C<1>.
2560 =item * Transitive closure
2562 __isl_give isl_map *isl_map_transitive_closure(
2563 __isl_take isl_map *map, int *exact);
2564 __isl_give isl_union_map *isl_union_map_transitive_closure(
2565 __isl_take isl_union_map *umap, int *exact);
2567 Compute the transitive closure of C<map>.
2568 The result may be an overapproximation. If the result is known to be exact,
2569 then C<*exact> is set to C<1>.
2571 =item * Reaching path lengths
2573 __isl_give isl_map *isl_map_reaching_path_lengths(
2574 __isl_take isl_map *map, int *exact);
2576 Compute a relation that maps each element in the range of C<map>
2577 to the lengths of all paths composed of edges in C<map> that
2578 end up in the given element.
2579 The result may be an overapproximation. If the result is known to be exact,
2580 then C<*exact> is set to C<1>.
2581 To compute the I<maximal> path length, the resulting relation
2582 should be postprocessed by C<isl_map_lexmax>.
2583 In particular, if the input relation is a dependence relation
2584 (mapping sources to sinks), then the maximal path length corresponds
2585 to the free schedule.
2586 Note, however, that C<isl_map_lexmax> expects the maximum to be
2587 finite, so if the path lengths are unbounded (possibly due to
2588 the overapproximation), then you will get an error message.
2592 __isl_give isl_basic_set *isl_basic_map_wrap(
2593 __isl_take isl_basic_map *bmap);
2594 __isl_give isl_set *isl_map_wrap(
2595 __isl_take isl_map *map);
2596 __isl_give isl_union_set *isl_union_map_wrap(
2597 __isl_take isl_union_map *umap);
2598 __isl_give isl_basic_map *isl_basic_set_unwrap(
2599 __isl_take isl_basic_set *bset);
2600 __isl_give isl_map *isl_set_unwrap(
2601 __isl_take isl_set *set);
2602 __isl_give isl_union_map *isl_union_set_unwrap(
2603 __isl_take isl_union_set *uset);
2607 Remove any internal structure of domain (and range) of the given
2608 set or relation. If there is any such internal structure in the input,
2609 then the name of the space is also removed.
2611 __isl_give isl_basic_set *isl_basic_set_flatten(
2612 __isl_take isl_basic_set *bset);
2613 __isl_give isl_set *isl_set_flatten(
2614 __isl_take isl_set *set);
2615 __isl_give isl_basic_map *isl_basic_map_flatten_domain(
2616 __isl_take isl_basic_map *bmap);
2617 __isl_give isl_basic_map *isl_basic_map_flatten_range(
2618 __isl_take isl_basic_map *bmap);
2619 __isl_give isl_map *isl_map_flatten_range(
2620 __isl_take isl_map *map);
2621 __isl_give isl_map *isl_map_flatten_domain(
2622 __isl_take isl_map *map);
2623 __isl_give isl_basic_map *isl_basic_map_flatten(
2624 __isl_take isl_basic_map *bmap);
2625 __isl_give isl_map *isl_map_flatten(
2626 __isl_take isl_map *map);
2628 __isl_give isl_map *isl_set_flatten_map(
2629 __isl_take isl_set *set);
2631 The function above constructs a relation
2632 that maps the input set to a flattened version of the set.
2636 Lift the input set to a space with extra dimensions corresponding
2637 to the existentially quantified variables in the input.
2638 In particular, the result lives in a wrapped map where the domain
2639 is the original space and the range corresponds to the original
2640 existentially quantified variables.
2642 __isl_give isl_basic_set *isl_basic_set_lift(
2643 __isl_take isl_basic_set *bset);
2644 __isl_give isl_set *isl_set_lift(
2645 __isl_take isl_set *set);
2646 __isl_give isl_union_set *isl_union_set_lift(
2647 __isl_take isl_union_set *uset);
2649 Given a local space that contains the existentially quantified
2650 variables of a set, a basic relation that, when applied to
2651 a basic set, has essentially the same effect as C<isl_basic_set_lift>,
2652 can be constructed using the following function.
2654 #include <isl/local_space.h>
2655 __isl_give isl_basic_map *isl_local_space_lifting(
2656 __isl_take isl_local_space *ls);
2658 =item * Internal Product
2660 __isl_give isl_basic_map *isl_basic_map_zip(
2661 __isl_take isl_basic_map *bmap);
2662 __isl_give isl_map *isl_map_zip(
2663 __isl_take isl_map *map);
2664 __isl_give isl_union_map *isl_union_map_zip(
2665 __isl_take isl_union_map *umap);
2667 Given a relation with nested relations for domain and range,
2668 interchange the range of the domain with the domain of the range.
2672 __isl_give isl_basic_map *isl_basic_map_curry(
2673 __isl_take isl_basic_map *bmap);
2674 __isl_give isl_basic_map *isl_basic_map_uncurry(
2675 __isl_take isl_basic_map *bmap);
2676 __isl_give isl_map *isl_map_curry(
2677 __isl_take isl_map *map);
2678 __isl_give isl_map *isl_map_uncurry(
2679 __isl_take isl_map *map);
2680 __isl_give isl_union_map *isl_union_map_curry(
2681 __isl_take isl_union_map *umap);
2682 __isl_give isl_union_map *isl_union_map_uncurry(
2683 __isl_take isl_union_map *umap);
2685 Given a relation with a nested relation for domain,
2686 the C<curry> functions
2687 move the range of the nested relation out of the domain
2688 and use it as the domain of a nested relation in the range,
2689 with the original range as range of this nested relation.
2690 The C<uncurry> functions perform the inverse operation.
2692 =item * Aligning parameters
2694 __isl_give isl_basic_set *isl_basic_set_align_params(
2695 __isl_take isl_basic_set *bset,
2696 __isl_take isl_space *model);
2697 __isl_give isl_set *isl_set_align_params(
2698 __isl_take isl_set *set,
2699 __isl_take isl_space *model);
2700 __isl_give isl_basic_map *isl_basic_map_align_params(
2701 __isl_take isl_basic_map *bmap,
2702 __isl_take isl_space *model);
2703 __isl_give isl_map *isl_map_align_params(
2704 __isl_take isl_map *map,
2705 __isl_take isl_space *model);
2707 Change the order of the parameters of the given set or relation
2708 such that the first parameters match those of C<model>.
2709 This may involve the introduction of extra parameters.
2710 All parameters need to be named.
2712 =item * Dimension manipulation
2714 __isl_give isl_basic_set *isl_basic_set_add_dims(
2715 __isl_take isl_basic_set *bset,
2716 enum isl_dim_type type, unsigned n);
2717 __isl_give isl_set *isl_set_add_dims(
2718 __isl_take isl_set *set,
2719 enum isl_dim_type type, unsigned n);
2720 __isl_give isl_map *isl_map_add_dims(
2721 __isl_take isl_map *map,
2722 enum isl_dim_type type, unsigned n);
2723 __isl_give isl_basic_set *isl_basic_set_insert_dims(
2724 __isl_take isl_basic_set *bset,
2725 enum isl_dim_type type, unsigned pos,
2727 __isl_give isl_basic_map *isl_basic_map_insert_dims(
2728 __isl_take isl_basic_map *bmap,
2729 enum isl_dim_type type, unsigned pos,
2731 __isl_give isl_set *isl_set_insert_dims(
2732 __isl_take isl_set *set,
2733 enum isl_dim_type type, unsigned pos, unsigned n);
2734 __isl_give isl_map *isl_map_insert_dims(
2735 __isl_take isl_map *map,
2736 enum isl_dim_type type, unsigned pos, unsigned n);
2737 __isl_give isl_basic_set *isl_basic_set_move_dims(
2738 __isl_take isl_basic_set *bset,
2739 enum isl_dim_type dst_type, unsigned dst_pos,
2740 enum isl_dim_type src_type, unsigned src_pos,
2742 __isl_give isl_basic_map *isl_basic_map_move_dims(
2743 __isl_take isl_basic_map *bmap,
2744 enum isl_dim_type dst_type, unsigned dst_pos,
2745 enum isl_dim_type src_type, unsigned src_pos,
2747 __isl_give isl_set *isl_set_move_dims(
2748 __isl_take isl_set *set,
2749 enum isl_dim_type dst_type, unsigned dst_pos,
2750 enum isl_dim_type src_type, unsigned src_pos,
2752 __isl_give isl_map *isl_map_move_dims(
2753 __isl_take isl_map *map,
2754 enum isl_dim_type dst_type, unsigned dst_pos,
2755 enum isl_dim_type src_type, unsigned src_pos,
2758 It is usually not advisable to directly change the (input or output)
2759 space of a set or a relation as this removes the name and the internal
2760 structure of the space. However, the above functions can be useful
2761 to add new parameters, assuming
2762 C<isl_set_align_params> and C<isl_map_align_params>
2767 =head2 Binary Operations
2769 The two arguments of a binary operation not only need to live
2770 in the same C<isl_ctx>, they currently also need to have
2771 the same (number of) parameters.
2773 =head3 Basic Operations
2777 =item * Intersection
2779 __isl_give isl_basic_set *isl_basic_set_intersect_params(
2780 __isl_take isl_basic_set *bset1,
2781 __isl_take isl_basic_set *bset2);
2782 __isl_give isl_basic_set *isl_basic_set_intersect(
2783 __isl_take isl_basic_set *bset1,
2784 __isl_take isl_basic_set *bset2);
2785 __isl_give isl_set *isl_set_intersect_params(
2786 __isl_take isl_set *set,
2787 __isl_take isl_set *params);
2788 __isl_give isl_set *isl_set_intersect(
2789 __isl_take isl_set *set1,
2790 __isl_take isl_set *set2);
2791 __isl_give isl_union_set *isl_union_set_intersect_params(
2792 __isl_take isl_union_set *uset,
2793 __isl_take isl_set *set);
2794 __isl_give isl_union_map *isl_union_map_intersect_params(
2795 __isl_take isl_union_map *umap,
2796 __isl_take isl_set *set);
2797 __isl_give isl_union_set *isl_union_set_intersect(
2798 __isl_take isl_union_set *uset1,
2799 __isl_take isl_union_set *uset2);
2800 __isl_give isl_basic_map *isl_basic_map_intersect_domain(
2801 __isl_take isl_basic_map *bmap,
2802 __isl_take isl_basic_set *bset);
2803 __isl_give isl_basic_map *isl_basic_map_intersect_range(
2804 __isl_take isl_basic_map *bmap,
2805 __isl_take isl_basic_set *bset);
2806 __isl_give isl_basic_map *isl_basic_map_intersect(
2807 __isl_take isl_basic_map *bmap1,
2808 __isl_take isl_basic_map *bmap2);
2809 __isl_give isl_map *isl_map_intersect_params(
2810 __isl_take isl_map *map,
2811 __isl_take isl_set *params);
2812 __isl_give isl_map *isl_map_intersect_domain(
2813 __isl_take isl_map *map,
2814 __isl_take isl_set *set);
2815 __isl_give isl_map *isl_map_intersect_range(
2816 __isl_take isl_map *map,
2817 __isl_take isl_set *set);
2818 __isl_give isl_map *isl_map_intersect(
2819 __isl_take isl_map *map1,
2820 __isl_take isl_map *map2);
2821 __isl_give isl_union_map *isl_union_map_intersect_domain(
2822 __isl_take isl_union_map *umap,
2823 __isl_take isl_union_set *uset);
2824 __isl_give isl_union_map *isl_union_map_intersect_range(
2825 __isl_take isl_union_map *umap,
2826 __isl_take isl_union_set *uset);
2827 __isl_give isl_union_map *isl_union_map_intersect(
2828 __isl_take isl_union_map *umap1,
2829 __isl_take isl_union_map *umap2);
2831 The second argument to the C<_params> functions needs to be
2832 a parametric (basic) set. For the other functions, a parametric set
2833 for either argument is only allowed if the other argument is
2834 a parametric set as well.
2838 __isl_give isl_set *isl_basic_set_union(
2839 __isl_take isl_basic_set *bset1,
2840 __isl_take isl_basic_set *bset2);
2841 __isl_give isl_map *isl_basic_map_union(
2842 __isl_take isl_basic_map *bmap1,
2843 __isl_take isl_basic_map *bmap2);
2844 __isl_give isl_set *isl_set_union(
2845 __isl_take isl_set *set1,
2846 __isl_take isl_set *set2);
2847 __isl_give isl_map *isl_map_union(
2848 __isl_take isl_map *map1,
2849 __isl_take isl_map *map2);
2850 __isl_give isl_union_set *isl_union_set_union(
2851 __isl_take isl_union_set *uset1,
2852 __isl_take isl_union_set *uset2);
2853 __isl_give isl_union_map *isl_union_map_union(
2854 __isl_take isl_union_map *umap1,
2855 __isl_take isl_union_map *umap2);
2857 =item * Set difference
2859 __isl_give isl_set *isl_set_subtract(
2860 __isl_take isl_set *set1,
2861 __isl_take isl_set *set2);
2862 __isl_give isl_map *isl_map_subtract(
2863 __isl_take isl_map *map1,
2864 __isl_take isl_map *map2);
2865 __isl_give isl_map *isl_map_subtract_domain(
2866 __isl_take isl_map *map,
2867 __isl_take isl_set *dom);
2868 __isl_give isl_map *isl_map_subtract_range(
2869 __isl_take isl_map *map,
2870 __isl_take isl_set *dom);
2871 __isl_give isl_union_set *isl_union_set_subtract(
2872 __isl_take isl_union_set *uset1,
2873 __isl_take isl_union_set *uset2);
2874 __isl_give isl_union_map *isl_union_map_subtract(
2875 __isl_take isl_union_map *umap1,
2876 __isl_take isl_union_map *umap2);
2877 __isl_give isl_union_map *isl_union_map_subtract_domain(
2878 __isl_take isl_union_map *umap,
2879 __isl_take isl_union_set *dom);
2880 __isl_give isl_union_map *isl_union_map_subtract_range(
2881 __isl_take isl_union_map *umap,
2882 __isl_take isl_union_set *dom);
2886 __isl_give isl_basic_set *isl_basic_set_apply(
2887 __isl_take isl_basic_set *bset,
2888 __isl_take isl_basic_map *bmap);
2889 __isl_give isl_set *isl_set_apply(
2890 __isl_take isl_set *set,
2891 __isl_take isl_map *map);
2892 __isl_give isl_union_set *isl_union_set_apply(
2893 __isl_take isl_union_set *uset,
2894 __isl_take isl_union_map *umap);
2895 __isl_give isl_basic_map *isl_basic_map_apply_domain(
2896 __isl_take isl_basic_map *bmap1,
2897 __isl_take isl_basic_map *bmap2);
2898 __isl_give isl_basic_map *isl_basic_map_apply_range(
2899 __isl_take isl_basic_map *bmap1,
2900 __isl_take isl_basic_map *bmap2);
2901 __isl_give isl_map *isl_map_apply_domain(
2902 __isl_take isl_map *map1,
2903 __isl_take isl_map *map2);
2904 __isl_give isl_union_map *isl_union_map_apply_domain(
2905 __isl_take isl_union_map *umap1,
2906 __isl_take isl_union_map *umap2);
2907 __isl_give isl_map *isl_map_apply_range(
2908 __isl_take isl_map *map1,
2909 __isl_take isl_map *map2);
2910 __isl_give isl_union_map *isl_union_map_apply_range(
2911 __isl_take isl_union_map *umap1,
2912 __isl_take isl_union_map *umap2);
2916 __isl_give isl_basic_set *
2917 isl_basic_set_preimage_multi_aff(
2918 __isl_take isl_basic_set *bset,
2919 __isl_take isl_multi_aff *ma);
2920 __isl_give isl_set *isl_set_preimage_multi_aff(
2921 __isl_take isl_set *set,
2922 __isl_take isl_multi_aff *ma);
2923 __isl_give isl_set *isl_set_preimage_pw_multi_aff(
2924 __isl_take isl_set *set,
2925 __isl_take isl_pw_multi_aff *pma);
2926 __isl_give isl_basic_map *
2927 isl_basic_map_preimage_domain_multi_aff(
2928 __isl_take isl_basic_map *bmap,
2929 __isl_take isl_multi_aff *ma);
2930 __isl_give isl_map *isl_map_preimage_domain_multi_aff(
2931 __isl_take isl_map *map,
2932 __isl_take isl_multi_aff *ma);
2933 __isl_give isl_union_map *
2934 isl_union_map_preimage_domain_multi_aff(
2935 __isl_take isl_union_map *umap,
2936 __isl_take isl_multi_aff *ma);
2937 __isl_give isl_basic_map *
2938 isl_basic_map_preimage_range_multi_aff(
2939 __isl_take isl_basic_map *bmap,
2940 __isl_take isl_multi_aff *ma);
2942 These functions compute the preimage of the given set or map domain/range under
2943 the given function. In other words, the expression is plugged
2944 into the set description or into the domain/range of the map.
2945 Objects of types C<isl_multi_aff> and C<isl_pw_multi_aff> are described in
2946 L</"Piecewise Multiple Quasi Affine Expressions">.
2948 =item * Cartesian Product
2950 __isl_give isl_set *isl_set_product(
2951 __isl_take isl_set *set1,
2952 __isl_take isl_set *set2);
2953 __isl_give isl_union_set *isl_union_set_product(
2954 __isl_take isl_union_set *uset1,
2955 __isl_take isl_union_set *uset2);
2956 __isl_give isl_basic_map *isl_basic_map_domain_product(
2957 __isl_take isl_basic_map *bmap1,
2958 __isl_take isl_basic_map *bmap2);
2959 __isl_give isl_basic_map *isl_basic_map_range_product(
2960 __isl_take isl_basic_map *bmap1,
2961 __isl_take isl_basic_map *bmap2);
2962 __isl_give isl_basic_map *isl_basic_map_product(
2963 __isl_take isl_basic_map *bmap1,
2964 __isl_take isl_basic_map *bmap2);
2965 __isl_give isl_map *isl_map_domain_product(
2966 __isl_take isl_map *map1,
2967 __isl_take isl_map *map2);
2968 __isl_give isl_map *isl_map_range_product(
2969 __isl_take isl_map *map1,
2970 __isl_take isl_map *map2);
2971 __isl_give isl_union_map *isl_union_map_domain_product(
2972 __isl_take isl_union_map *umap1,
2973 __isl_take isl_union_map *umap2);
2974 __isl_give isl_union_map *isl_union_map_range_product(
2975 __isl_take isl_union_map *umap1,
2976 __isl_take isl_union_map *umap2);
2977 __isl_give isl_map *isl_map_product(
2978 __isl_take isl_map *map1,
2979 __isl_take isl_map *map2);
2980 __isl_give isl_union_map *isl_union_map_product(
2981 __isl_take isl_union_map *umap1,
2982 __isl_take isl_union_map *umap2);
2984 The above functions compute the cross product of the given
2985 sets or relations. The domains and ranges of the results
2986 are wrapped maps between domains and ranges of the inputs.
2987 To obtain a ``flat'' product, use the following functions
2990 __isl_give isl_basic_set *isl_basic_set_flat_product(
2991 __isl_take isl_basic_set *bset1,
2992 __isl_take isl_basic_set *bset2);
2993 __isl_give isl_set *isl_set_flat_product(
2994 __isl_take isl_set *set1,
2995 __isl_take isl_set *set2);
2996 __isl_give isl_basic_map *isl_basic_map_flat_range_product(
2997 __isl_take isl_basic_map *bmap1,
2998 __isl_take isl_basic_map *bmap2);
2999 __isl_give isl_map *isl_map_flat_domain_product(
3000 __isl_take isl_map *map1,
3001 __isl_take isl_map *map2);
3002 __isl_give isl_map *isl_map_flat_range_product(
3003 __isl_take isl_map *map1,
3004 __isl_take isl_map *map2);
3005 __isl_give isl_union_map *isl_union_map_flat_range_product(
3006 __isl_take isl_union_map *umap1,
3007 __isl_take isl_union_map *umap2);
3008 __isl_give isl_basic_map *isl_basic_map_flat_product(
3009 __isl_take isl_basic_map *bmap1,
3010 __isl_take isl_basic_map *bmap2);
3011 __isl_give isl_map *isl_map_flat_product(
3012 __isl_take isl_map *map1,
3013 __isl_take isl_map *map2);
3015 =item * Simplification
3017 __isl_give isl_basic_set *isl_basic_set_gist(
3018 __isl_take isl_basic_set *bset,
3019 __isl_take isl_basic_set *context);
3020 __isl_give isl_set *isl_set_gist(__isl_take isl_set *set,
3021 __isl_take isl_set *context);
3022 __isl_give isl_set *isl_set_gist_params(
3023 __isl_take isl_set *set,
3024 __isl_take isl_set *context);
3025 __isl_give isl_union_set *isl_union_set_gist(
3026 __isl_take isl_union_set *uset,
3027 __isl_take isl_union_set *context);
3028 __isl_give isl_union_set *isl_union_set_gist_params(
3029 __isl_take isl_union_set *uset,
3030 __isl_take isl_set *set);
3031 __isl_give isl_basic_map *isl_basic_map_gist(
3032 __isl_take isl_basic_map *bmap,
3033 __isl_take isl_basic_map *context);
3034 __isl_give isl_map *isl_map_gist(__isl_take isl_map *map,
3035 __isl_take isl_map *context);
3036 __isl_give isl_map *isl_map_gist_params(
3037 __isl_take isl_map *map,
3038 __isl_take isl_set *context);
3039 __isl_give isl_map *isl_map_gist_domain(
3040 __isl_take isl_map *map,
3041 __isl_take isl_set *context);
3042 __isl_give isl_map *isl_map_gist_range(
3043 __isl_take isl_map *map,
3044 __isl_take isl_set *context);
3045 __isl_give isl_union_map *isl_union_map_gist(
3046 __isl_take isl_union_map *umap,
3047 __isl_take isl_union_map *context);
3048 __isl_give isl_union_map *isl_union_map_gist_params(
3049 __isl_take isl_union_map *umap,
3050 __isl_take isl_set *set);
3051 __isl_give isl_union_map *isl_union_map_gist_domain(
3052 __isl_take isl_union_map *umap,
3053 __isl_take isl_union_set *uset);
3054 __isl_give isl_union_map *isl_union_map_gist_range(
3055 __isl_take isl_union_map *umap,
3056 __isl_take isl_union_set *uset);
3058 The gist operation returns a set or relation that has the
3059 same intersection with the context as the input set or relation.
3060 Any implicit equality in the intersection is made explicit in the result,
3061 while all inequalities that are redundant with respect to the intersection
3063 In case of union sets and relations, the gist operation is performed
3068 =head3 Lexicographic Optimization
3070 Given a (basic) set C<set> (or C<bset>) and a zero-dimensional domain C<dom>,
3071 the following functions
3072 compute a set that contains the lexicographic minimum or maximum
3073 of the elements in C<set> (or C<bset>) for those values of the parameters
3074 that satisfy C<dom>.
3075 If C<empty> is not C<NULL>, then C<*empty> is assigned a set
3076 that contains the parameter values in C<dom> for which C<set> (or C<bset>)
3078 In other words, the union of the parameter values
3079 for which the result is non-empty and of C<*empty>
3082 __isl_give isl_set *isl_basic_set_partial_lexmin(
3083 __isl_take isl_basic_set *bset,
3084 __isl_take isl_basic_set *dom,
3085 __isl_give isl_set **empty);
3086 __isl_give isl_set *isl_basic_set_partial_lexmax(
3087 __isl_take isl_basic_set *bset,
3088 __isl_take isl_basic_set *dom,
3089 __isl_give isl_set **empty);
3090 __isl_give isl_set *isl_set_partial_lexmin(
3091 __isl_take isl_set *set, __isl_take isl_set *dom,
3092 __isl_give isl_set **empty);
3093 __isl_give isl_set *isl_set_partial_lexmax(
3094 __isl_take isl_set *set, __isl_take isl_set *dom,
3095 __isl_give isl_set **empty);
3097 Given a (basic) set C<set> (or C<bset>), the following functions simply
3098 return a set containing the lexicographic minimum or maximum
3099 of the elements in C<set> (or C<bset>).
3100 In case of union sets, the optimum is computed per space.
3102 __isl_give isl_set *isl_basic_set_lexmin(
3103 __isl_take isl_basic_set *bset);
3104 __isl_give isl_set *isl_basic_set_lexmax(
3105 __isl_take isl_basic_set *bset);
3106 __isl_give isl_set *isl_set_lexmin(
3107 __isl_take isl_set *set);
3108 __isl_give isl_set *isl_set_lexmax(
3109 __isl_take isl_set *set);
3110 __isl_give isl_union_set *isl_union_set_lexmin(
3111 __isl_take isl_union_set *uset);
3112 __isl_give isl_union_set *isl_union_set_lexmax(
3113 __isl_take isl_union_set *uset);
3115 Given a (basic) relation C<map> (or C<bmap>) and a domain C<dom>,
3116 the following functions
3117 compute a relation that maps each element of C<dom>
3118 to the single lexicographic minimum or maximum
3119 of the elements that are associated to that same
3120 element in C<map> (or C<bmap>).
3121 If C<empty> is not C<NULL>, then C<*empty> is assigned a set
3122 that contains the elements in C<dom> that do not map
3123 to any elements in C<map> (or C<bmap>).
3124 In other words, the union of the domain of the result and of C<*empty>
3127 __isl_give isl_map *isl_basic_map_partial_lexmax(
3128 __isl_take isl_basic_map *bmap,
3129 __isl_take isl_basic_set *dom,
3130 __isl_give isl_set **empty);
3131 __isl_give isl_map *isl_basic_map_partial_lexmin(
3132 __isl_take isl_basic_map *bmap,
3133 __isl_take isl_basic_set *dom,
3134 __isl_give isl_set **empty);
3135 __isl_give isl_map *isl_map_partial_lexmax(
3136 __isl_take isl_map *map, __isl_take isl_set *dom,
3137 __isl_give isl_set **empty);
3138 __isl_give isl_map *isl_map_partial_lexmin(
3139 __isl_take isl_map *map, __isl_take isl_set *dom,
3140 __isl_give isl_set **empty);
3142 Given a (basic) map C<map> (or C<bmap>), the following functions simply
3143 return a map mapping each element in the domain of
3144 C<map> (or C<bmap>) to the lexicographic minimum or maximum
3145 of all elements associated to that element.
3146 In case of union relations, the optimum is computed per space.
3148 __isl_give isl_map *isl_basic_map_lexmin(
3149 __isl_take isl_basic_map *bmap);
3150 __isl_give isl_map *isl_basic_map_lexmax(
3151 __isl_take isl_basic_map *bmap);
3152 __isl_give isl_map *isl_map_lexmin(
3153 __isl_take isl_map *map);
3154 __isl_give isl_map *isl_map_lexmax(
3155 __isl_take isl_map *map);
3156 __isl_give isl_union_map *isl_union_map_lexmin(
3157 __isl_take isl_union_map *umap);
3158 __isl_give isl_union_map *isl_union_map_lexmax(
3159 __isl_take isl_union_map *umap);
3161 The following functions return their result in the form of
3162 a piecewise multi-affine expression
3163 (See L<"Piecewise Multiple Quasi Affine Expressions">),
3164 but are otherwise equivalent to the corresponding functions
3165 returning a basic set or relation.
3167 __isl_give isl_pw_multi_aff *
3168 isl_basic_map_lexmin_pw_multi_aff(
3169 __isl_take isl_basic_map *bmap);
3170 __isl_give isl_pw_multi_aff *
3171 isl_basic_set_partial_lexmin_pw_multi_aff(
3172 __isl_take isl_basic_set *bset,
3173 __isl_take isl_basic_set *dom,
3174 __isl_give isl_set **empty);
3175 __isl_give isl_pw_multi_aff *
3176 isl_basic_set_partial_lexmax_pw_multi_aff(
3177 __isl_take isl_basic_set *bset,
3178 __isl_take isl_basic_set *dom,
3179 __isl_give isl_set **empty);
3180 __isl_give isl_pw_multi_aff *
3181 isl_basic_map_partial_lexmin_pw_multi_aff(
3182 __isl_take isl_basic_map *bmap,
3183 __isl_take isl_basic_set *dom,
3184 __isl_give isl_set **empty);
3185 __isl_give isl_pw_multi_aff *
3186 isl_basic_map_partial_lexmax_pw_multi_aff(
3187 __isl_take isl_basic_map *bmap,
3188 __isl_take isl_basic_set *dom,
3189 __isl_give isl_set **empty);
3190 __isl_give isl_pw_multi_aff *isl_set_lexmin_pw_multi_aff(
3191 __isl_take isl_set *set);
3192 __isl_give isl_pw_multi_aff *isl_set_lexmax_pw_multi_aff(
3193 __isl_take isl_set *set);
3194 __isl_give isl_pw_multi_aff *isl_map_lexmin_pw_multi_aff(
3195 __isl_take isl_map *map);
3196 __isl_give isl_pw_multi_aff *isl_map_lexmax_pw_multi_aff(
3197 __isl_take isl_map *map);
3201 Lists are defined over several element types, including
3202 C<isl_val>, C<isl_id>, C<isl_aff>, C<isl_pw_aff>, C<isl_constraint>,
3203 C<isl_basic_set>, C<isl_set>, C<isl_ast_expr> and C<isl_ast_node>.
3204 Here we take lists of C<isl_set>s as an example.
3205 Lists can be created, copied, modified and freed using the following functions.
3207 #include <isl/list.h>
3208 __isl_give isl_set_list *isl_set_list_from_set(
3209 __isl_take isl_set *el);
3210 __isl_give isl_set_list *isl_set_list_alloc(
3211 isl_ctx *ctx, int n);
3212 __isl_give isl_set_list *isl_set_list_copy(
3213 __isl_keep isl_set_list *list);
3214 __isl_give isl_set_list *isl_set_list_insert(
3215 __isl_take isl_set_list *list, unsigned pos,
3216 __isl_take isl_set *el);
3217 __isl_give isl_set_list *isl_set_list_add(
3218 __isl_take isl_set_list *list,
3219 __isl_take isl_set *el);
3220 __isl_give isl_set_list *isl_set_list_drop(
3221 __isl_take isl_set_list *list,
3222 unsigned first, unsigned n);
3223 __isl_give isl_set_list *isl_set_list_set_set(
3224 __isl_take isl_set_list *list, int index,
3225 __isl_take isl_set *set);
3226 __isl_give isl_set_list *isl_set_list_concat(
3227 __isl_take isl_set_list *list1,
3228 __isl_take isl_set_list *list2);
3229 __isl_give isl_set_list *isl_set_list_sort(
3230 __isl_take isl_set_list *list,
3231 int (*cmp)(__isl_keep isl_set *a,
3232 __isl_keep isl_set *b, void *user),
3234 void *isl_set_list_free(__isl_take isl_set_list *list);
3236 C<isl_set_list_alloc> creates an empty list with a capacity for
3237 C<n> elements. C<isl_set_list_from_set> creates a list with a single
3240 Lists can be inspected using the following functions.
3242 #include <isl/list.h>
3243 isl_ctx *isl_set_list_get_ctx(__isl_keep isl_set_list *list);
3244 int isl_set_list_n_set(__isl_keep isl_set_list *list);
3245 __isl_give isl_set *isl_set_list_get_set(
3246 __isl_keep isl_set_list *list, int index);
3247 int isl_set_list_foreach(__isl_keep isl_set_list *list,
3248 int (*fn)(__isl_take isl_set *el, void *user),
3250 int isl_set_list_foreach_scc(__isl_keep isl_set_list *list,
3251 int (*follows)(__isl_keep isl_set *a,
3252 __isl_keep isl_set *b, void *user),
3254 int (*fn)(__isl_take isl_set *el, void *user),
3257 The function C<isl_set_list_foreach_scc> calls C<fn> on each of the
3258 strongly connected components of the graph with as vertices the elements
3259 of C<list> and a directed edge from vertex C<b> to vertex C<a>
3260 iff C<follows(a, b)> returns C<1>. The callbacks C<follows> and C<fn>
3261 should return C<-1> on error.
3263 Lists can be printed using
3265 #include <isl/list.h>
3266 __isl_give isl_printer *isl_printer_print_set_list(
3267 __isl_take isl_printer *p,
3268 __isl_keep isl_set_list *list);
3270 =head2 Multiple Values
3272 An C<isl_multi_val> object represents a sequence of zero or more values,
3273 living in a set space.
3275 An C<isl_multi_val> can be constructed from an C<isl_val_list>
3276 using the following function
3278 #include <isl/val.h>
3279 __isl_give isl_multi_val *isl_multi_val_from_val_list(
3280 __isl_take isl_space *space,
3281 __isl_take isl_val_list *list);
3283 The zero multiple value (with value zero for each set dimension)
3284 can be created using the following function.
3286 #include <isl/val.h>
3287 __isl_give isl_multi_val *isl_multi_val_zero(
3288 __isl_take isl_space *space);
3290 Multiple values can be copied and freed using
3292 #include <isl/val.h>
3293 __isl_give isl_multi_val *isl_multi_val_copy(
3294 __isl_keep isl_multi_val *mv);
3295 void *isl_multi_val_free(__isl_take isl_multi_val *mv);
3297 They can be inspected using
3299 #include <isl/val.h>
3300 isl_ctx *isl_multi_val_get_ctx(
3301 __isl_keep isl_multi_val *mv);
3302 unsigned isl_multi_val_dim(__isl_keep isl_multi_val *mv,
3303 enum isl_dim_type type);
3304 __isl_give isl_val *isl_multi_val_get_val(
3305 __isl_keep isl_multi_val *mv, int pos);
3306 int isl_multi_val_find_dim_by_id(
3307 __isl_keep isl_multi_val *mv,
3308 enum isl_dim_type type, __isl_keep isl_id *id);
3309 __isl_give isl_id *isl_multi_val_get_dim_id(
3310 __isl_keep isl_multi_val *mv,
3311 enum isl_dim_type type, unsigned pos);
3312 const char *isl_multi_val_get_tuple_name(
3313 __isl_keep isl_multi_val *mv,
3314 enum isl_dim_type type);
3315 int isl_multi_val_has_tuple_id(__isl_keep isl_multi_val *mv,
3316 enum isl_dim_type type);
3317 __isl_give isl_id *isl_multi_val_get_tuple_id(
3318 __isl_keep isl_multi_val *mv,
3319 enum isl_dim_type type);
3320 __isl_give isl_multi_val *isl_multi_val_reset_tuple_id(
3321 __isl_take isl_multi_val *mv,
3322 enum isl_dim_type type);
3324 They can be modified using
3326 #include <isl/val.h>
3327 __isl_give isl_multi_val *isl_multi_val_set_val(
3328 __isl_take isl_multi_val *mv, int pos,
3329 __isl_take isl_val *val);
3330 __isl_give isl_multi_val *isl_multi_val_set_dim_name(
3331 __isl_take isl_multi_val *mv,
3332 enum isl_dim_type type, unsigned pos, const char *s);
3333 __isl_give isl_multi_val *isl_multi_val_set_dim_id(
3334 __isl_take isl_multi_val *mv,
3335 enum isl_dim_type type, unsigned pos,
3336 __isl_take isl_id *id);
3337 __isl_give isl_multi_val *isl_multi_val_set_tuple_name(
3338 __isl_take isl_multi_val *mv,
3339 enum isl_dim_type type, const char *s);
3340 __isl_give isl_multi_val *isl_multi_val_set_tuple_id(
3341 __isl_take isl_multi_val *mv,
3342 enum isl_dim_type type, __isl_take isl_id *id);
3344 __isl_give isl_multi_val *isl_multi_val_insert_dims(
3345 __isl_take isl_multi_val *mv,
3346 enum isl_dim_type type, unsigned first, unsigned n);
3347 __isl_give isl_multi_val *isl_multi_val_add_dims(
3348 __isl_take isl_multi_val *mv,
3349 enum isl_dim_type type, unsigned n);
3350 __isl_give isl_multi_val *isl_multi_val_drop_dims(
3351 __isl_take isl_multi_val *mv,
3352 enum isl_dim_type type, unsigned first, unsigned n);
3356 #include <isl/val.h>
3357 __isl_give isl_multi_val *isl_multi_val_align_params(
3358 __isl_take isl_multi_val *mv,
3359 __isl_take isl_space *model);
3360 __isl_give isl_multi_val *isl_multi_val_from_range(
3361 __isl_take isl_multi_val *mv);
3362 __isl_give isl_multi_val *isl_multi_val_range_splice(
3363 __isl_take isl_multi_val *mv1, unsigned pos,
3364 __isl_take isl_multi_val *mv2);
3365 __isl_give isl_multi_val *isl_multi_val_range_product(
3366 __isl_take isl_multi_val *mv1,
3367 __isl_take isl_multi_val *mv2);
3368 __isl_give isl_multi_val *isl_multi_val_flat_range_product(
3369 __isl_take isl_multi_val *mv1,
3370 __isl_take isl_multi_aff *mv2);
3371 __isl_give isl_multi_val *isl_multi_val_add_val(
3372 __isl_take isl_multi_val *mv,
3373 __isl_take isl_val *v);
3374 __isl_give isl_multi_val *isl_multi_val_mod_val(
3375 __isl_take isl_multi_val *mv,
3376 __isl_take isl_val *v);
3377 __isl_give isl_multi_val *isl_multi_val_scale_val(
3378 __isl_take isl_multi_val *mv,
3379 __isl_take isl_val *v);
3380 __isl_give isl_multi_val *isl_multi_val_scale_multi_val(
3381 __isl_take isl_multi_val *mv1,
3382 __isl_take isl_multi_val *mv2);
3383 __isl_give isl_multi_val *
3384 isl_multi_val_scale_down_multi_val(
3385 __isl_take isl_multi_val *mv1,
3386 __isl_take isl_multi_val *mv2);
3388 A multiple value can be printed using
3390 __isl_give isl_printer *isl_printer_print_multi_val(
3391 __isl_take isl_printer *p,
3392 __isl_keep isl_multi_val *mv);
3396 Vectors can be created, copied and freed using the following functions.
3398 #include <isl/vec.h>
3399 __isl_give isl_vec *isl_vec_alloc(isl_ctx *ctx,
3401 __isl_give isl_vec *isl_vec_copy(__isl_keep isl_vec *vec);
3402 void *isl_vec_free(__isl_take isl_vec *vec);
3404 Note that the elements of a newly created vector may have arbitrary values.
3405 The elements can be changed and inspected using the following functions.
3407 isl_ctx *isl_vec_get_ctx(__isl_keep isl_vec *vec);
3408 int isl_vec_size(__isl_keep isl_vec *vec);
3409 __isl_give isl_val *isl_vec_get_element_val(
3410 __isl_keep isl_vec *vec, int pos);
3411 __isl_give isl_vec *isl_vec_set_element_si(
3412 __isl_take isl_vec *vec, int pos, int v);
3413 __isl_give isl_vec *isl_vec_set_element_val(
3414 __isl_take isl_vec *vec, int pos,
3415 __isl_take isl_val *v);
3416 __isl_give isl_vec *isl_vec_set_si(__isl_take isl_vec *vec,
3418 __isl_give isl_vec *isl_vec_set_val(
3419 __isl_take isl_vec *vec, __isl_take isl_val *v);
3420 int isl_vec_cmp_element(__isl_keep isl_vec *vec1,
3421 __isl_keep isl_vec *vec2, int pos);
3423 C<isl_vec_get_element> will return a negative value if anything went wrong.
3424 In that case, the value of C<*v> is undefined.
3426 The following function can be used to concatenate two vectors.
3428 __isl_give isl_vec *isl_vec_concat(__isl_take isl_vec *vec1,
3429 __isl_take isl_vec *vec2);
3433 Matrices can be created, copied and freed using the following functions.
3435 #include <isl/mat.h>
3436 __isl_give isl_mat *isl_mat_alloc(isl_ctx *ctx,
3437 unsigned n_row, unsigned n_col);
3438 __isl_give isl_mat *isl_mat_copy(__isl_keep isl_mat *mat);
3439 void *isl_mat_free(__isl_take isl_mat *mat);
3441 Note that the elements of a newly created matrix may have arbitrary values.
3442 The elements can be changed and inspected using the following functions.
3444 isl_ctx *isl_mat_get_ctx(__isl_keep isl_mat *mat);
3445 int isl_mat_rows(__isl_keep isl_mat *mat);
3446 int isl_mat_cols(__isl_keep isl_mat *mat);
3447 __isl_give isl_val *isl_mat_get_element_val(
3448 __isl_keep isl_mat *mat, int row, int col);
3449 __isl_give isl_mat *isl_mat_set_element_si(__isl_take isl_mat *mat,
3450 int row, int col, int v);
3451 __isl_give isl_mat *isl_mat_set_element_val(
3452 __isl_take isl_mat *mat, int row, int col,
3453 __isl_take isl_val *v);
3455 C<isl_mat_get_element> will return a negative value if anything went wrong.
3456 In that case, the value of C<*v> is undefined.
3458 The following function can be used to compute the (right) inverse
3459 of a matrix, i.e., a matrix such that the product of the original
3460 and the inverse (in that order) is a multiple of the identity matrix.
3461 The input matrix is assumed to be of full row-rank.
3463 __isl_give isl_mat *isl_mat_right_inverse(__isl_take isl_mat *mat);
3465 The following function can be used to compute the (right) kernel
3466 (or null space) of a matrix, i.e., a matrix such that the product of
3467 the original and the kernel (in that order) is the zero matrix.
3469 __isl_give isl_mat *isl_mat_right_kernel(__isl_take isl_mat *mat);
3471 =head2 Piecewise Quasi Affine Expressions
3473 The zero quasi affine expression or the quasi affine expression
3474 that is equal to a given value or
3475 a specified dimension on a given domain can be created using
3477 __isl_give isl_aff *isl_aff_zero_on_domain(
3478 __isl_take isl_local_space *ls);
3479 __isl_give isl_pw_aff *isl_pw_aff_zero_on_domain(
3480 __isl_take isl_local_space *ls);
3481 __isl_give isl_aff *isl_aff_val_on_domain(
3482 __isl_take isl_local_space *ls,
3483 __isl_take isl_val *val);
3484 __isl_give isl_aff *isl_aff_var_on_domain(
3485 __isl_take isl_local_space *ls,
3486 enum isl_dim_type type, unsigned pos);
3487 __isl_give isl_pw_aff *isl_pw_aff_var_on_domain(
3488 __isl_take isl_local_space *ls,
3489 enum isl_dim_type type, unsigned pos);
3491 Note that the space in which the resulting objects live is a map space
3492 with the given space as domain and a one-dimensional range.
3494 An empty piecewise quasi affine expression (one with no cells)
3495 or a piecewise quasi affine expression with a single cell can
3496 be created using the following functions.
3498 #include <isl/aff.h>
3499 __isl_give isl_pw_aff *isl_pw_aff_empty(
3500 __isl_take isl_space *space);
3501 __isl_give isl_pw_aff *isl_pw_aff_alloc(
3502 __isl_take isl_set *set, __isl_take isl_aff *aff);
3503 __isl_give isl_pw_aff *isl_pw_aff_from_aff(
3504 __isl_take isl_aff *aff);
3506 A piecewise quasi affine expression that is equal to 1 on a set
3507 and 0 outside the set can be created using the following function.
3509 #include <isl/aff.h>
3510 __isl_give isl_pw_aff *isl_set_indicator_function(
3511 __isl_take isl_set *set);
3513 Quasi affine expressions can be copied and freed using
3515 #include <isl/aff.h>
3516 __isl_give isl_aff *isl_aff_copy(__isl_keep isl_aff *aff);
3517 void *isl_aff_free(__isl_take isl_aff *aff);
3519 __isl_give isl_pw_aff *isl_pw_aff_copy(
3520 __isl_keep isl_pw_aff *pwaff);
3521 void *isl_pw_aff_free(__isl_take isl_pw_aff *pwaff);
3523 A (rational) bound on a dimension can be extracted from an C<isl_constraint>
3524 using the following function. The constraint is required to have
3525 a non-zero coefficient for the specified dimension.
3527 #include <isl/constraint.h>
3528 __isl_give isl_aff *isl_constraint_get_bound(
3529 __isl_keep isl_constraint *constraint,
3530 enum isl_dim_type type, int pos);
3532 The entire affine expression of the constraint can also be extracted
3533 using the following function.
3535 #include <isl/constraint.h>
3536 __isl_give isl_aff *isl_constraint_get_aff(
3537 __isl_keep isl_constraint *constraint);
3539 Conversely, an equality constraint equating
3540 the affine expression to zero or an inequality constraint enforcing
3541 the affine expression to be non-negative, can be constructed using
3543 __isl_give isl_constraint *isl_equality_from_aff(
3544 __isl_take isl_aff *aff);
3545 __isl_give isl_constraint *isl_inequality_from_aff(
3546 __isl_take isl_aff *aff);
3548 The expression can be inspected using
3550 #include <isl/aff.h>
3551 isl_ctx *isl_aff_get_ctx(__isl_keep isl_aff *aff);
3552 int isl_aff_dim(__isl_keep isl_aff *aff,
3553 enum isl_dim_type type);
3554 __isl_give isl_local_space *isl_aff_get_domain_local_space(
3555 __isl_keep isl_aff *aff);
3556 __isl_give isl_local_space *isl_aff_get_local_space(
3557 __isl_keep isl_aff *aff);
3558 const char *isl_aff_get_dim_name(__isl_keep isl_aff *aff,
3559 enum isl_dim_type type, unsigned pos);
3560 const char *isl_pw_aff_get_dim_name(
3561 __isl_keep isl_pw_aff *pa,
3562 enum isl_dim_type type, unsigned pos);
3563 int isl_pw_aff_has_dim_id(__isl_keep isl_pw_aff *pa,
3564 enum isl_dim_type type, unsigned pos);
3565 __isl_give isl_id *isl_pw_aff_get_dim_id(
3566 __isl_keep isl_pw_aff *pa,
3567 enum isl_dim_type type, unsigned pos);
3568 __isl_give isl_id *isl_pw_aff_get_tuple_id(
3569 __isl_keep isl_pw_aff *pa,
3570 enum isl_dim_type type);
3571 __isl_give isl_val *isl_aff_get_constant_val(
3572 __isl_keep isl_aff *aff);
3573 __isl_give isl_val *isl_aff_get_coefficient_val(
3574 __isl_keep isl_aff *aff,
3575 enum isl_dim_type type, int pos);
3576 __isl_give isl_val *isl_aff_get_denominator_val(
3577 __isl_keep isl_aff *aff);
3578 __isl_give isl_aff *isl_aff_get_div(
3579 __isl_keep isl_aff *aff, int pos);
3581 int isl_pw_aff_n_piece(__isl_keep isl_pw_aff *pwaff);
3582 int isl_pw_aff_foreach_piece(__isl_keep isl_pw_aff *pwaff,
3583 int (*fn)(__isl_take isl_set *set,
3584 __isl_take isl_aff *aff,
3585 void *user), void *user);
3587 int isl_aff_is_cst(__isl_keep isl_aff *aff);
3588 int isl_pw_aff_is_cst(__isl_keep isl_pw_aff *pwaff);
3590 int isl_aff_involves_dims(__isl_keep isl_aff *aff,
3591 enum isl_dim_type type, unsigned first, unsigned n);
3592 int isl_pw_aff_involves_dims(__isl_keep isl_pw_aff *pwaff,
3593 enum isl_dim_type type, unsigned first, unsigned n);
3595 isl_ctx *isl_pw_aff_get_ctx(__isl_keep isl_pw_aff *pwaff);
3596 unsigned isl_pw_aff_dim(__isl_keep isl_pw_aff *pwaff,
3597 enum isl_dim_type type);
3598 int isl_pw_aff_is_empty(__isl_keep isl_pw_aff *pwaff);
3600 It can be modified using
3602 #include <isl/aff.h>
3603 __isl_give isl_pw_aff *isl_pw_aff_set_tuple_id(
3604 __isl_take isl_pw_aff *pwaff,
3605 enum isl_dim_type type, __isl_take isl_id *id);
3606 __isl_give isl_aff *isl_aff_set_dim_name(
3607 __isl_take isl_aff *aff, enum isl_dim_type type,
3608 unsigned pos, const char *s);
3609 __isl_give isl_aff *isl_aff_set_dim_id(
3610 __isl_take isl_aff *aff, enum isl_dim_type type,
3611 unsigned pos, __isl_take isl_id *id);
3612 __isl_give isl_pw_aff *isl_pw_aff_set_dim_id(
3613 __isl_take isl_pw_aff *pma,
3614 enum isl_dim_type type, unsigned pos,
3615 __isl_take isl_id *id);
3616 __isl_give isl_aff *isl_aff_set_constant_si(
3617 __isl_take isl_aff *aff, int v);
3618 __isl_give isl_aff *isl_aff_set_constant_val(
3619 __isl_take isl_aff *aff, __isl_take isl_val *v);
3620 __isl_give isl_aff *isl_aff_set_coefficient_si(
3621 __isl_take isl_aff *aff,
3622 enum isl_dim_type type, int pos, int v);
3623 __isl_give isl_aff *isl_aff_set_coefficient_val(
3624 __isl_take isl_aff *aff,
3625 enum isl_dim_type type, int pos,
3626 __isl_take isl_val *v);
3628 __isl_give isl_aff *isl_aff_add_constant_si(
3629 __isl_take isl_aff *aff, int v);
3630 __isl_give isl_aff *isl_aff_add_constant_val(
3631 __isl_take isl_aff *aff, __isl_take isl_val *v);
3632 __isl_give isl_aff *isl_aff_add_constant_num_si(
3633 __isl_take isl_aff *aff, int v);
3634 __isl_give isl_aff *isl_aff_add_coefficient_si(
3635 __isl_take isl_aff *aff,
3636 enum isl_dim_type type, int pos, int v);
3637 __isl_give isl_aff *isl_aff_add_coefficient_val(
3638 __isl_take isl_aff *aff,
3639 enum isl_dim_type type, int pos,
3640 __isl_take isl_val *v);
3642 __isl_give isl_aff *isl_aff_insert_dims(
3643 __isl_take isl_aff *aff,
3644 enum isl_dim_type type, unsigned first, unsigned n);
3645 __isl_give isl_pw_aff *isl_pw_aff_insert_dims(
3646 __isl_take isl_pw_aff *pwaff,
3647 enum isl_dim_type type, unsigned first, unsigned n);
3648 __isl_give isl_aff *isl_aff_add_dims(
3649 __isl_take isl_aff *aff,
3650 enum isl_dim_type type, unsigned n);
3651 __isl_give isl_pw_aff *isl_pw_aff_add_dims(
3652 __isl_take isl_pw_aff *pwaff,
3653 enum isl_dim_type type, unsigned n);
3654 __isl_give isl_aff *isl_aff_drop_dims(
3655 __isl_take isl_aff *aff,
3656 enum isl_dim_type type, unsigned first, unsigned n);
3657 __isl_give isl_pw_aff *isl_pw_aff_drop_dims(
3658 __isl_take isl_pw_aff *pwaff,
3659 enum isl_dim_type type, unsigned first, unsigned n);
3660 __isl_give isl_aff *isl_aff_move_dims(
3661 __isl_take isl_aff *aff,
3662 enum isl_dim_type dst_type, unsigned dst_pos,
3663 enum isl_dim_type src_type, unsigned src_pos,
3665 __isl_give isl_pw_aff *isl_pw_aff_move_dims(
3666 __isl_take isl_pw_aff *pa,
3667 enum isl_dim_type dst_type, unsigned dst_pos,
3668 enum isl_dim_type src_type, unsigned src_pos,
3671 Note that C<isl_aff_set_constant_si> and C<isl_aff_set_coefficient_si>
3672 set the I<numerator> of the constant or coefficient, while
3673 C<isl_aff_set_constant_val> and C<isl_aff_set_coefficient_val> set
3674 the constant or coefficient as a whole.
3675 The C<add_constant> and C<add_coefficient> functions add an integer
3676 or rational value to
3677 the possibly rational constant or coefficient.
3678 The C<add_constant_num> functions add an integer value to
3681 To check whether an affine expressions is obviously zero
3682 or obviously equal to some other affine expression, use
3684 #include <isl/aff.h>
3685 int isl_aff_plain_is_zero(__isl_keep isl_aff *aff);
3686 int isl_aff_plain_is_equal(__isl_keep isl_aff *aff1,
3687 __isl_keep isl_aff *aff2);
3688 int isl_pw_aff_plain_is_equal(
3689 __isl_keep isl_pw_aff *pwaff1,
3690 __isl_keep isl_pw_aff *pwaff2);
3694 #include <isl/aff.h>
3695 __isl_give isl_aff *isl_aff_add(__isl_take isl_aff *aff1,
3696 __isl_take isl_aff *aff2);
3697 __isl_give isl_pw_aff *isl_pw_aff_add(
3698 __isl_take isl_pw_aff *pwaff1,
3699 __isl_take isl_pw_aff *pwaff2);
3700 __isl_give isl_pw_aff *isl_pw_aff_min(
3701 __isl_take isl_pw_aff *pwaff1,
3702 __isl_take isl_pw_aff *pwaff2);
3703 __isl_give isl_pw_aff *isl_pw_aff_max(
3704 __isl_take isl_pw_aff *pwaff1,
3705 __isl_take isl_pw_aff *pwaff2);
3706 __isl_give isl_aff *isl_aff_sub(__isl_take isl_aff *aff1,
3707 __isl_take isl_aff *aff2);
3708 __isl_give isl_pw_aff *isl_pw_aff_sub(
3709 __isl_take isl_pw_aff *pwaff1,
3710 __isl_take isl_pw_aff *pwaff2);
3711 __isl_give isl_aff *isl_aff_neg(__isl_take isl_aff *aff);
3712 __isl_give isl_pw_aff *isl_pw_aff_neg(
3713 __isl_take isl_pw_aff *pwaff);
3714 __isl_give isl_aff *isl_aff_ceil(__isl_take isl_aff *aff);
3715 __isl_give isl_pw_aff *isl_pw_aff_ceil(
3716 __isl_take isl_pw_aff *pwaff);
3717 __isl_give isl_aff *isl_aff_floor(__isl_take isl_aff *aff);
3718 __isl_give isl_pw_aff *isl_pw_aff_floor(
3719 __isl_take isl_pw_aff *pwaff);
3720 __isl_give isl_aff *isl_aff_mod_val(__isl_take isl_aff *aff,
3721 __isl_take isl_val *mod);
3722 __isl_give isl_pw_aff *isl_pw_aff_mod_val(
3723 __isl_take isl_pw_aff *pa,
3724 __isl_take isl_val *mod);
3725 __isl_give isl_aff *isl_aff_scale_val(__isl_take isl_aff *aff,
3726 __isl_take isl_val *v);
3727 __isl_give isl_pw_aff *isl_pw_aff_scale_val(
3728 __isl_take isl_pw_aff *pa, __isl_take isl_val *v);
3729 __isl_give isl_aff *isl_aff_scale_down_ui(
3730 __isl_take isl_aff *aff, unsigned f);
3731 __isl_give isl_aff *isl_aff_scale_down_val(
3732 __isl_take isl_aff *aff, __isl_take isl_val *v);
3733 __isl_give isl_pw_aff *isl_pw_aff_scale_down_val(
3734 __isl_take isl_pw_aff *pa,
3735 __isl_take isl_val *f);
3737 __isl_give isl_pw_aff *isl_pw_aff_list_min(
3738 __isl_take isl_pw_aff_list *list);
3739 __isl_give isl_pw_aff *isl_pw_aff_list_max(
3740 __isl_take isl_pw_aff_list *list);
3742 __isl_give isl_pw_aff *isl_pw_aff_coalesce(
3743 __isl_take isl_pw_aff *pwqp);
3745 __isl_give isl_aff *isl_aff_align_params(
3746 __isl_take isl_aff *aff,
3747 __isl_take isl_space *model);
3748 __isl_give isl_pw_aff *isl_pw_aff_align_params(
3749 __isl_take isl_pw_aff *pwaff,
3750 __isl_take isl_space *model);
3752 __isl_give isl_aff *isl_aff_project_domain_on_params(
3753 __isl_take isl_aff *aff);
3755 __isl_give isl_aff *isl_aff_gist_params(
3756 __isl_take isl_aff *aff,
3757 __isl_take isl_set *context);
3758 __isl_give isl_aff *isl_aff_gist(__isl_take isl_aff *aff,
3759 __isl_take isl_set *context);
3760 __isl_give isl_pw_aff *isl_pw_aff_gist_params(
3761 __isl_take isl_pw_aff *pwaff,
3762 __isl_take isl_set *context);
3763 __isl_give isl_pw_aff *isl_pw_aff_gist(
3764 __isl_take isl_pw_aff *pwaff,
3765 __isl_take isl_set *context);
3767 __isl_give isl_set *isl_pw_aff_domain(
3768 __isl_take isl_pw_aff *pwaff);
3769 __isl_give isl_pw_aff *isl_pw_aff_intersect_domain(
3770 __isl_take isl_pw_aff *pa,
3771 __isl_take isl_set *set);
3772 __isl_give isl_pw_aff *isl_pw_aff_intersect_params(
3773 __isl_take isl_pw_aff *pa,
3774 __isl_take isl_set *set);
3776 __isl_give isl_aff *isl_aff_mul(__isl_take isl_aff *aff1,
3777 __isl_take isl_aff *aff2);
3778 __isl_give isl_aff *isl_aff_div(__isl_take isl_aff *aff1,
3779 __isl_take isl_aff *aff2);
3780 __isl_give isl_pw_aff *isl_pw_aff_mul(
3781 __isl_take isl_pw_aff *pwaff1,
3782 __isl_take isl_pw_aff *pwaff2);
3783 __isl_give isl_pw_aff *isl_pw_aff_div(
3784 __isl_take isl_pw_aff *pa1,
3785 __isl_take isl_pw_aff *pa2);
3786 __isl_give isl_pw_aff *isl_pw_aff_tdiv_q(
3787 __isl_take isl_pw_aff *pa1,
3788 __isl_take isl_pw_aff *pa2);
3789 __isl_give isl_pw_aff *isl_pw_aff_tdiv_r(
3790 __isl_take isl_pw_aff *pa1,
3791 __isl_take isl_pw_aff *pa2);
3793 When multiplying two affine expressions, at least one of the two needs
3794 to be a constant. Similarly, when dividing an affine expression by another,
3795 the second expression needs to be a constant.
3796 C<isl_pw_aff_tdiv_q> computes the quotient of an integer division with
3797 rounding towards zero. C<isl_pw_aff_tdiv_r> computes the corresponding
3800 #include <isl/aff.h>
3801 __isl_give isl_aff *isl_aff_pullback_multi_aff(
3802 __isl_take isl_aff *aff,
3803 __isl_take isl_multi_aff *ma);
3804 __isl_give isl_pw_aff *isl_pw_aff_pullback_multi_aff(
3805 __isl_take isl_pw_aff *pa,
3806 __isl_take isl_multi_aff *ma);
3807 __isl_give isl_pw_aff *isl_pw_aff_pullback_pw_multi_aff(
3808 __isl_take isl_pw_aff *pa,
3809 __isl_take isl_pw_multi_aff *pma);
3811 These functions precompose the input expression by the given
3812 C<isl_multi_aff> or C<isl_pw_multi_aff>. In other words,
3813 the C<isl_multi_aff> or C<isl_pw_multi_aff> is plugged
3814 into the (piecewise) affine expression.
3815 Objects of type C<isl_multi_aff> are described in
3816 L</"Piecewise Multiple Quasi Affine Expressions">.
3818 #include <isl/aff.h>
3819 __isl_give isl_basic_set *isl_aff_zero_basic_set(
3820 __isl_take isl_aff *aff);
3821 __isl_give isl_basic_set *isl_aff_neg_basic_set(
3822 __isl_take isl_aff *aff);
3823 __isl_give isl_basic_set *isl_aff_le_basic_set(
3824 __isl_take isl_aff *aff1, __isl_take isl_aff *aff2);
3825 __isl_give isl_basic_set *isl_aff_ge_basic_set(
3826 __isl_take isl_aff *aff1, __isl_take isl_aff *aff2);
3827 __isl_give isl_set *isl_pw_aff_eq_set(
3828 __isl_take isl_pw_aff *pwaff1,
3829 __isl_take isl_pw_aff *pwaff2);
3830 __isl_give isl_set *isl_pw_aff_ne_set(
3831 __isl_take isl_pw_aff *pwaff1,
3832 __isl_take isl_pw_aff *pwaff2);
3833 __isl_give isl_set *isl_pw_aff_le_set(
3834 __isl_take isl_pw_aff *pwaff1,
3835 __isl_take isl_pw_aff *pwaff2);
3836 __isl_give isl_set *isl_pw_aff_lt_set(
3837 __isl_take isl_pw_aff *pwaff1,
3838 __isl_take isl_pw_aff *pwaff2);
3839 __isl_give isl_set *isl_pw_aff_ge_set(
3840 __isl_take isl_pw_aff *pwaff1,
3841 __isl_take isl_pw_aff *pwaff2);
3842 __isl_give isl_set *isl_pw_aff_gt_set(
3843 __isl_take isl_pw_aff *pwaff1,
3844 __isl_take isl_pw_aff *pwaff2);
3846 __isl_give isl_set *isl_pw_aff_list_eq_set(
3847 __isl_take isl_pw_aff_list *list1,
3848 __isl_take isl_pw_aff_list *list2);
3849 __isl_give isl_set *isl_pw_aff_list_ne_set(
3850 __isl_take isl_pw_aff_list *list1,
3851 __isl_take isl_pw_aff_list *list2);
3852 __isl_give isl_set *isl_pw_aff_list_le_set(
3853 __isl_take isl_pw_aff_list *list1,
3854 __isl_take isl_pw_aff_list *list2);
3855 __isl_give isl_set *isl_pw_aff_list_lt_set(
3856 __isl_take isl_pw_aff_list *list1,
3857 __isl_take isl_pw_aff_list *list2);
3858 __isl_give isl_set *isl_pw_aff_list_ge_set(
3859 __isl_take isl_pw_aff_list *list1,
3860 __isl_take isl_pw_aff_list *list2);
3861 __isl_give isl_set *isl_pw_aff_list_gt_set(
3862 __isl_take isl_pw_aff_list *list1,
3863 __isl_take isl_pw_aff_list *list2);
3865 The function C<isl_aff_neg_basic_set> returns a basic set
3866 containing those elements in the domain space
3867 of C<aff> where C<aff> is negative.
3868 The function C<isl_aff_ge_basic_set> returns a basic set
3869 containing those elements in the shared space
3870 of C<aff1> and C<aff2> where C<aff1> is greater than or equal to C<aff2>.
3871 The function C<isl_pw_aff_ge_set> returns a set
3872 containing those elements in the shared domain
3873 of C<pwaff1> and C<pwaff2> where C<pwaff1> is greater than or equal to C<pwaff2>.
3874 The functions operating on C<isl_pw_aff_list> apply the corresponding
3875 C<isl_pw_aff> function to each pair of elements in the two lists.
3877 #include <isl/aff.h>
3878 __isl_give isl_set *isl_pw_aff_nonneg_set(
3879 __isl_take isl_pw_aff *pwaff);
3880 __isl_give isl_set *isl_pw_aff_zero_set(
3881 __isl_take isl_pw_aff *pwaff);
3882 __isl_give isl_set *isl_pw_aff_non_zero_set(
3883 __isl_take isl_pw_aff *pwaff);
3885 The function C<isl_pw_aff_nonneg_set> returns a set
3886 containing those elements in the domain
3887 of C<pwaff> where C<pwaff> is non-negative.
3889 #include <isl/aff.h>
3890 __isl_give isl_pw_aff *isl_pw_aff_cond(
3891 __isl_take isl_pw_aff *cond,
3892 __isl_take isl_pw_aff *pwaff_true,
3893 __isl_take isl_pw_aff *pwaff_false);
3895 The function C<isl_pw_aff_cond> performs a conditional operator
3896 and returns an expression that is equal to C<pwaff_true>
3897 for elements where C<cond> is non-zero and equal to C<pwaff_false> for elements
3898 where C<cond> is zero.
3900 #include <isl/aff.h>
3901 __isl_give isl_pw_aff *isl_pw_aff_union_min(
3902 __isl_take isl_pw_aff *pwaff1,
3903 __isl_take isl_pw_aff *pwaff2);
3904 __isl_give isl_pw_aff *isl_pw_aff_union_max(
3905 __isl_take isl_pw_aff *pwaff1,
3906 __isl_take isl_pw_aff *pwaff2);
3907 __isl_give isl_pw_aff *isl_pw_aff_union_add(
3908 __isl_take isl_pw_aff *pwaff1,
3909 __isl_take isl_pw_aff *pwaff2);
3911 The function C<isl_pw_aff_union_max> computes a piecewise quasi-affine
3912 expression with a domain that is the union of those of C<pwaff1> and
3913 C<pwaff2> and such that on each cell, the quasi-affine expression is
3914 the maximum of those of C<pwaff1> and C<pwaff2>. If only one of
3915 C<pwaff1> or C<pwaff2> is defined on a given cell, then the
3916 associated expression is the defined one.
3918 An expression can be read from input using
3920 #include <isl/aff.h>
3921 __isl_give isl_aff *isl_aff_read_from_str(
3922 isl_ctx *ctx, const char *str);
3923 __isl_give isl_pw_aff *isl_pw_aff_read_from_str(
3924 isl_ctx *ctx, const char *str);
3926 An expression can be printed using
3928 #include <isl/aff.h>
3929 __isl_give isl_printer *isl_printer_print_aff(
3930 __isl_take isl_printer *p, __isl_keep isl_aff *aff);
3932 __isl_give isl_printer *isl_printer_print_pw_aff(
3933 __isl_take isl_printer *p,
3934 __isl_keep isl_pw_aff *pwaff);
3936 =head2 Piecewise Multiple Quasi Affine Expressions
3938 An C<isl_multi_aff> object represents a sequence of
3939 zero or more affine expressions, all defined on the same domain space.
3940 Similarly, an C<isl_multi_pw_aff> object represents a sequence of
3941 zero or more piecewise affine expressions.
3943 An C<isl_multi_aff> can be constructed from a single
3944 C<isl_aff> or an C<isl_aff_list> using the
3945 following functions. Similarly for C<isl_multi_pw_aff>.
3947 #include <isl/aff.h>
3948 __isl_give isl_multi_aff *isl_multi_aff_from_aff(
3949 __isl_take isl_aff *aff);
3950 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_pw_aff(
3951 __isl_take isl_pw_aff *pa);
3952 __isl_give isl_multi_aff *isl_multi_aff_from_aff_list(
3953 __isl_take isl_space *space,
3954 __isl_take isl_aff_list *list);
3956 An empty piecewise multiple quasi affine expression (one with no cells),
3957 the zero piecewise multiple quasi affine expression (with value zero
3958 for each output dimension),
3959 a piecewise multiple quasi affine expression with a single cell (with
3960 either a universe or a specified domain) or
3961 a zero-dimensional piecewise multiple quasi affine expression
3963 can be created using the following functions.
3965 #include <isl/aff.h>
3966 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_empty(
3967 __isl_take isl_space *space);
3968 __isl_give isl_multi_aff *isl_multi_aff_zero(
3969 __isl_take isl_space *space);
3970 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_zero(
3971 __isl_take isl_space *space);
3972 __isl_give isl_multi_aff *isl_multi_aff_identity(
3973 __isl_take isl_space *space);
3974 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_identity(
3975 __isl_take isl_space *space);
3976 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_identity(
3977 __isl_take isl_space *space);
3978 __isl_give isl_pw_multi_aff *
3979 isl_pw_multi_aff_from_multi_aff(
3980 __isl_take isl_multi_aff *ma);
3981 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_alloc(
3982 __isl_take isl_set *set,
3983 __isl_take isl_multi_aff *maff);
3984 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_domain(
3985 __isl_take isl_set *set);
3987 __isl_give isl_union_pw_multi_aff *
3988 isl_union_pw_multi_aff_empty(
3989 __isl_take isl_space *space);
3990 __isl_give isl_union_pw_multi_aff *
3991 isl_union_pw_multi_aff_add_pw_multi_aff(
3992 __isl_take isl_union_pw_multi_aff *upma,
3993 __isl_take isl_pw_multi_aff *pma);
3994 __isl_give isl_union_pw_multi_aff *
3995 isl_union_pw_multi_aff_from_domain(
3996 __isl_take isl_union_set *uset);
3998 A piecewise multiple quasi affine expression can also be initialized
3999 from an C<isl_set> or C<isl_map>, provided the C<isl_set> is a singleton
4000 and the C<isl_map> is single-valued.
4001 In case of a conversion from an C<isl_union_set> or an C<isl_union_map>
4002 to an C<isl_union_pw_multi_aff>, these properties need to hold in each space.
4004 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_set(
4005 __isl_take isl_set *set);
4006 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_map(
4007 __isl_take isl_map *map);
4009 __isl_give isl_union_pw_multi_aff *
4010 isl_union_pw_multi_aff_from_union_set(
4011 __isl_take isl_union_set *uset);
4012 __isl_give isl_union_pw_multi_aff *
4013 isl_union_pw_multi_aff_from_union_map(
4014 __isl_take isl_union_map *umap);
4016 Multiple quasi affine expressions can be copied and freed using
4018 #include <isl/aff.h>
4019 __isl_give isl_multi_aff *isl_multi_aff_copy(
4020 __isl_keep isl_multi_aff *maff);
4021 void *isl_multi_aff_free(__isl_take isl_multi_aff *maff);
4023 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_copy(
4024 __isl_keep isl_pw_multi_aff *pma);
4025 void *isl_pw_multi_aff_free(
4026 __isl_take isl_pw_multi_aff *pma);
4028 __isl_give isl_union_pw_multi_aff *
4029 isl_union_pw_multi_aff_copy(
4030 __isl_keep isl_union_pw_multi_aff *upma);
4031 void *isl_union_pw_multi_aff_free(
4032 __isl_take isl_union_pw_multi_aff *upma);
4034 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_copy(
4035 __isl_keep isl_multi_pw_aff *mpa);
4036 void *isl_multi_pw_aff_free(
4037 __isl_take isl_multi_pw_aff *mpa);
4039 The expression can be inspected using
4041 #include <isl/aff.h>
4042 isl_ctx *isl_multi_aff_get_ctx(
4043 __isl_keep isl_multi_aff *maff);
4044 isl_ctx *isl_pw_multi_aff_get_ctx(
4045 __isl_keep isl_pw_multi_aff *pma);
4046 isl_ctx *isl_union_pw_multi_aff_get_ctx(
4047 __isl_keep isl_union_pw_multi_aff *upma);
4048 isl_ctx *isl_multi_pw_aff_get_ctx(
4049 __isl_keep isl_multi_pw_aff *mpa);
4050 unsigned isl_multi_aff_dim(__isl_keep isl_multi_aff *maff,
4051 enum isl_dim_type type);
4052 unsigned isl_pw_multi_aff_dim(
4053 __isl_keep isl_pw_multi_aff *pma,
4054 enum isl_dim_type type);
4055 unsigned isl_multi_pw_aff_dim(
4056 __isl_keep isl_multi_pw_aff *mpa,
4057 enum isl_dim_type type);
4058 __isl_give isl_aff *isl_multi_aff_get_aff(
4059 __isl_keep isl_multi_aff *multi, int pos);
4060 __isl_give isl_pw_aff *isl_pw_multi_aff_get_pw_aff(
4061 __isl_keep isl_pw_multi_aff *pma, int pos);
4062 __isl_give isl_pw_aff *isl_multi_pw_aff_get_pw_aff(
4063 __isl_keep isl_multi_pw_aff *mpa, int pos);
4064 int isl_multi_aff_find_dim_by_id(
4065 __isl_keep isl_multi_aff *ma,
4066 enum isl_dim_type type, __isl_keep isl_id *id);
4067 int isl_multi_pw_aff_find_dim_by_id(
4068 __isl_keep isl_multi_pw_aff *mpa,
4069 enum isl_dim_type type, __isl_keep isl_id *id);
4070 const char *isl_pw_multi_aff_get_dim_name(
4071 __isl_keep isl_pw_multi_aff *pma,
4072 enum isl_dim_type type, unsigned pos);
4073 __isl_give isl_id *isl_multi_aff_get_dim_id(
4074 __isl_keep isl_multi_aff *ma,
4075 enum isl_dim_type type, unsigned pos);
4076 __isl_give isl_id *isl_pw_multi_aff_get_dim_id(
4077 __isl_keep isl_pw_multi_aff *pma,
4078 enum isl_dim_type type, unsigned pos);
4079 __isl_give isl_id *isl_multi_pw_aff_get_dim_id(
4080 __isl_keep isl_multi_pw_aff *mpa,
4081 enum isl_dim_type type, unsigned pos);
4082 const char *isl_multi_aff_get_tuple_name(
4083 __isl_keep isl_multi_aff *multi,
4084 enum isl_dim_type type);
4085 int isl_pw_multi_aff_has_tuple_name(
4086 __isl_keep isl_pw_multi_aff *pma,
4087 enum isl_dim_type type);
4088 const char *isl_pw_multi_aff_get_tuple_name(
4089 __isl_keep isl_pw_multi_aff *pma,
4090 enum isl_dim_type type);
4091 int isl_multi_aff_has_tuple_id(__isl_keep isl_multi_aff *ma,
4092 enum isl_dim_type type);
4093 int isl_pw_multi_aff_has_tuple_id(
4094 __isl_keep isl_pw_multi_aff *pma,
4095 enum isl_dim_type type);
4096 int isl_multi_pw_aff_has_tuple_id(
4097 __isl_keep isl_multi_pw_aff *mpa,
4098 enum isl_dim_type type);
4099 __isl_give isl_id *isl_multi_aff_get_tuple_id(
4100 __isl_keep isl_multi_aff *ma,
4101 enum isl_dim_type type);
4102 __isl_give isl_id *isl_pw_multi_aff_get_tuple_id(
4103 __isl_keep isl_pw_multi_aff *pma,
4104 enum isl_dim_type type);
4105 __isl_give isl_id *isl_multi_pw_aff_get_tuple_id(
4106 __isl_keep isl_multi_pw_aff *mpa,
4107 enum isl_dim_type type);
4108 __isl_give isl_multi_aff *isl_multi_aff_reset_tuple_id(
4109 __isl_take isl_multi_aff *ma,
4110 enum isl_dim_type type);
4111 __isl_give isl_multi_pw_aff *
4112 isl_multi_pw_aff_reset_tuple_id(
4113 __isl_take isl_multi_pw_aff *mpa,
4114 enum isl_dim_type type);
4116 int isl_pw_multi_aff_foreach_piece(
4117 __isl_keep isl_pw_multi_aff *pma,
4118 int (*fn)(__isl_take isl_set *set,
4119 __isl_take isl_multi_aff *maff,
4120 void *user), void *user);
4122 int isl_union_pw_multi_aff_foreach_pw_multi_aff(
4123 __isl_keep isl_union_pw_multi_aff *upma,
4124 int (*fn)(__isl_take isl_pw_multi_aff *pma,
4125 void *user), void *user);
4127 It can be modified using
4129 #include <isl/aff.h>
4130 __isl_give isl_multi_aff *isl_multi_aff_set_aff(
4131 __isl_take isl_multi_aff *multi, int pos,
4132 __isl_take isl_aff *aff);
4133 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_pw_aff(
4134 __isl_take isl_pw_multi_aff *pma, unsigned pos,
4135 __isl_take isl_pw_aff *pa);
4136 __isl_give isl_multi_aff *isl_multi_aff_set_dim_name(
4137 __isl_take isl_multi_aff *maff,
4138 enum isl_dim_type type, unsigned pos, const char *s);
4139 __isl_give isl_multi_aff *isl_multi_aff_set_dim_id(
4140 __isl_take isl_multi_aff *maff,
4141 enum isl_dim_type type, unsigned pos,
4142 __isl_take isl_id *id);
4143 __isl_give isl_multi_aff *isl_multi_aff_set_tuple_name(
4144 __isl_take isl_multi_aff *maff,
4145 enum isl_dim_type type, const char *s);
4146 __isl_give isl_multi_aff *isl_multi_aff_set_tuple_id(
4147 __isl_take isl_multi_aff *maff,
4148 enum isl_dim_type type, __isl_take isl_id *id);
4149 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_tuple_id(
4150 __isl_take isl_pw_multi_aff *pma,
4151 enum isl_dim_type type, __isl_take isl_id *id);
4153 __isl_give isl_multi_pw_aff *
4154 isl_multi_pw_aff_set_dim_name(
4155 __isl_take isl_multi_pw_aff *mpa,
4156 enum isl_dim_type type, unsigned pos, const char *s);
4157 __isl_give isl_multi_pw_aff *
4158 isl_multi_pw_aff_set_dim_id(
4159 __isl_take isl_multi_pw_aff *mpa,
4160 enum isl_dim_type type, unsigned pos,
4161 __isl_take isl_id *id);
4162 __isl_give isl_multi_pw_aff *
4163 isl_multi_pw_aff_set_tuple_name(
4164 __isl_take isl_multi_pw_aff *mpa,
4165 enum isl_dim_type type, const char *s);
4167 __isl_give isl_multi_aff *isl_multi_aff_insert_dims(
4168 __isl_take isl_multi_aff *ma,
4169 enum isl_dim_type type, unsigned first, unsigned n);
4170 __isl_give isl_multi_aff *isl_multi_aff_add_dims(
4171 __isl_take isl_multi_aff *ma,
4172 enum isl_dim_type type, unsigned n);
4173 __isl_give isl_multi_aff *isl_multi_aff_drop_dims(
4174 __isl_take isl_multi_aff *maff,
4175 enum isl_dim_type type, unsigned first, unsigned n);
4176 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_drop_dims(
4177 __isl_take isl_pw_multi_aff *pma,
4178 enum isl_dim_type type, unsigned first, unsigned n);
4180 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_insert_dims(
4181 __isl_take isl_multi_pw_aff *mpa,
4182 enum isl_dim_type type, unsigned first, unsigned n);
4183 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_add_dims(
4184 __isl_take isl_multi_pw_aff *mpa,
4185 enum isl_dim_type type, unsigned n);
4186 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_move_dims(
4187 __isl_take isl_multi_pw_aff *pma,
4188 enum isl_dim_type dst_type, unsigned dst_pos,
4189 enum isl_dim_type src_type, unsigned src_pos,
4192 To check whether two multiple affine expressions are
4193 obviously equal to each other, use
4195 int isl_multi_aff_plain_is_equal(__isl_keep isl_multi_aff *maff1,
4196 __isl_keep isl_multi_aff *maff2);
4197 int isl_pw_multi_aff_plain_is_equal(
4198 __isl_keep isl_pw_multi_aff *pma1,
4199 __isl_keep isl_pw_multi_aff *pma2);
4203 #include <isl/aff.h>
4204 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmin(
4205 __isl_take isl_pw_multi_aff *pma1,
4206 __isl_take isl_pw_multi_aff *pma2);
4207 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmax(
4208 __isl_take isl_pw_multi_aff *pma1,
4209 __isl_take isl_pw_multi_aff *pma2);
4210 __isl_give isl_multi_aff *isl_multi_aff_add(
4211 __isl_take isl_multi_aff *maff1,
4212 __isl_take isl_multi_aff *maff2);
4213 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_add(
4214 __isl_take isl_pw_multi_aff *pma1,
4215 __isl_take isl_pw_multi_aff *pma2);
4216 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_add(
4217 __isl_take isl_union_pw_multi_aff *upma1,
4218 __isl_take isl_union_pw_multi_aff *upma2);
4219 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_add(
4220 __isl_take isl_pw_multi_aff *pma1,
4221 __isl_take isl_pw_multi_aff *pma2);
4222 __isl_give isl_multi_aff *isl_multi_aff_sub(
4223 __isl_take isl_multi_aff *ma1,
4224 __isl_take isl_multi_aff *ma2);
4225 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_sub(
4226 __isl_take isl_pw_multi_aff *pma1,
4227 __isl_take isl_pw_multi_aff *pma2);
4228 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_sub(
4229 __isl_take isl_union_pw_multi_aff *upma1,
4230 __isl_take isl_union_pw_multi_aff *upma2);
4232 C<isl_multi_aff_sub> subtracts the second argument from the first.
4234 __isl_give isl_multi_aff *isl_multi_aff_scale_val(
4235 __isl_take isl_multi_aff *ma,
4236 __isl_take isl_val *v);
4237 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_val(
4238 __isl_take isl_pw_multi_aff *pma,
4239 __isl_take isl_val *v);
4240 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_scale_val(
4241 __isl_take isl_multi_pw_aff *mpa,
4242 __isl_take isl_val *v);
4243 __isl_give isl_multi_aff *isl_multi_aff_scale_multi_val(
4244 __isl_take isl_multi_aff *ma,
4245 __isl_take isl_multi_val *mv);
4246 __isl_give isl_pw_multi_aff *
4247 isl_pw_multi_aff_scale_multi_val(
4248 __isl_take isl_pw_multi_aff *pma,
4249 __isl_take isl_multi_val *mv);
4250 __isl_give isl_multi_pw_aff *
4251 isl_multi_pw_aff_scale_multi_val(
4252 __isl_take isl_multi_pw_aff *mpa,
4253 __isl_take isl_multi_val *mv);
4254 __isl_give isl_union_pw_multi_aff *
4255 isl_union_pw_multi_aff_scale_multi_val(
4256 __isl_take isl_union_pw_multi_aff *upma,
4257 __isl_take isl_multi_val *mv);
4258 __isl_give isl_multi_aff *
4259 isl_multi_aff_scale_down_multi_val(
4260 __isl_take isl_multi_aff *ma,
4261 __isl_take isl_multi_val *mv);
4262 __isl_give isl_multi_pw_aff *
4263 isl_multi_pw_aff_scale_down_multi_val(
4264 __isl_take isl_multi_pw_aff *mpa,
4265 __isl_take isl_multi_val *mv);
4267 C<isl_multi_aff_scale_multi_val> scales the elements of C<ma>
4268 by the corresponding elements of C<mv>.
4270 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_params(
4271 __isl_take isl_pw_multi_aff *pma,
4272 __isl_take isl_set *set);
4273 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_domain(
4274 __isl_take isl_pw_multi_aff *pma,
4275 __isl_take isl_set *set);
4276 __isl_give isl_union_pw_multi_aff *
4277 isl_union_pw_multi_aff_intersect_domain(
4278 __isl_take isl_union_pw_multi_aff *upma,
4279 __isl_take isl_union_set *uset);
4280 __isl_give isl_multi_aff *isl_multi_aff_lift(
4281 __isl_take isl_multi_aff *maff,
4282 __isl_give isl_local_space **ls);
4283 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_coalesce(
4284 __isl_take isl_pw_multi_aff *pma);
4285 __isl_give isl_multi_aff *isl_multi_aff_align_params(
4286 __isl_take isl_multi_aff *multi,
4287 __isl_take isl_space *model);
4288 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_align_params(
4289 __isl_take isl_pw_multi_aff *pma,
4290 __isl_take isl_space *model);
4291 __isl_give isl_pw_multi_aff *
4292 isl_pw_multi_aff_project_domain_on_params(
4293 __isl_take isl_pw_multi_aff *pma);
4294 __isl_give isl_multi_aff *isl_multi_aff_gist_params(
4295 __isl_take isl_multi_aff *maff,
4296 __isl_take isl_set *context);
4297 __isl_give isl_multi_aff *isl_multi_aff_gist(
4298 __isl_take isl_multi_aff *maff,
4299 __isl_take isl_set *context);
4300 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist_params(
4301 __isl_take isl_pw_multi_aff *pma,
4302 __isl_take isl_set *set);
4303 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist(
4304 __isl_take isl_pw_multi_aff *pma,
4305 __isl_take isl_set *set);
4306 __isl_give isl_multi_aff *isl_multi_aff_from_range(
4307 __isl_take isl_multi_aff *ma);
4308 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_range(
4309 __isl_take isl_multi_pw_aff *mpa);
4310 __isl_give isl_set *isl_pw_multi_aff_domain(
4311 __isl_take isl_pw_multi_aff *pma);
4312 __isl_give isl_union_set *isl_union_pw_multi_aff_domain(
4313 __isl_take isl_union_pw_multi_aff *upma);
4314 __isl_give isl_multi_aff *isl_multi_aff_range_splice(
4315 __isl_take isl_multi_aff *ma1, unsigned pos,
4316 __isl_take isl_multi_aff *ma2);
4317 __isl_give isl_multi_aff *isl_multi_aff_splice(
4318 __isl_take isl_multi_aff *ma1,
4319 unsigned in_pos, unsigned out_pos,
4320 __isl_take isl_multi_aff *ma2);
4321 __isl_give isl_multi_aff *isl_multi_aff_range_product(
4322 __isl_take isl_multi_aff *ma1,
4323 __isl_take isl_multi_aff *ma2);
4324 __isl_give isl_multi_aff *isl_multi_aff_flat_range_product(
4325 __isl_take isl_multi_aff *ma1,
4326 __isl_take isl_multi_aff *ma2);
4327 __isl_give isl_multi_aff *isl_multi_aff_product(
4328 __isl_take isl_multi_aff *ma1,
4329 __isl_take isl_multi_aff *ma2);
4330 __isl_give isl_pw_multi_aff *
4331 isl_pw_multi_aff_range_product(
4332 __isl_take isl_pw_multi_aff *pma1,
4333 __isl_take isl_pw_multi_aff *pma2);
4334 __isl_give isl_pw_multi_aff *
4335 isl_pw_multi_aff_flat_range_product(
4336 __isl_take isl_pw_multi_aff *pma1,
4337 __isl_take isl_pw_multi_aff *pma2);
4338 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_product(
4339 __isl_take isl_pw_multi_aff *pma1,
4340 __isl_take isl_pw_multi_aff *pma2);
4341 __isl_give isl_union_pw_multi_aff *
4342 isl_union_pw_multi_aff_flat_range_product(
4343 __isl_take isl_union_pw_multi_aff *upma1,
4344 __isl_take isl_union_pw_multi_aff *upma2);
4345 __isl_give isl_multi_pw_aff *
4346 isl_multi_pw_aff_range_splice(
4347 __isl_take isl_multi_pw_aff *mpa1, unsigned pos,
4348 __isl_take isl_multi_pw_aff *mpa2);
4349 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_splice(
4350 __isl_take isl_multi_pw_aff *mpa1,
4351 unsigned in_pos, unsigned out_pos,
4352 __isl_take isl_multi_pw_aff *mpa2);
4353 __isl_give isl_multi_pw_aff *
4354 isl_multi_pw_aff_range_product(
4355 __isl_take isl_multi_pw_aff *mpa1,
4356 __isl_take isl_multi_pw_aff *mpa2);
4357 __isl_give isl_multi_pw_aff *
4358 isl_multi_pw_aff_flat_range_product(
4359 __isl_take isl_multi_pw_aff *mpa1,
4360 __isl_take isl_multi_pw_aff *mpa2);
4362 If the C<ls> argument of C<isl_multi_aff_lift> is not C<NULL>,
4363 then it is assigned the local space that lies at the basis of
4364 the lifting applied.
4366 #include <isl/aff.h>
4367 __isl_give isl_multi_aff *isl_multi_aff_pullback_multi_aff(
4368 __isl_take isl_multi_aff *ma1,
4369 __isl_take isl_multi_aff *ma2);
4370 __isl_give isl_pw_multi_aff *
4371 isl_pw_multi_aff_pullback_multi_aff(
4372 __isl_take isl_pw_multi_aff *pma,
4373 __isl_take isl_multi_aff *ma);
4374 __isl_give isl_pw_multi_aff *
4375 isl_pw_multi_aff_pullback_pw_multi_aff(
4376 __isl_take isl_pw_multi_aff *pma1,
4377 __isl_take isl_pw_multi_aff *pma2);
4379 The function C<isl_multi_aff_pullback_multi_aff> precomposes C<ma1> by C<ma2>.
4380 In other words, C<ma2> is plugged
4383 __isl_give isl_set *isl_multi_aff_lex_le_set(
4384 __isl_take isl_multi_aff *ma1,
4385 __isl_take isl_multi_aff *ma2);
4386 __isl_give isl_set *isl_multi_aff_lex_ge_set(
4387 __isl_take isl_multi_aff *ma1,
4388 __isl_take isl_multi_aff *ma2);
4390 The function C<isl_multi_aff_lex_le_set> returns a set
4391 containing those elements in the shared domain space
4392 where C<ma1> is lexicographically smaller than or
4395 An expression can be read from input using
4397 #include <isl/aff.h>
4398 __isl_give isl_multi_aff *isl_multi_aff_read_from_str(
4399 isl_ctx *ctx, const char *str);
4400 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_read_from_str(
4401 isl_ctx *ctx, const char *str);
4402 __isl_give isl_union_pw_multi_aff *
4403 isl_union_pw_multi_aff_read_from_str(
4404 isl_ctx *ctx, const char *str);
4406 An expression can be printed using
4408 #include <isl/aff.h>
4409 __isl_give isl_printer *isl_printer_print_multi_aff(
4410 __isl_take isl_printer *p,
4411 __isl_keep isl_multi_aff *maff);
4412 __isl_give isl_printer *isl_printer_print_pw_multi_aff(
4413 __isl_take isl_printer *p,
4414 __isl_keep isl_pw_multi_aff *pma);
4415 __isl_give isl_printer *isl_printer_print_union_pw_multi_aff(
4416 __isl_take isl_printer *p,
4417 __isl_keep isl_union_pw_multi_aff *upma);
4418 __isl_give isl_printer *isl_printer_print_multi_pw_aff(
4419 __isl_take isl_printer *p,
4420 __isl_keep isl_multi_pw_aff *mpa);
4424 Points are elements of a set. They can be used to construct
4425 simple sets (boxes) or they can be used to represent the
4426 individual elements of a set.
4427 The zero point (the origin) can be created using
4429 __isl_give isl_point *isl_point_zero(__isl_take isl_space *space);
4431 The coordinates of a point can be inspected, set and changed
4434 __isl_give isl_val *isl_point_get_coordinate_val(
4435 __isl_keep isl_point *pnt,
4436 enum isl_dim_type type, int pos);
4437 __isl_give isl_point *isl_point_set_coordinate_val(
4438 __isl_take isl_point *pnt,
4439 enum isl_dim_type type, int pos,
4440 __isl_take isl_val *v);
4442 __isl_give isl_point *isl_point_add_ui(
4443 __isl_take isl_point *pnt,
4444 enum isl_dim_type type, int pos, unsigned val);
4445 __isl_give isl_point *isl_point_sub_ui(
4446 __isl_take isl_point *pnt,
4447 enum isl_dim_type type, int pos, unsigned val);
4449 Other properties can be obtained using
4451 isl_ctx *isl_point_get_ctx(__isl_keep isl_point *pnt);
4453 Points can be copied or freed using
4455 __isl_give isl_point *isl_point_copy(
4456 __isl_keep isl_point *pnt);
4457 void isl_point_free(__isl_take isl_point *pnt);
4459 A singleton set can be created from a point using
4461 __isl_give isl_basic_set *isl_basic_set_from_point(
4462 __isl_take isl_point *pnt);
4463 __isl_give isl_set *isl_set_from_point(
4464 __isl_take isl_point *pnt);
4466 and a box can be created from two opposite extremal points using
4468 __isl_give isl_basic_set *isl_basic_set_box_from_points(
4469 __isl_take isl_point *pnt1,
4470 __isl_take isl_point *pnt2);
4471 __isl_give isl_set *isl_set_box_from_points(
4472 __isl_take isl_point *pnt1,
4473 __isl_take isl_point *pnt2);
4475 All elements of a B<bounded> (union) set can be enumerated using
4476 the following functions.
4478 int isl_set_foreach_point(__isl_keep isl_set *set,
4479 int (*fn)(__isl_take isl_point *pnt, void *user),
4481 int isl_union_set_foreach_point(__isl_keep isl_union_set *uset,
4482 int (*fn)(__isl_take isl_point *pnt, void *user),
4485 The function C<fn> is called for each integer point in
4486 C<set> with as second argument the last argument of
4487 the C<isl_set_foreach_point> call. The function C<fn>
4488 should return C<0> on success and C<-1> on failure.
4489 In the latter case, C<isl_set_foreach_point> will stop
4490 enumerating and return C<-1> as well.
4491 If the enumeration is performed successfully and to completion,
4492 then C<isl_set_foreach_point> returns C<0>.
4494 To obtain a single point of a (basic) set, use
4496 __isl_give isl_point *isl_basic_set_sample_point(
4497 __isl_take isl_basic_set *bset);
4498 __isl_give isl_point *isl_set_sample_point(
4499 __isl_take isl_set *set);
4501 If C<set> does not contain any (integer) points, then the
4502 resulting point will be ``void'', a property that can be
4505 int isl_point_is_void(__isl_keep isl_point *pnt);
4507 =head2 Piecewise Quasipolynomials
4509 A piecewise quasipolynomial is a particular kind of function that maps
4510 a parametric point to a rational value.
4511 More specifically, a quasipolynomial is a polynomial expression in greatest
4512 integer parts of affine expressions of parameters and variables.
4513 A piecewise quasipolynomial is a subdivision of a given parametric
4514 domain into disjoint cells with a quasipolynomial associated to
4515 each cell. The value of the piecewise quasipolynomial at a given
4516 point is the value of the quasipolynomial associated to the cell
4517 that contains the point. Outside of the union of cells,
4518 the value is assumed to be zero.
4519 For example, the piecewise quasipolynomial
4521 [n] -> { [x] -> ((1 + n) - x) : x <= n and x >= 0 }
4523 maps C<x> to C<1 + n - x> for values of C<x> between C<0> and C<n>.
4524 A given piecewise quasipolynomial has a fixed domain dimension.
4525 Union piecewise quasipolynomials are used to contain piecewise quasipolynomials
4526 defined over different domains.
4527 Piecewise quasipolynomials are mainly used by the C<barvinok>
4528 library for representing the number of elements in a parametric set or map.
4529 For example, the piecewise quasipolynomial above represents
4530 the number of points in the map
4532 [n] -> { [x] -> [y] : x,y >= 0 and 0 <= x + y <= n }
4534 =head3 Input and Output
4536 Piecewise quasipolynomials can be read from input using
4538 __isl_give isl_union_pw_qpolynomial *
4539 isl_union_pw_qpolynomial_read_from_str(
4540 isl_ctx *ctx, const char *str);
4542 Quasipolynomials and piecewise quasipolynomials can be printed
4543 using the following functions.
4545 __isl_give isl_printer *isl_printer_print_qpolynomial(
4546 __isl_take isl_printer *p,
4547 __isl_keep isl_qpolynomial *qp);
4549 __isl_give isl_printer *isl_printer_print_pw_qpolynomial(
4550 __isl_take isl_printer *p,
4551 __isl_keep isl_pw_qpolynomial *pwqp);
4553 __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial(
4554 __isl_take isl_printer *p,
4555 __isl_keep isl_union_pw_qpolynomial *upwqp);
4557 The output format of the printer
4558 needs to be set to either C<ISL_FORMAT_ISL> or C<ISL_FORMAT_C>.
4559 For C<isl_printer_print_union_pw_qpolynomial>, only C<ISL_FORMAT_ISL>
4561 In case of printing in C<ISL_FORMAT_C>, the user may want
4562 to set the names of all dimensions
4564 __isl_give isl_qpolynomial *isl_qpolynomial_set_dim_name(
4565 __isl_take isl_qpolynomial *qp,
4566 enum isl_dim_type type, unsigned pos,
4568 __isl_give isl_pw_qpolynomial *
4569 isl_pw_qpolynomial_set_dim_name(
4570 __isl_take isl_pw_qpolynomial *pwqp,
4571 enum isl_dim_type type, unsigned pos,
4574 =head3 Creating New (Piecewise) Quasipolynomials
4576 Some simple quasipolynomials can be created using the following functions.
4577 More complicated quasipolynomials can be created by applying
4578 operations such as addition and multiplication
4579 on the resulting quasipolynomials
4581 __isl_give isl_qpolynomial *isl_qpolynomial_zero_on_domain(
4582 __isl_take isl_space *domain);
4583 __isl_give isl_qpolynomial *isl_qpolynomial_one_on_domain(
4584 __isl_take isl_space *domain);
4585 __isl_give isl_qpolynomial *isl_qpolynomial_infty_on_domain(
4586 __isl_take isl_space *domain);
4587 __isl_give isl_qpolynomial *isl_qpolynomial_neginfty_on_domain(
4588 __isl_take isl_space *domain);
4589 __isl_give isl_qpolynomial *isl_qpolynomial_nan_on_domain(
4590 __isl_take isl_space *domain);
4591 __isl_give isl_qpolynomial *isl_qpolynomial_val_on_domain(
4592 __isl_take isl_space *domain,
4593 __isl_take isl_val *val);
4594 __isl_give isl_qpolynomial *isl_qpolynomial_var_on_domain(
4595 __isl_take isl_space *domain,
4596 enum isl_dim_type type, unsigned pos);
4597 __isl_give isl_qpolynomial *isl_qpolynomial_from_aff(
4598 __isl_take isl_aff *aff);
4600 Note that the space in which a quasipolynomial lives is a map space
4601 with a one-dimensional range. The C<domain> argument in some of
4602 the functions above corresponds to the domain of this map space.
4604 The zero piecewise quasipolynomial or a piecewise quasipolynomial
4605 with a single cell can be created using the following functions.
4606 Multiple of these single cell piecewise quasipolynomials can
4607 be combined to create more complicated piecewise quasipolynomials.
4609 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_zero(
4610 __isl_take isl_space *space);
4611 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_alloc(
4612 __isl_take isl_set *set,
4613 __isl_take isl_qpolynomial *qp);
4614 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_from_qpolynomial(
4615 __isl_take isl_qpolynomial *qp);
4616 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_from_pw_aff(
4617 __isl_take isl_pw_aff *pwaff);
4619 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_zero(
4620 __isl_take isl_space *space);
4621 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_from_pw_qpolynomial(
4622 __isl_take isl_pw_qpolynomial *pwqp);
4623 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add_pw_qpolynomial(
4624 __isl_take isl_union_pw_qpolynomial *upwqp,
4625 __isl_take isl_pw_qpolynomial *pwqp);
4627 Quasipolynomials can be copied and freed again using the following
4630 __isl_give isl_qpolynomial *isl_qpolynomial_copy(
4631 __isl_keep isl_qpolynomial *qp);
4632 void *isl_qpolynomial_free(__isl_take isl_qpolynomial *qp);
4634 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_copy(
4635 __isl_keep isl_pw_qpolynomial *pwqp);
4636 void *isl_pw_qpolynomial_free(
4637 __isl_take isl_pw_qpolynomial *pwqp);
4639 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_copy(
4640 __isl_keep isl_union_pw_qpolynomial *upwqp);
4641 void *isl_union_pw_qpolynomial_free(
4642 __isl_take isl_union_pw_qpolynomial *upwqp);
4644 =head3 Inspecting (Piecewise) Quasipolynomials
4646 To iterate over all piecewise quasipolynomials in a union
4647 piecewise quasipolynomial, use the following function
4649 int isl_union_pw_qpolynomial_foreach_pw_qpolynomial(
4650 __isl_keep isl_union_pw_qpolynomial *upwqp,
4651 int (*fn)(__isl_take isl_pw_qpolynomial *pwqp, void *user),
4654 To extract the piecewise quasipolynomial in a given space from a union, use
4656 __isl_give isl_pw_qpolynomial *
4657 isl_union_pw_qpolynomial_extract_pw_qpolynomial(
4658 __isl_keep isl_union_pw_qpolynomial *upwqp,
4659 __isl_take isl_space *space);
4661 To iterate over the cells in a piecewise quasipolynomial,
4662 use either of the following two functions
4664 int isl_pw_qpolynomial_foreach_piece(
4665 __isl_keep isl_pw_qpolynomial *pwqp,
4666 int (*fn)(__isl_take isl_set *set,
4667 __isl_take isl_qpolynomial *qp,
4668 void *user), void *user);
4669 int isl_pw_qpolynomial_foreach_lifted_piece(
4670 __isl_keep isl_pw_qpolynomial *pwqp,
4671 int (*fn)(__isl_take isl_set *set,
4672 __isl_take isl_qpolynomial *qp,
4673 void *user), void *user);
4675 As usual, the function C<fn> should return C<0> on success
4676 and C<-1> on failure. The difference between
4677 C<isl_pw_qpolynomial_foreach_piece> and
4678 C<isl_pw_qpolynomial_foreach_lifted_piece> is that
4679 C<isl_pw_qpolynomial_foreach_lifted_piece> will first
4680 compute unique representations for all existentially quantified
4681 variables and then turn these existentially quantified variables
4682 into extra set variables, adapting the associated quasipolynomial
4683 accordingly. This means that the C<set> passed to C<fn>
4684 will not have any existentially quantified variables, but that
4685 the dimensions of the sets may be different for different
4686 invocations of C<fn>.
4688 The constant term of a quasipolynomial can be extracted using
4690 __isl_give isl_val *isl_qpolynomial_get_constant_val(
4691 __isl_keep isl_qpolynomial *qp);
4693 To iterate over all terms in a quasipolynomial,
4696 int isl_qpolynomial_foreach_term(
4697 __isl_keep isl_qpolynomial *qp,
4698 int (*fn)(__isl_take isl_term *term,
4699 void *user), void *user);
4701 The terms themselves can be inspected and freed using
4704 unsigned isl_term_dim(__isl_keep isl_term *term,
4705 enum isl_dim_type type);
4706 __isl_give isl_val *isl_term_get_coefficient_val(
4707 __isl_keep isl_term *term);
4708 int isl_term_get_exp(__isl_keep isl_term *term,
4709 enum isl_dim_type type, unsigned pos);
4710 __isl_give isl_aff *isl_term_get_div(
4711 __isl_keep isl_term *term, unsigned pos);
4712 void isl_term_free(__isl_take isl_term *term);
4714 Each term is a product of parameters, set variables and
4715 integer divisions. The function C<isl_term_get_exp>
4716 returns the exponent of a given dimensions in the given term.
4718 =head3 Properties of (Piecewise) Quasipolynomials
4720 To check whether two union piecewise quasipolynomials are
4721 obviously equal, use
4723 int isl_union_pw_qpolynomial_plain_is_equal(
4724 __isl_keep isl_union_pw_qpolynomial *upwqp1,
4725 __isl_keep isl_union_pw_qpolynomial *upwqp2);
4727 =head3 Operations on (Piecewise) Quasipolynomials
4729 __isl_give isl_qpolynomial *isl_qpolynomial_scale_val(
4730 __isl_take isl_qpolynomial *qp,
4731 __isl_take isl_val *v);
4732 __isl_give isl_qpolynomial *isl_qpolynomial_neg(
4733 __isl_take isl_qpolynomial *qp);
4734 __isl_give isl_qpolynomial *isl_qpolynomial_add(
4735 __isl_take isl_qpolynomial *qp1,
4736 __isl_take isl_qpolynomial *qp2);
4737 __isl_give isl_qpolynomial *isl_qpolynomial_sub(
4738 __isl_take isl_qpolynomial *qp1,
4739 __isl_take isl_qpolynomial *qp2);
4740 __isl_give isl_qpolynomial *isl_qpolynomial_mul(
4741 __isl_take isl_qpolynomial *qp1,
4742 __isl_take isl_qpolynomial *qp2);
4743 __isl_give isl_qpolynomial *isl_qpolynomial_pow(
4744 __isl_take isl_qpolynomial *qp, unsigned exponent);
4746 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_fix_val(
4747 __isl_take isl_pw_qpolynomial *pwqp,
4748 enum isl_dim_type type, unsigned n,
4749 __isl_take isl_val *v);
4750 __isl_give isl_pw_qpolynomial *
4751 isl_pw_qpolynomial_scale_val(
4752 __isl_take isl_pw_qpolynomial *pwqp,
4753 __isl_take isl_val *v);
4754 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add(
4755 __isl_take isl_pw_qpolynomial *pwqp1,
4756 __isl_take isl_pw_qpolynomial *pwqp2);
4757 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_sub(
4758 __isl_take isl_pw_qpolynomial *pwqp1,
4759 __isl_take isl_pw_qpolynomial *pwqp2);
4760 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add_disjoint(
4761 __isl_take isl_pw_qpolynomial *pwqp1,
4762 __isl_take isl_pw_qpolynomial *pwqp2);
4763 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_neg(
4764 __isl_take isl_pw_qpolynomial *pwqp);
4765 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_mul(
4766 __isl_take isl_pw_qpolynomial *pwqp1,
4767 __isl_take isl_pw_qpolynomial *pwqp2);
4768 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_pow(
4769 __isl_take isl_pw_qpolynomial *pwqp, unsigned exponent);
4771 __isl_give isl_union_pw_qpolynomial *
4772 isl_union_pw_qpolynomial_scale_val(
4773 __isl_take isl_union_pw_qpolynomial *upwqp,
4774 __isl_take isl_val *v);
4775 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add(
4776 __isl_take isl_union_pw_qpolynomial *upwqp1,
4777 __isl_take isl_union_pw_qpolynomial *upwqp2);
4778 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_sub(
4779 __isl_take isl_union_pw_qpolynomial *upwqp1,
4780 __isl_take isl_union_pw_qpolynomial *upwqp2);
4781 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_mul(
4782 __isl_take isl_union_pw_qpolynomial *upwqp1,
4783 __isl_take isl_union_pw_qpolynomial *upwqp2);
4785 __isl_give isl_val *isl_pw_qpolynomial_eval(
4786 __isl_take isl_pw_qpolynomial *pwqp,
4787 __isl_take isl_point *pnt);
4789 __isl_give isl_val *isl_union_pw_qpolynomial_eval(
4790 __isl_take isl_union_pw_qpolynomial *upwqp,
4791 __isl_take isl_point *pnt);
4793 __isl_give isl_set *isl_pw_qpolynomial_domain(
4794 __isl_take isl_pw_qpolynomial *pwqp);
4795 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_intersect_domain(
4796 __isl_take isl_pw_qpolynomial *pwpq,
4797 __isl_take isl_set *set);
4798 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_intersect_params(
4799 __isl_take isl_pw_qpolynomial *pwpq,
4800 __isl_take isl_set *set);
4802 __isl_give isl_union_set *isl_union_pw_qpolynomial_domain(
4803 __isl_take isl_union_pw_qpolynomial *upwqp);
4804 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_intersect_domain(
4805 __isl_take isl_union_pw_qpolynomial *upwpq,
4806 __isl_take isl_union_set *uset);
4807 __isl_give isl_union_pw_qpolynomial *
4808 isl_union_pw_qpolynomial_intersect_params(
4809 __isl_take isl_union_pw_qpolynomial *upwpq,
4810 __isl_take isl_set *set);
4812 __isl_give isl_qpolynomial *isl_qpolynomial_align_params(
4813 __isl_take isl_qpolynomial *qp,
4814 __isl_take isl_space *model);
4816 __isl_give isl_qpolynomial *isl_qpolynomial_project_domain_on_params(
4817 __isl_take isl_qpolynomial *qp);
4818 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_project_domain_on_params(
4819 __isl_take isl_pw_qpolynomial *pwqp);
4821 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_coalesce(
4822 __isl_take isl_union_pw_qpolynomial *upwqp);
4824 __isl_give isl_qpolynomial *isl_qpolynomial_gist_params(
4825 __isl_take isl_qpolynomial *qp,
4826 __isl_take isl_set *context);
4827 __isl_give isl_qpolynomial *isl_qpolynomial_gist(
4828 __isl_take isl_qpolynomial *qp,
4829 __isl_take isl_set *context);
4831 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist_params(
4832 __isl_take isl_pw_qpolynomial *pwqp,
4833 __isl_take isl_set *context);
4834 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist(
4835 __isl_take isl_pw_qpolynomial *pwqp,
4836 __isl_take isl_set *context);
4838 __isl_give isl_union_pw_qpolynomial *
4839 isl_union_pw_qpolynomial_gist_params(
4840 __isl_take isl_union_pw_qpolynomial *upwqp,
4841 __isl_take isl_set *context);
4842 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_gist(
4843 __isl_take isl_union_pw_qpolynomial *upwqp,
4844 __isl_take isl_union_set *context);
4846 The gist operation applies the gist operation to each of
4847 the cells in the domain of the input piecewise quasipolynomial.
4848 The context is also exploited
4849 to simplify the quasipolynomials associated to each cell.
4851 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_to_polynomial(
4852 __isl_take isl_pw_qpolynomial *pwqp, int sign);
4853 __isl_give isl_union_pw_qpolynomial *
4854 isl_union_pw_qpolynomial_to_polynomial(
4855 __isl_take isl_union_pw_qpolynomial *upwqp, int sign);
4857 Approximate each quasipolynomial by a polynomial. If C<sign> is positive,
4858 the polynomial will be an overapproximation. If C<sign> is negative,
4859 it will be an underapproximation. If C<sign> is zero, the approximation
4860 will lie somewhere in between.
4862 =head2 Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions
4864 A piecewise quasipolynomial reduction is a piecewise
4865 reduction (or fold) of quasipolynomials.
4866 In particular, the reduction can be maximum or a minimum.
4867 The objects are mainly used to represent the result of
4868 an upper or lower bound on a quasipolynomial over its domain,
4869 i.e., as the result of the following function.
4871 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_bound(
4872 __isl_take isl_pw_qpolynomial *pwqp,
4873 enum isl_fold type, int *tight);
4875 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_bound(
4876 __isl_take isl_union_pw_qpolynomial *upwqp,
4877 enum isl_fold type, int *tight);
4879 The C<type> argument may be either C<isl_fold_min> or C<isl_fold_max>.
4880 If C<tight> is not C<NULL>, then C<*tight> is set to C<1>
4881 is the returned bound is known be tight, i.e., for each value
4882 of the parameters there is at least
4883 one element in the domain that reaches the bound.
4884 If the domain of C<pwqp> is not wrapping, then the bound is computed
4885 over all elements in that domain and the result has a purely parametric
4886 domain. If the domain of C<pwqp> is wrapping, then the bound is
4887 computed over the range of the wrapped relation. The domain of the
4888 wrapped relation becomes the domain of the result.
4890 A (piecewise) quasipolynomial reduction can be copied or freed using the
4891 following functions.
4893 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_copy(
4894 __isl_keep isl_qpolynomial_fold *fold);
4895 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_copy(
4896 __isl_keep isl_pw_qpolynomial_fold *pwf);
4897 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_copy(
4898 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
4899 void isl_qpolynomial_fold_free(
4900 __isl_take isl_qpolynomial_fold *fold);
4901 void *isl_pw_qpolynomial_fold_free(
4902 __isl_take isl_pw_qpolynomial_fold *pwf);
4903 void *isl_union_pw_qpolynomial_fold_free(
4904 __isl_take isl_union_pw_qpolynomial_fold *upwf);
4906 =head3 Printing Piecewise Quasipolynomial Reductions
4908 Piecewise quasipolynomial reductions can be printed
4909 using the following function.
4911 __isl_give isl_printer *isl_printer_print_pw_qpolynomial_fold(
4912 __isl_take isl_printer *p,
4913 __isl_keep isl_pw_qpolynomial_fold *pwf);
4914 __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial_fold(
4915 __isl_take isl_printer *p,
4916 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
4918 For C<isl_printer_print_pw_qpolynomial_fold>,
4919 output format of the printer
4920 needs to be set to either C<ISL_FORMAT_ISL> or C<ISL_FORMAT_C>.
4921 For C<isl_printer_print_union_pw_qpolynomial_fold>,
4922 output format of the printer
4923 needs to be set to C<ISL_FORMAT_ISL>.
4924 In case of printing in C<ISL_FORMAT_C>, the user may want
4925 to set the names of all dimensions
4927 __isl_give isl_pw_qpolynomial_fold *
4928 isl_pw_qpolynomial_fold_set_dim_name(
4929 __isl_take isl_pw_qpolynomial_fold *pwf,
4930 enum isl_dim_type type, unsigned pos,
4933 =head3 Inspecting (Piecewise) Quasipolynomial Reductions
4935 To iterate over all piecewise quasipolynomial reductions in a union
4936 piecewise quasipolynomial reduction, use the following function
4938 int isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(
4939 __isl_keep isl_union_pw_qpolynomial_fold *upwf,
4940 int (*fn)(__isl_take isl_pw_qpolynomial_fold *pwf,
4941 void *user), void *user);
4943 To iterate over the cells in a piecewise quasipolynomial reduction,
4944 use either of the following two functions
4946 int isl_pw_qpolynomial_fold_foreach_piece(
4947 __isl_keep isl_pw_qpolynomial_fold *pwf,
4948 int (*fn)(__isl_take isl_set *set,
4949 __isl_take isl_qpolynomial_fold *fold,
4950 void *user), void *user);
4951 int isl_pw_qpolynomial_fold_foreach_lifted_piece(
4952 __isl_keep isl_pw_qpolynomial_fold *pwf,
4953 int (*fn)(__isl_take isl_set *set,
4954 __isl_take isl_qpolynomial_fold *fold,
4955 void *user), void *user);
4957 See L<Inspecting (Piecewise) Quasipolynomials> for an explanation
4958 of the difference between these two functions.
4960 To iterate over all quasipolynomials in a reduction, use
4962 int isl_qpolynomial_fold_foreach_qpolynomial(
4963 __isl_keep isl_qpolynomial_fold *fold,
4964 int (*fn)(__isl_take isl_qpolynomial *qp,
4965 void *user), void *user);
4967 =head3 Properties of Piecewise Quasipolynomial Reductions
4969 To check whether two union piecewise quasipolynomial reductions are
4970 obviously equal, use
4972 int isl_union_pw_qpolynomial_fold_plain_is_equal(
4973 __isl_keep isl_union_pw_qpolynomial_fold *upwf1,
4974 __isl_keep isl_union_pw_qpolynomial_fold *upwf2);
4976 =head3 Operations on Piecewise Quasipolynomial Reductions
4978 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_scale_val(
4979 __isl_take isl_qpolynomial_fold *fold,
4980 __isl_take isl_val *v);
4981 __isl_give isl_pw_qpolynomial_fold *
4982 isl_pw_qpolynomial_fold_scale_val(
4983 __isl_take isl_pw_qpolynomial_fold *pwf,
4984 __isl_take isl_val *v);
4985 __isl_give isl_union_pw_qpolynomial_fold *
4986 isl_union_pw_qpolynomial_fold_scale_val(
4987 __isl_take isl_union_pw_qpolynomial_fold *upwf,
4988 __isl_take isl_val *v);
4990 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_add(
4991 __isl_take isl_pw_qpolynomial_fold *pwf1,
4992 __isl_take isl_pw_qpolynomial_fold *pwf2);
4994 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_fold(
4995 __isl_take isl_pw_qpolynomial_fold *pwf1,
4996 __isl_take isl_pw_qpolynomial_fold *pwf2);
4998 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_fold(
4999 __isl_take isl_union_pw_qpolynomial_fold *upwf1,
5000 __isl_take isl_union_pw_qpolynomial_fold *upwf2);
5002 __isl_give isl_val *isl_pw_qpolynomial_fold_eval(
5003 __isl_take isl_pw_qpolynomial_fold *pwf,
5004 __isl_take isl_point *pnt);
5006 __isl_give isl_val *isl_union_pw_qpolynomial_fold_eval(
5007 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5008 __isl_take isl_point *pnt);
5010 __isl_give isl_pw_qpolynomial_fold *
5011 isl_pw_qpolynomial_fold_intersect_params(
5012 __isl_take isl_pw_qpolynomial_fold *pwf,
5013 __isl_take isl_set *set);
5015 __isl_give isl_union_set *isl_union_pw_qpolynomial_fold_domain(
5016 __isl_take isl_union_pw_qpolynomial_fold *upwf);
5017 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_intersect_domain(
5018 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5019 __isl_take isl_union_set *uset);
5020 __isl_give isl_union_pw_qpolynomial_fold *
5021 isl_union_pw_qpolynomial_fold_intersect_params(
5022 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5023 __isl_take isl_set *set);
5025 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_project_domain_on_params(
5026 __isl_take isl_pw_qpolynomial_fold *pwf);
5028 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_coalesce(
5029 __isl_take isl_pw_qpolynomial_fold *pwf);
5031 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_coalesce(
5032 __isl_take isl_union_pw_qpolynomial_fold *upwf);
5034 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist_params(
5035 __isl_take isl_qpolynomial_fold *fold,
5036 __isl_take isl_set *context);
5037 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist(
5038 __isl_take isl_qpolynomial_fold *fold,
5039 __isl_take isl_set *context);
5041 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_gist(
5042 __isl_take isl_pw_qpolynomial_fold *pwf,
5043 __isl_take isl_set *context);
5044 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_gist_params(
5045 __isl_take isl_pw_qpolynomial_fold *pwf,
5046 __isl_take isl_set *context);
5048 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_gist(
5049 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5050 __isl_take isl_union_set *context);
5051 __isl_give isl_union_pw_qpolynomial_fold *
5052 isl_union_pw_qpolynomial_fold_gist_params(
5053 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5054 __isl_take isl_set *context);
5056 The gist operation applies the gist operation to each of
5057 the cells in the domain of the input piecewise quasipolynomial reduction.
5058 In future, the operation will also exploit the context
5059 to simplify the quasipolynomial reductions associated to each cell.
5061 __isl_give isl_pw_qpolynomial_fold *
5062 isl_set_apply_pw_qpolynomial_fold(
5063 __isl_take isl_set *set,
5064 __isl_take isl_pw_qpolynomial_fold *pwf,
5066 __isl_give isl_pw_qpolynomial_fold *
5067 isl_map_apply_pw_qpolynomial_fold(
5068 __isl_take isl_map *map,
5069 __isl_take isl_pw_qpolynomial_fold *pwf,
5071 __isl_give isl_union_pw_qpolynomial_fold *
5072 isl_union_set_apply_union_pw_qpolynomial_fold(
5073 __isl_take isl_union_set *uset,
5074 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5076 __isl_give isl_union_pw_qpolynomial_fold *
5077 isl_union_map_apply_union_pw_qpolynomial_fold(
5078 __isl_take isl_union_map *umap,
5079 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5082 The functions taking a map
5083 compose the given map with the given piecewise quasipolynomial reduction.
5084 That is, compute a bound (of the same type as C<pwf> or C<upwf> itself)
5085 over all elements in the intersection of the range of the map
5086 and the domain of the piecewise quasipolynomial reduction
5087 as a function of an element in the domain of the map.
5088 The functions taking a set compute a bound over all elements in the
5089 intersection of the set and the domain of the
5090 piecewise quasipolynomial reduction.
5092 =head2 Parametric Vertex Enumeration
5094 The parametric vertex enumeration described in this section
5095 is mainly intended to be used internally and by the C<barvinok>
5098 #include <isl/vertices.h>
5099 __isl_give isl_vertices *isl_basic_set_compute_vertices(
5100 __isl_keep isl_basic_set *bset);
5102 The function C<isl_basic_set_compute_vertices> performs the
5103 actual computation of the parametric vertices and the chamber
5104 decomposition and store the result in an C<isl_vertices> object.
5105 This information can be queried by either iterating over all
5106 the vertices or iterating over all the chambers or cells
5107 and then iterating over all vertices that are active on the chamber.
5109 int isl_vertices_foreach_vertex(
5110 __isl_keep isl_vertices *vertices,
5111 int (*fn)(__isl_take isl_vertex *vertex, void *user),
5114 int isl_vertices_foreach_cell(
5115 __isl_keep isl_vertices *vertices,
5116 int (*fn)(__isl_take isl_cell *cell, void *user),
5118 int isl_cell_foreach_vertex(__isl_keep isl_cell *cell,
5119 int (*fn)(__isl_take isl_vertex *vertex, void *user),
5122 Other operations that can be performed on an C<isl_vertices> object are
5125 isl_ctx *isl_vertices_get_ctx(
5126 __isl_keep isl_vertices *vertices);
5127 int isl_vertices_get_n_vertices(
5128 __isl_keep isl_vertices *vertices);
5129 void isl_vertices_free(__isl_take isl_vertices *vertices);
5131 Vertices can be inspected and destroyed using the following functions.
5133 isl_ctx *isl_vertex_get_ctx(__isl_keep isl_vertex *vertex);
5134 int isl_vertex_get_id(__isl_keep isl_vertex *vertex);
5135 __isl_give isl_basic_set *isl_vertex_get_domain(
5136 __isl_keep isl_vertex *vertex);
5137 __isl_give isl_basic_set *isl_vertex_get_expr(
5138 __isl_keep isl_vertex *vertex);
5139 void isl_vertex_free(__isl_take isl_vertex *vertex);
5141 C<isl_vertex_get_expr> returns a singleton parametric set describing
5142 the vertex, while C<isl_vertex_get_domain> returns the activity domain
5144 Note that C<isl_vertex_get_domain> and C<isl_vertex_get_expr> return
5145 B<rational> basic sets, so they should mainly be used for inspection
5146 and should not be mixed with integer sets.
5148 Chambers can be inspected and destroyed using the following functions.
5150 isl_ctx *isl_cell_get_ctx(__isl_keep isl_cell *cell);
5151 __isl_give isl_basic_set *isl_cell_get_domain(
5152 __isl_keep isl_cell *cell);
5153 void isl_cell_free(__isl_take isl_cell *cell);
5155 =head1 Polyhedral Compilation Library
5157 This section collects functionality in C<isl> that has been specifically
5158 designed for use during polyhedral compilation.
5160 =head2 Dependence Analysis
5162 C<isl> contains specialized functionality for performing
5163 array dataflow analysis. That is, given a I<sink> access relation
5164 and a collection of possible I<source> access relations,
5165 C<isl> can compute relations that describe
5166 for each iteration of the sink access, which iteration
5167 of which of the source access relations was the last
5168 to access the same data element before the given iteration
5170 The resulting dependence relations map source iterations
5171 to the corresponding sink iterations.
5172 To compute standard flow dependences, the sink should be
5173 a read, while the sources should be writes.
5174 If any of the source accesses are marked as being I<may>
5175 accesses, then there will be a dependence from the last
5176 I<must> access B<and> from any I<may> access that follows
5177 this last I<must> access.
5178 In particular, if I<all> sources are I<may> accesses,
5179 then memory based dependence analysis is performed.
5180 If, on the other hand, all sources are I<must> accesses,
5181 then value based dependence analysis is performed.
5183 #include <isl/flow.h>
5185 typedef int (*isl_access_level_before)(void *first, void *second);
5187 __isl_give isl_access_info *isl_access_info_alloc(
5188 __isl_take isl_map *sink,
5189 void *sink_user, isl_access_level_before fn,
5191 __isl_give isl_access_info *isl_access_info_add_source(
5192 __isl_take isl_access_info *acc,
5193 __isl_take isl_map *source, int must,
5195 void *isl_access_info_free(__isl_take isl_access_info *acc);
5197 __isl_give isl_flow *isl_access_info_compute_flow(
5198 __isl_take isl_access_info *acc);
5200 int isl_flow_foreach(__isl_keep isl_flow *deps,
5201 int (*fn)(__isl_take isl_map *dep, int must,
5202 void *dep_user, void *user),
5204 __isl_give isl_map *isl_flow_get_no_source(
5205 __isl_keep isl_flow *deps, int must);
5206 void isl_flow_free(__isl_take isl_flow *deps);
5208 The function C<isl_access_info_compute_flow> performs the actual
5209 dependence analysis. The other functions are used to construct
5210 the input for this function or to read off the output.
5212 The input is collected in an C<isl_access_info>, which can
5213 be created through a call to C<isl_access_info_alloc>.
5214 The arguments to this functions are the sink access relation
5215 C<sink>, a token C<sink_user> used to identify the sink
5216 access to the user, a callback function for specifying the
5217 relative order of source and sink accesses, and the number
5218 of source access relations that will be added.
5219 The callback function has type C<int (*)(void *first, void *second)>.
5220 The function is called with two user supplied tokens identifying
5221 either a source or the sink and it should return the shared nesting
5222 level and the relative order of the two accesses.
5223 In particular, let I<n> be the number of loops shared by
5224 the two accesses. If C<first> precedes C<second> textually,
5225 then the function should return I<2 * n + 1>; otherwise,
5226 it should return I<2 * n>.
5227 The sources can be added to the C<isl_access_info> by performing
5228 (at most) C<max_source> calls to C<isl_access_info_add_source>.
5229 C<must> indicates whether the source is a I<must> access
5230 or a I<may> access. Note that a multi-valued access relation
5231 should only be marked I<must> if every iteration in the domain
5232 of the relation accesses I<all> elements in its image.
5233 The C<source_user> token is again used to identify
5234 the source access. The range of the source access relation
5235 C<source> should have the same dimension as the range
5236 of the sink access relation.
5237 The C<isl_access_info_free> function should usually not be
5238 called explicitly, because it is called implicitly by
5239 C<isl_access_info_compute_flow>.
5241 The result of the dependence analysis is collected in an
5242 C<isl_flow>. There may be elements of
5243 the sink access for which no preceding source access could be
5244 found or for which all preceding sources are I<may> accesses.
5245 The relations containing these elements can be obtained through
5246 calls to C<isl_flow_get_no_source>, the first with C<must> set
5247 and the second with C<must> unset.
5248 In the case of standard flow dependence analysis,
5249 with the sink a read and the sources I<must> writes,
5250 the first relation corresponds to the reads from uninitialized
5251 array elements and the second relation is empty.
5252 The actual flow dependences can be extracted using
5253 C<isl_flow_foreach>. This function will call the user-specified
5254 callback function C<fn> for each B<non-empty> dependence between
5255 a source and the sink. The callback function is called
5256 with four arguments, the actual flow dependence relation
5257 mapping source iterations to sink iterations, a boolean that
5258 indicates whether it is a I<must> or I<may> dependence, a token
5259 identifying the source and an additional C<void *> with value
5260 equal to the third argument of the C<isl_flow_foreach> call.
5261 A dependence is marked I<must> if it originates from a I<must>
5262 source and if it is not followed by any I<may> sources.
5264 After finishing with an C<isl_flow>, the user should call
5265 C<isl_flow_free> to free all associated memory.
5267 A higher-level interface to dependence analysis is provided
5268 by the following function.
5270 #include <isl/flow.h>
5272 int isl_union_map_compute_flow(__isl_take isl_union_map *sink,
5273 __isl_take isl_union_map *must_source,
5274 __isl_take isl_union_map *may_source,
5275 __isl_take isl_union_map *schedule,
5276 __isl_give isl_union_map **must_dep,
5277 __isl_give isl_union_map **may_dep,
5278 __isl_give isl_union_map **must_no_source,
5279 __isl_give isl_union_map **may_no_source);
5281 The arrays are identified by the tuple names of the ranges
5282 of the accesses. The iteration domains by the tuple names
5283 of the domains of the accesses and of the schedule.
5284 The relative order of the iteration domains is given by the
5285 schedule. The relations returned through C<must_no_source>
5286 and C<may_no_source> are subsets of C<sink>.
5287 Any of C<must_dep>, C<may_dep>, C<must_no_source>
5288 or C<may_no_source> may be C<NULL>, but a C<NULL> value for
5289 any of the other arguments is treated as an error.
5291 =head3 Interaction with Dependence Analysis
5293 During the dependence analysis, we frequently need to perform
5294 the following operation. Given a relation between sink iterations
5295 and potential source iterations from a particular source domain,
5296 what is the last potential source iteration corresponding to each
5297 sink iteration. It can sometimes be convenient to adjust
5298 the set of potential source iterations before or after each such operation.
5299 The prototypical example is fuzzy array dataflow analysis,
5300 where we need to analyze if, based on data-dependent constraints,
5301 the sink iteration can ever be executed without one or more of
5302 the corresponding potential source iterations being executed.
5303 If so, we can introduce extra parameters and select an unknown
5304 but fixed source iteration from the potential source iterations.
5305 To be able to perform such manipulations, C<isl> provides the following
5308 #include <isl/flow.h>
5310 typedef __isl_give isl_restriction *(*isl_access_restrict)(
5311 __isl_keep isl_map *source_map,
5312 __isl_keep isl_set *sink, void *source_user,
5314 __isl_give isl_access_info *isl_access_info_set_restrict(
5315 __isl_take isl_access_info *acc,
5316 isl_access_restrict fn, void *user);
5318 The function C<isl_access_info_set_restrict> should be called
5319 before calling C<isl_access_info_compute_flow> and registers a callback function
5320 that will be called any time C<isl> is about to compute the last
5321 potential source. The first argument is the (reverse) proto-dependence,
5322 mapping sink iterations to potential source iterations.
5323 The second argument represents the sink iterations for which
5324 we want to compute the last source iteration.
5325 The third argument is the token corresponding to the source
5326 and the final argument is the token passed to C<isl_access_info_set_restrict>.
5327 The callback is expected to return a restriction on either the input or
5328 the output of the operation computing the last potential source.
5329 If the input needs to be restricted then restrictions are needed
5330 for both the source and the sink iterations. The sink iterations
5331 and the potential source iterations will be intersected with these sets.
5332 If the output needs to be restricted then only a restriction on the source
5333 iterations is required.
5334 If any error occurs, the callback should return C<NULL>.
5335 An C<isl_restriction> object can be created, freed and inspected
5336 using the following functions.
5338 #include <isl/flow.h>
5340 __isl_give isl_restriction *isl_restriction_input(
5341 __isl_take isl_set *source_restr,
5342 __isl_take isl_set *sink_restr);
5343 __isl_give isl_restriction *isl_restriction_output(
5344 __isl_take isl_set *source_restr);
5345 __isl_give isl_restriction *isl_restriction_none(
5346 __isl_take isl_map *source_map);
5347 __isl_give isl_restriction *isl_restriction_empty(
5348 __isl_take isl_map *source_map);
5349 void *isl_restriction_free(
5350 __isl_take isl_restriction *restr);
5351 isl_ctx *isl_restriction_get_ctx(
5352 __isl_keep isl_restriction *restr);
5354 C<isl_restriction_none> and C<isl_restriction_empty> are special
5355 cases of C<isl_restriction_input>. C<isl_restriction_none>
5356 is essentially equivalent to
5358 isl_restriction_input(isl_set_universe(
5359 isl_space_range(isl_map_get_space(source_map))),
5361 isl_space_domain(isl_map_get_space(source_map))));
5363 whereas C<isl_restriction_empty> is essentially equivalent to
5365 isl_restriction_input(isl_set_empty(
5366 isl_space_range(isl_map_get_space(source_map))),
5368 isl_space_domain(isl_map_get_space(source_map))));
5372 B<The functionality described in this section is fairly new
5373 and may be subject to change.>
5375 The following function can be used to compute a schedule
5376 for a union of domains.
5377 By default, the algorithm used to construct the schedule is similar
5378 to that of C<Pluto>.
5379 Alternatively, Feautrier's multi-dimensional scheduling algorithm can
5381 The generated schedule respects all C<validity> dependences.
5382 That is, all dependence distances over these dependences in the
5383 scheduled space are lexicographically positive.
5384 The default algorithm tries to minimize the dependence distances over
5385 C<proximity> dependences.
5386 Moreover, it tries to obtain sequences (bands) of schedule dimensions
5387 for groups of domains where the dependence distances have only
5388 non-negative values.
5389 When using Feautrier's algorithm, the C<proximity> dependence
5390 distances are only minimized during the extension to a
5391 full-dimensional schedule.
5393 #include <isl/schedule.h>
5394 __isl_give isl_schedule *isl_union_set_compute_schedule(
5395 __isl_take isl_union_set *domain,
5396 __isl_take isl_union_map *validity,
5397 __isl_take isl_union_map *proximity);
5398 void *isl_schedule_free(__isl_take isl_schedule *sched);
5400 A mapping from the domains to the scheduled space can be obtained
5401 from an C<isl_schedule> using the following function.
5403 __isl_give isl_union_map *isl_schedule_get_map(
5404 __isl_keep isl_schedule *sched);
5406 A representation of the schedule can be printed using
5408 __isl_give isl_printer *isl_printer_print_schedule(
5409 __isl_take isl_printer *p,
5410 __isl_keep isl_schedule *schedule);
5412 A representation of the schedule as a forest of bands can be obtained
5413 using the following function.
5415 __isl_give isl_band_list *isl_schedule_get_band_forest(
5416 __isl_keep isl_schedule *schedule);
5418 The individual bands can be visited in depth-first post-order
5419 using the following function.
5421 #include <isl/schedule.h>
5422 int isl_schedule_foreach_band(
5423 __isl_keep isl_schedule *sched,
5424 int (*fn)(__isl_keep isl_band *band, void *user),
5427 The list can be manipulated as explained in L<"Lists">.
5428 The bands inside the list can be copied and freed using the following
5431 #include <isl/band.h>
5432 __isl_give isl_band *isl_band_copy(
5433 __isl_keep isl_band *band);
5434 void *isl_band_free(__isl_take isl_band *band);
5436 Each band contains zero or more scheduling dimensions.
5437 These are referred to as the members of the band.
5438 The section of the schedule that corresponds to the band is
5439 referred to as the partial schedule of the band.
5440 For those nodes that participate in a band, the outer scheduling
5441 dimensions form the prefix schedule, while the inner scheduling
5442 dimensions form the suffix schedule.
5443 That is, if we take a cut of the band forest, then the union of
5444 the concatenations of the prefix, partial and suffix schedules of
5445 each band in the cut is equal to the entire schedule (modulo
5446 some possible padding at the end with zero scheduling dimensions).
5447 The properties of a band can be inspected using the following functions.
5449 #include <isl/band.h>
5450 isl_ctx *isl_band_get_ctx(__isl_keep isl_band *band);
5452 int isl_band_has_children(__isl_keep isl_band *band);
5453 __isl_give isl_band_list *isl_band_get_children(
5454 __isl_keep isl_band *band);
5456 __isl_give isl_union_map *isl_band_get_prefix_schedule(
5457 __isl_keep isl_band *band);
5458 __isl_give isl_union_map *isl_band_get_partial_schedule(
5459 __isl_keep isl_band *band);
5460 __isl_give isl_union_map *isl_band_get_suffix_schedule(
5461 __isl_keep isl_band *band);
5463 int isl_band_n_member(__isl_keep isl_band *band);
5464 int isl_band_member_is_zero_distance(
5465 __isl_keep isl_band *band, int pos);
5467 int isl_band_list_foreach_band(
5468 __isl_keep isl_band_list *list,
5469 int (*fn)(__isl_keep isl_band *band, void *user),
5472 Note that a scheduling dimension is considered to be ``zero
5473 distance'' if it does not carry any proximity dependences
5475 That is, if the dependence distances of the proximity
5476 dependences are all zero in that direction (for fixed
5477 iterations of outer bands).
5478 Like C<isl_schedule_foreach_band>,
5479 the function C<isl_band_list_foreach_band> calls C<fn> on the bands
5480 in depth-first post-order.
5482 A band can be tiled using the following function.
5484 #include <isl/band.h>
5485 int isl_band_tile(__isl_keep isl_band *band,
5486 __isl_take isl_vec *sizes);
5488 int isl_options_set_tile_scale_tile_loops(isl_ctx *ctx,
5490 int isl_options_get_tile_scale_tile_loops(isl_ctx *ctx);
5491 int isl_options_set_tile_shift_point_loops(isl_ctx *ctx,
5493 int isl_options_get_tile_shift_point_loops(isl_ctx *ctx);
5495 The C<isl_band_tile> function tiles the band using the given tile sizes
5496 inside its schedule.
5497 A new child band is created to represent the point loops and it is
5498 inserted between the modified band and its children.
5499 The C<tile_scale_tile_loops> option specifies whether the tile
5500 loops iterators should be scaled by the tile sizes.
5501 If the C<tile_shift_point_loops> option is set, then the point loops
5502 are shifted to start at zero.
5504 A band can be split into two nested bands using the following function.
5506 int isl_band_split(__isl_keep isl_band *band, int pos);
5508 The resulting outer band contains the first C<pos> dimensions of C<band>
5509 while the inner band contains the remaining dimensions.
5511 A representation of the band can be printed using
5513 #include <isl/band.h>
5514 __isl_give isl_printer *isl_printer_print_band(
5515 __isl_take isl_printer *p,
5516 __isl_keep isl_band *band);
5520 #include <isl/schedule.h>
5521 int isl_options_set_schedule_max_coefficient(
5522 isl_ctx *ctx, int val);
5523 int isl_options_get_schedule_max_coefficient(
5525 int isl_options_set_schedule_max_constant_term(
5526 isl_ctx *ctx, int val);
5527 int isl_options_get_schedule_max_constant_term(
5529 int isl_options_set_schedule_fuse(isl_ctx *ctx, int val);
5530 int isl_options_get_schedule_fuse(isl_ctx *ctx);
5531 int isl_options_set_schedule_maximize_band_depth(
5532 isl_ctx *ctx, int val);
5533 int isl_options_get_schedule_maximize_band_depth(
5535 int isl_options_set_schedule_outer_zero_distance(
5536 isl_ctx *ctx, int val);
5537 int isl_options_get_schedule_outer_zero_distance(
5539 int isl_options_set_schedule_split_scaled(
5540 isl_ctx *ctx, int val);
5541 int isl_options_get_schedule_split_scaled(
5543 int isl_options_set_schedule_algorithm(
5544 isl_ctx *ctx, int val);
5545 int isl_options_get_schedule_algorithm(
5547 int isl_options_set_schedule_separate_components(
5548 isl_ctx *ctx, int val);
5549 int isl_options_get_schedule_separate_components(
5554 =item * schedule_max_coefficient
5556 This option enforces that the coefficients for variable and parameter
5557 dimensions in the calculated schedule are not larger than the specified value.
5558 This option can significantly increase the speed of the scheduling calculation
5559 and may also prevent fusing of unrelated dimensions. A value of -1 means that
5560 this option does not introduce bounds on the variable or parameter
5563 =item * schedule_max_constant_term
5565 This option enforces that the constant coefficients in the calculated schedule
5566 are not larger than the maximal constant term. This option can significantly
5567 increase the speed of the scheduling calculation and may also prevent fusing of
5568 unrelated dimensions. A value of -1 means that this option does not introduce
5569 bounds on the constant coefficients.
5571 =item * schedule_fuse
5573 This option controls the level of fusion.
5574 If this option is set to C<ISL_SCHEDULE_FUSE_MIN>, then loops in the
5575 resulting schedule will be distributed as much as possible.
5576 If this option is set to C<ISL_SCHEDULE_FUSE_MAX>, then C<isl> will
5577 try to fuse loops in the resulting schedule.
5579 =item * schedule_maximize_band_depth
5581 If this option is set, we do not split bands at the point
5582 where we detect splitting is necessary. Instead, we
5583 backtrack and split bands as early as possible. This
5584 reduces the number of splits and maximizes the width of
5585 the bands. Wider bands give more possibilities for tiling.
5586 Note that if the C<schedule_fuse> option is set to C<ISL_SCHEDULE_FUSE_MIN>,
5587 then bands will be split as early as possible, even if there is no need.
5588 The C<schedule_maximize_band_depth> option therefore has no effect in this case.
5590 =item * schedule_outer_zero_distance
5592 If this option is set, then we try to construct schedules
5593 where the outermost scheduling dimension in each band
5594 results in a zero dependence distance over the proximity
5597 =item * schedule_split_scaled
5599 If this option is set, then we try to construct schedules in which the
5600 constant term is split off from the linear part if the linear parts of
5601 the scheduling rows for all nodes in the graphs have a common non-trivial
5603 The constant term is then placed in a separate band and the linear
5606 =item * schedule_algorithm
5608 Selects the scheduling algorithm to be used.
5609 Available scheduling algorithms are C<ISL_SCHEDULE_ALGORITHM_ISL>
5610 and C<ISL_SCHEDULE_ALGORITHM_FEAUTRIER>.
5612 =item * schedule_separate_components
5614 If at any point the dependence graph contains any (weakly connected) components,
5615 then these components are scheduled separately.
5616 If this option is not set, then some iterations of the domains
5617 in these components may be scheduled together.
5618 If this option is set, then the components are given consecutive
5623 =head2 AST Generation
5625 This section describes the C<isl> functionality for generating
5626 ASTs that visit all the elements
5627 in a domain in an order specified by a schedule.
5628 In particular, given a C<isl_union_map>, an AST is generated
5629 that visits all the elements in the domain of the C<isl_union_map>
5630 according to the lexicographic order of the corresponding image
5631 element(s). If the range of the C<isl_union_map> consists of
5632 elements in more than one space, then each of these spaces is handled
5633 separately in an arbitrary order.
5634 It should be noted that the image elements only specify the I<order>
5635 in which the corresponding domain elements should be visited.
5636 No direct relation between the image elements and the loop iterators
5637 in the generated AST should be assumed.
5639 Each AST is generated within a build. The initial build
5640 simply specifies the constraints on the parameters (if any)
5641 and can be created, inspected, copied and freed using the following functions.
5643 #include <isl/ast_build.h>
5644 __isl_give isl_ast_build *isl_ast_build_from_context(
5645 __isl_take isl_set *set);
5646 isl_ctx *isl_ast_build_get_ctx(
5647 __isl_keep isl_ast_build *build);
5648 __isl_give isl_ast_build *isl_ast_build_copy(
5649 __isl_keep isl_ast_build *build);
5650 void *isl_ast_build_free(
5651 __isl_take isl_ast_build *build);
5653 The C<set> argument is usually a parameter set with zero or more parameters.
5654 More C<isl_ast_build> functions are described in L</"Nested AST Generation">
5655 and L</"Fine-grained Control over AST Generation">.
5656 Finally, the AST itself can be constructed using the following
5659 #include <isl/ast_build.h>
5660 __isl_give isl_ast_node *isl_ast_build_ast_from_schedule(
5661 __isl_keep isl_ast_build *build,
5662 __isl_take isl_union_map *schedule);
5664 =head3 Inspecting the AST
5666 The basic properties of an AST node can be obtained as follows.
5668 #include <isl/ast.h>
5669 isl_ctx *isl_ast_node_get_ctx(
5670 __isl_keep isl_ast_node *node);
5671 enum isl_ast_node_type isl_ast_node_get_type(
5672 __isl_keep isl_ast_node *node);
5674 The type of an AST node is one of
5675 C<isl_ast_node_for>,
5677 C<isl_ast_node_block> or
5678 C<isl_ast_node_user>.
5679 An C<isl_ast_node_for> represents a for node.
5680 An C<isl_ast_node_if> represents an if node.
5681 An C<isl_ast_node_block> represents a compound node.
5682 An C<isl_ast_node_user> represents an expression statement.
5683 An expression statement typically corresponds to a domain element, i.e.,
5684 one of the elements that is visited by the AST.
5686 Each type of node has its own additional properties.
5688 #include <isl/ast.h>
5689 __isl_give isl_ast_expr *isl_ast_node_for_get_iterator(
5690 __isl_keep isl_ast_node *node);
5691 __isl_give isl_ast_expr *isl_ast_node_for_get_init(
5692 __isl_keep isl_ast_node *node);
5693 __isl_give isl_ast_expr *isl_ast_node_for_get_cond(
5694 __isl_keep isl_ast_node *node);
5695 __isl_give isl_ast_expr *isl_ast_node_for_get_inc(
5696 __isl_keep isl_ast_node *node);
5697 __isl_give isl_ast_node *isl_ast_node_for_get_body(
5698 __isl_keep isl_ast_node *node);
5699 int isl_ast_node_for_is_degenerate(
5700 __isl_keep isl_ast_node *node);
5702 An C<isl_ast_for> is considered degenerate if it is known to execute
5705 #include <isl/ast.h>
5706 __isl_give isl_ast_expr *isl_ast_node_if_get_cond(
5707 __isl_keep isl_ast_node *node);
5708 __isl_give isl_ast_node *isl_ast_node_if_get_then(
5709 __isl_keep isl_ast_node *node);
5710 int isl_ast_node_if_has_else(
5711 __isl_keep isl_ast_node *node);
5712 __isl_give isl_ast_node *isl_ast_node_if_get_else(
5713 __isl_keep isl_ast_node *node);
5715 __isl_give isl_ast_node_list *
5716 isl_ast_node_block_get_children(
5717 __isl_keep isl_ast_node *node);
5719 __isl_give isl_ast_expr *isl_ast_node_user_get_expr(
5720 __isl_keep isl_ast_node *node);
5722 Each of the returned C<isl_ast_expr>s can in turn be inspected using
5723 the following functions.
5725 #include <isl/ast.h>
5726 isl_ctx *isl_ast_expr_get_ctx(
5727 __isl_keep isl_ast_expr *expr);
5728 enum isl_ast_expr_type isl_ast_expr_get_type(
5729 __isl_keep isl_ast_expr *expr);
5731 The type of an AST expression is one of
5733 C<isl_ast_expr_id> or
5734 C<isl_ast_expr_int>.
5735 An C<isl_ast_expr_op> represents the result of an operation.
5736 An C<isl_ast_expr_id> represents an identifier.
5737 An C<isl_ast_expr_int> represents an integer value.
5739 Each type of expression has its own additional properties.
5741 #include <isl/ast.h>
5742 enum isl_ast_op_type isl_ast_expr_get_op_type(
5743 __isl_keep isl_ast_expr *expr);
5744 int isl_ast_expr_get_op_n_arg(__isl_keep isl_ast_expr *expr);
5745 __isl_give isl_ast_expr *isl_ast_expr_get_op_arg(
5746 __isl_keep isl_ast_expr *expr, int pos);
5747 int isl_ast_node_foreach_ast_op_type(
5748 __isl_keep isl_ast_node *node,
5749 int (*fn)(enum isl_ast_op_type type, void *user),
5752 C<isl_ast_expr_get_op_type> returns the type of the operation
5753 performed. C<isl_ast_expr_get_op_n_arg> returns the number of
5754 arguments. C<isl_ast_expr_get_op_arg> returns the specified
5756 C<isl_ast_node_foreach_ast_op_type> calls C<fn> for each distinct
5757 C<isl_ast_op_type> that appears in C<node>.
5758 The operation type is one of the following.
5762 =item C<isl_ast_op_and>
5764 Logical I<and> of two arguments.
5765 Both arguments can be evaluated.
5767 =item C<isl_ast_op_and_then>
5769 Logical I<and> of two arguments.
5770 The second argument can only be evaluated if the first evaluates to true.
5772 =item C<isl_ast_op_or>
5774 Logical I<or> of two arguments.
5775 Both arguments can be evaluated.
5777 =item C<isl_ast_op_or_else>
5779 Logical I<or> of two arguments.
5780 The second argument can only be evaluated if the first evaluates to false.
5782 =item C<isl_ast_op_max>
5784 Maximum of two or more arguments.
5786 =item C<isl_ast_op_min>
5788 Minimum of two or more arguments.
5790 =item C<isl_ast_op_minus>
5794 =item C<isl_ast_op_add>
5796 Sum of two arguments.
5798 =item C<isl_ast_op_sub>
5800 Difference of two arguments.
5802 =item C<isl_ast_op_mul>
5804 Product of two arguments.
5806 =item C<isl_ast_op_div>
5808 Exact division. That is, the result is known to be an integer.
5810 =item C<isl_ast_op_fdiv_q>
5812 Result of integer division, rounded towards negative
5815 =item C<isl_ast_op_pdiv_q>
5817 Result of integer division, where dividend is known to be non-negative.
5819 =item C<isl_ast_op_pdiv_r>
5821 Remainder of integer division, where dividend is known to be non-negative.
5823 =item C<isl_ast_op_cond>
5825 Conditional operator defined on three arguments.
5826 If the first argument evaluates to true, then the result
5827 is equal to the second argument. Otherwise, the result
5828 is equal to the third argument.
5829 The second and third argument may only be evaluated if
5830 the first argument evaluates to true and false, respectively.
5831 Corresponds to C<a ? b : c> in C.
5833 =item C<isl_ast_op_select>
5835 Conditional operator defined on three arguments.
5836 If the first argument evaluates to true, then the result
5837 is equal to the second argument. Otherwise, the result
5838 is equal to the third argument.
5839 The second and third argument may be evaluated independently
5840 of the value of the first argument.
5841 Corresponds to C<a * b + (1 - a) * c> in C.
5843 =item C<isl_ast_op_eq>
5847 =item C<isl_ast_op_le>
5849 Less than or equal relation.
5851 =item C<isl_ast_op_lt>
5855 =item C<isl_ast_op_ge>
5857 Greater than or equal relation.
5859 =item C<isl_ast_op_gt>
5861 Greater than relation.
5863 =item C<isl_ast_op_call>
5866 The number of arguments of the C<isl_ast_expr> is one more than
5867 the number of arguments in the function call, the first argument
5868 representing the function being called.
5872 #include <isl/ast.h>
5873 __isl_give isl_id *isl_ast_expr_get_id(
5874 __isl_keep isl_ast_expr *expr);
5876 Return the identifier represented by the AST expression.
5878 #include <isl/ast.h>
5879 __isl_give isl_val *isl_ast_expr_get_val(
5880 __isl_keep isl_ast_expr *expr);
5882 Return the integer represented by the AST expression.
5884 =head3 Manipulating and printing the AST
5886 AST nodes can be copied and freed using the following functions.
5888 #include <isl/ast.h>
5889 __isl_give isl_ast_node *isl_ast_node_copy(
5890 __isl_keep isl_ast_node *node);
5891 void *isl_ast_node_free(__isl_take isl_ast_node *node);
5893 AST expressions can be copied and freed using the following functions.
5895 #include <isl/ast.h>
5896 __isl_give isl_ast_expr *isl_ast_expr_copy(
5897 __isl_keep isl_ast_expr *expr);
5898 void *isl_ast_expr_free(__isl_take isl_ast_expr *expr);
5900 New AST expressions can be created either directly or within
5901 the context of an C<isl_ast_build>.
5903 #include <isl/ast.h>
5904 __isl_give isl_ast_expr *isl_ast_expr_from_val(
5905 __isl_take isl_val *v);
5906 __isl_give isl_ast_expr *isl_ast_expr_from_id(
5907 __isl_take isl_id *id);
5908 __isl_give isl_ast_expr *isl_ast_expr_neg(
5909 __isl_take isl_ast_expr *expr);
5910 __isl_give isl_ast_expr *isl_ast_expr_add(
5911 __isl_take isl_ast_expr *expr1,
5912 __isl_take isl_ast_expr *expr2);
5913 __isl_give isl_ast_expr *isl_ast_expr_sub(
5914 __isl_take isl_ast_expr *expr1,
5915 __isl_take isl_ast_expr *expr2);
5916 __isl_give isl_ast_expr *isl_ast_expr_mul(
5917 __isl_take isl_ast_expr *expr1,
5918 __isl_take isl_ast_expr *expr2);
5919 __isl_give isl_ast_expr *isl_ast_expr_div(
5920 __isl_take isl_ast_expr *expr1,
5921 __isl_take isl_ast_expr *expr2);
5922 __isl_give isl_ast_expr *isl_ast_expr_and(
5923 __isl_take isl_ast_expr *expr1,
5924 __isl_take isl_ast_expr *expr2)
5925 __isl_give isl_ast_expr *isl_ast_expr_or(
5926 __isl_take isl_ast_expr *expr1,
5927 __isl_take isl_ast_expr *expr2)
5929 #include <isl/ast_build.h>
5930 __isl_give isl_ast_expr *isl_ast_build_expr_from_pw_aff(
5931 __isl_keep isl_ast_build *build,
5932 __isl_take isl_pw_aff *pa);
5933 __isl_give isl_ast_expr *
5934 isl_ast_build_call_from_pw_multi_aff(
5935 __isl_keep isl_ast_build *build,
5936 __isl_take isl_pw_multi_aff *pma);
5938 The domains of C<pa> and C<pma> should correspond
5939 to the schedule space of C<build>.
5940 The tuple id of C<pma> is used as the function being called.
5942 User specified data can be attached to an C<isl_ast_node> and obtained
5943 from the same C<isl_ast_node> using the following functions.
5945 #include <isl/ast.h>
5946 __isl_give isl_ast_node *isl_ast_node_set_annotation(
5947 __isl_take isl_ast_node *node,
5948 __isl_take isl_id *annotation);
5949 __isl_give isl_id *isl_ast_node_get_annotation(
5950 __isl_keep isl_ast_node *node);
5952 Basic printing can be performed using the following functions.
5954 #include <isl/ast.h>
5955 __isl_give isl_printer *isl_printer_print_ast_expr(
5956 __isl_take isl_printer *p,
5957 __isl_keep isl_ast_expr *expr);
5958 __isl_give isl_printer *isl_printer_print_ast_node(
5959 __isl_take isl_printer *p,
5960 __isl_keep isl_ast_node *node);
5962 More advanced printing can be performed using the following functions.
5964 #include <isl/ast.h>
5965 __isl_give isl_printer *isl_ast_op_type_print_macro(
5966 enum isl_ast_op_type type,
5967 __isl_take isl_printer *p);
5968 __isl_give isl_printer *isl_ast_node_print_macros(
5969 __isl_keep isl_ast_node *node,
5970 __isl_take isl_printer *p);
5971 __isl_give isl_printer *isl_ast_node_print(
5972 __isl_keep isl_ast_node *node,
5973 __isl_take isl_printer *p,
5974 __isl_take isl_ast_print_options *options);
5975 __isl_give isl_printer *isl_ast_node_for_print(
5976 __isl_keep isl_ast_node *node,
5977 __isl_take isl_printer *p,
5978 __isl_take isl_ast_print_options *options);
5979 __isl_give isl_printer *isl_ast_node_if_print(
5980 __isl_keep isl_ast_node *node,
5981 __isl_take isl_printer *p,
5982 __isl_take isl_ast_print_options *options);
5984 While printing an C<isl_ast_node> in C<ISL_FORMAT_C>,
5985 C<isl> may print out an AST that makes use of macros such
5986 as C<floord>, C<min> and C<max>.
5987 C<isl_ast_op_type_print_macro> prints out the macro
5988 corresponding to a specific C<isl_ast_op_type>.
5989 C<isl_ast_node_print_macros> scans the C<isl_ast_node>
5990 for expressions where these macros would be used and prints
5991 out the required macro definitions.
5992 Essentially, C<isl_ast_node_print_macros> calls
5993 C<isl_ast_node_foreach_ast_op_type> with C<isl_ast_op_type_print_macro>
5994 as function argument.
5995 C<isl_ast_node_print>, C<isl_ast_node_for_print> and
5996 C<isl_ast_node_if_print> print an C<isl_ast_node>
5997 in C<ISL_FORMAT_C>, but allow for some extra control
5998 through an C<isl_ast_print_options> object.
5999 This object can be created using the following functions.
6001 #include <isl/ast.h>
6002 __isl_give isl_ast_print_options *
6003 isl_ast_print_options_alloc(isl_ctx *ctx);
6004 __isl_give isl_ast_print_options *
6005 isl_ast_print_options_copy(
6006 __isl_keep isl_ast_print_options *options);
6007 void *isl_ast_print_options_free(
6008 __isl_take isl_ast_print_options *options);
6010 __isl_give isl_ast_print_options *
6011 isl_ast_print_options_set_print_user(
6012 __isl_take isl_ast_print_options *options,
6013 __isl_give isl_printer *(*print_user)(
6014 __isl_take isl_printer *p,
6015 __isl_take isl_ast_print_options *options,
6016 __isl_keep isl_ast_node *node, void *user),
6018 __isl_give isl_ast_print_options *
6019 isl_ast_print_options_set_print_for(
6020 __isl_take isl_ast_print_options *options,
6021 __isl_give isl_printer *(*print_for)(
6022 __isl_take isl_printer *p,
6023 __isl_take isl_ast_print_options *options,
6024 __isl_keep isl_ast_node *node, void *user),
6027 The callback set by C<isl_ast_print_options_set_print_user>
6028 is called whenever a node of type C<isl_ast_node_user> needs to
6030 The callback set by C<isl_ast_print_options_set_print_for>
6031 is called whenever a node of type C<isl_ast_node_for> needs to
6033 Note that C<isl_ast_node_for_print> will I<not> call the
6034 callback set by C<isl_ast_print_options_set_print_for> on the node
6035 on which C<isl_ast_node_for_print> is called, but only on nested
6036 nodes of type C<isl_ast_node_for>. It is therefore safe to
6037 call C<isl_ast_node_for_print> from within the callback set by
6038 C<isl_ast_print_options_set_print_for>.
6040 The following option determines the type to be used for iterators
6041 while printing the AST.
6043 int isl_options_set_ast_iterator_type(
6044 isl_ctx *ctx, const char *val);
6045 const char *isl_options_get_ast_iterator_type(
6050 #include <isl/ast_build.h>
6051 int isl_options_set_ast_build_atomic_upper_bound(
6052 isl_ctx *ctx, int val);
6053 int isl_options_get_ast_build_atomic_upper_bound(
6055 int isl_options_set_ast_build_prefer_pdiv(isl_ctx *ctx,
6057 int isl_options_get_ast_build_prefer_pdiv(isl_ctx *ctx);
6058 int isl_options_set_ast_build_exploit_nested_bounds(
6059 isl_ctx *ctx, int val);
6060 int isl_options_get_ast_build_exploit_nested_bounds(
6062 int isl_options_set_ast_build_group_coscheduled(
6063 isl_ctx *ctx, int val);
6064 int isl_options_get_ast_build_group_coscheduled(
6066 int isl_options_set_ast_build_scale_strides(
6067 isl_ctx *ctx, int val);
6068 int isl_options_get_ast_build_scale_strides(
6070 int isl_options_set_ast_build_allow_else(isl_ctx *ctx,
6072 int isl_options_get_ast_build_allow_else(isl_ctx *ctx);
6073 int isl_options_set_ast_build_allow_or(isl_ctx *ctx,
6075 int isl_options_get_ast_build_allow_or(isl_ctx *ctx);
6079 =item * ast_build_atomic_upper_bound
6081 Generate loop upper bounds that consist of the current loop iterator,
6082 an operator and an expression not involving the iterator.
6083 If this option is not set, then the current loop iterator may appear
6084 several times in the upper bound.
6085 For example, when this option is turned off, AST generation
6088 [n] -> { A[i] -> [i] : 0 <= i <= 100, n }
6092 for (int c0 = 0; c0 <= 100 && n >= c0; c0 += 1)
6095 When the option is turned on, the following AST is generated
6097 for (int c0 = 0; c0 <= min(100, n); c0 += 1)
6100 =item * ast_build_prefer_pdiv
6102 If this option is turned off, then the AST generation will
6103 produce ASTs that may only contain C<isl_ast_op_fdiv_q>
6104 operators, but no C<isl_ast_op_pdiv_q> or
6105 C<isl_ast_op_pdiv_r> operators.
6106 If this options is turned on, then C<isl> will try to convert
6107 some of the C<isl_ast_op_fdiv_q> operators to (expressions containing)
6108 C<isl_ast_op_pdiv_q> or C<isl_ast_op_pdiv_r> operators.
6110 =item * ast_build_exploit_nested_bounds
6112 Simplify conditions based on bounds of nested for loops.
6113 In particular, remove conditions that are implied by the fact
6114 that one or more nested loops have at least one iteration,
6115 meaning that the upper bound is at least as large as the lower bound.
6116 For example, when this option is turned off, AST generation
6119 [N,M] -> { A[i,j] -> [i,j] : 0 <= i <= N and
6125 for (int c0 = 0; c0 <= N; c0 += 1)
6126 for (int c1 = 0; c1 <= M; c1 += 1)
6129 When the option is turned on, the following AST is generated
6131 for (int c0 = 0; c0 <= N; c0 += 1)
6132 for (int c1 = 0; c1 <= M; c1 += 1)
6135 =item * ast_build_group_coscheduled
6137 If two domain elements are assigned the same schedule point, then
6138 they may be executed in any order and they may even appear in different
6139 loops. If this options is set, then the AST generator will make
6140 sure that coscheduled domain elements do not appear in separate parts
6141 of the AST. This is useful in case of nested AST generation
6142 if the outer AST generation is given only part of a schedule
6143 and the inner AST generation should handle the domains that are
6144 coscheduled by this initial part of the schedule together.
6145 For example if an AST is generated for a schedule
6147 { A[i] -> [0]; B[i] -> [0] }
6149 then the C<isl_ast_build_set_create_leaf> callback described
6150 below may get called twice, once for each domain.
6151 Setting this option ensures that the callback is only called once
6152 on both domains together.
6154 =item * ast_build_separation_bounds
6156 This option specifies which bounds to use during separation.
6157 If this option is set to C<ISL_AST_BUILD_SEPARATION_BOUNDS_IMPLICIT>
6158 then all (possibly implicit) bounds on the current dimension will
6159 be used during separation.
6160 If this option is set to C<ISL_AST_BUILD_SEPARATION_BOUNDS_EXPLICIT>
6161 then only those bounds that are explicitly available will
6162 be used during separation.
6164 =item * ast_build_scale_strides
6166 This option specifies whether the AST generator is allowed
6167 to scale down iterators of strided loops.
6169 =item * ast_build_allow_else
6171 This option specifies whether the AST generator is allowed
6172 to construct if statements with else branches.
6174 =item * ast_build_allow_or
6176 This option specifies whether the AST generator is allowed
6177 to construct if conditions with disjunctions.
6181 =head3 Fine-grained Control over AST Generation
6183 Besides specifying the constraints on the parameters,
6184 an C<isl_ast_build> object can be used to control
6185 various aspects of the AST generation process.
6186 The most prominent way of control is through ``options'',
6187 which can be set using the following function.
6189 #include <isl/ast_build.h>
6190 __isl_give isl_ast_build *
6191 isl_ast_build_set_options(
6192 __isl_take isl_ast_build *control,
6193 __isl_take isl_union_map *options);
6195 The options are encoded in an <isl_union_map>.
6196 The domain of this union relation refers to the schedule domain,
6197 i.e., the range of the schedule passed to C<isl_ast_build_ast_from_schedule>.
6198 In the case of nested AST generation (see L</"Nested AST Generation">),
6199 the domain of C<options> should refer to the extra piece of the schedule.
6200 That is, it should be equal to the range of the wrapped relation in the
6201 range of the schedule.
6202 The range of the options can consist of elements in one or more spaces,
6203 the names of which determine the effect of the option.
6204 The values of the range typically also refer to the schedule dimension
6205 to which the option applies. In case of nested AST generation
6206 (see L</"Nested AST Generation">), these values refer to the position
6207 of the schedule dimension within the innermost AST generation.
6208 The constraints on the domain elements of
6209 the option should only refer to this dimension and earlier dimensions.
6210 We consider the following spaces.
6214 =item C<separation_class>
6216 This space is a wrapped relation between two one dimensional spaces.
6217 The input space represents the schedule dimension to which the option
6218 applies and the output space represents the separation class.
6219 While constructing a loop corresponding to the specified schedule
6220 dimension(s), the AST generator will try to generate separate loops
6221 for domain elements that are assigned different classes.
6222 If only some of the elements are assigned a class, then those elements
6223 that are not assigned any class will be treated as belonging to a class
6224 that is separate from the explicitly assigned classes.
6225 The typical use case for this option is to separate full tiles from
6227 The other options, described below, are applied after the separation
6230 As an example, consider the separation into full and partial tiles
6231 of a tiling of a triangular domain.
6232 Take, for example, the domain
6234 { A[i,j] : 0 <= i,j and i + j <= 100 }
6236 and a tiling into tiles of 10 by 10. The input to the AST generator
6237 is then the schedule
6239 { A[i,j] -> [([i/10]),[j/10],i,j] : 0 <= i,j and
6242 Without any options, the following AST is generated
6244 for (int c0 = 0; c0 <= 10; c0 += 1)
6245 for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
6246 for (int c2 = 10 * c0;
6247 c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
6249 for (int c3 = 10 * c1;
6250 c3 <= min(10 * c1 + 9, -c2 + 100);
6254 Separation into full and partial tiles can be obtained by assigning
6255 a class, say C<0>, to the full tiles. The full tiles are represented by those
6256 values of the first and second schedule dimensions for which there are
6257 values of the third and fourth dimensions to cover an entire tile.
6258 That is, we need to specify the following option
6260 { [a,b,c,d] -> separation_class[[0]->[0]] :
6261 exists b': 0 <= 10a,10b' and
6262 10a+9+10b'+9 <= 100;
6263 [a,b,c,d] -> separation_class[[1]->[0]] :
6264 0 <= 10a,10b and 10a+9+10b+9 <= 100 }
6268 { [a, b, c, d] -> separation_class[[1] -> [0]] :
6269 a >= 0 and b >= 0 and b <= 8 - a;
6270 [a, b, c, d] -> separation_class[[0] -> [0]] :
6273 With this option, the generated AST is as follows
6276 for (int c0 = 0; c0 <= 8; c0 += 1) {
6277 for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
6278 for (int c2 = 10 * c0;
6279 c2 <= 10 * c0 + 9; c2 += 1)
6280 for (int c3 = 10 * c1;
6281 c3 <= 10 * c1 + 9; c3 += 1)
6283 for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
6284 for (int c2 = 10 * c0;
6285 c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
6287 for (int c3 = 10 * c1;
6288 c3 <= min(-c2 + 100, 10 * c1 + 9);
6292 for (int c0 = 9; c0 <= 10; c0 += 1)
6293 for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
6294 for (int c2 = 10 * c0;
6295 c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
6297 for (int c3 = 10 * c1;
6298 c3 <= min(10 * c1 + 9, -c2 + 100);
6305 This is a single-dimensional space representing the schedule dimension(s)
6306 to which ``separation'' should be applied. Separation tries to split
6307 a loop into several pieces if this can avoid the generation of guards
6309 See also the C<atomic> option.
6313 This is a single-dimensional space representing the schedule dimension(s)
6314 for which the domains should be considered ``atomic''. That is, the
6315 AST generator will make sure that any given domain space will only appear
6316 in a single loop at the specified level.
6318 Consider the following schedule
6320 { a[i] -> [i] : 0 <= i < 10;
6321 b[i] -> [i+1] : 0 <= i < 10 }
6323 If the following option is specified
6325 { [i] -> separate[x] }
6327 then the following AST will be generated
6331 for (int c0 = 1; c0 <= 9; c0 += 1) {
6338 If, on the other hand, the following option is specified
6340 { [i] -> atomic[x] }
6342 then the following AST will be generated
6344 for (int c0 = 0; c0 <= 10; c0 += 1) {
6351 If neither C<atomic> nor C<separate> is specified, then the AST generator
6352 may produce either of these two results or some intermediate form.
6356 This is a single-dimensional space representing the schedule dimension(s)
6357 that should be I<completely> unrolled.
6358 To obtain a partial unrolling, the user should apply an additional
6359 strip-mining to the schedule and fully unroll the inner loop.
6363 Additional control is available through the following functions.
6365 #include <isl/ast_build.h>
6366 __isl_give isl_ast_build *
6367 isl_ast_build_set_iterators(
6368 __isl_take isl_ast_build *control,
6369 __isl_take isl_id_list *iterators);
6371 The function C<isl_ast_build_set_iterators> allows the user to
6372 specify a list of iterator C<isl_id>s to be used as iterators.
6373 If the input schedule is injective, then
6374 the number of elements in this list should be as large as the dimension
6375 of the schedule space, but no direct correspondence should be assumed
6376 between dimensions and elements.
6377 If the input schedule is not injective, then an additional number
6378 of C<isl_id>s equal to the largest dimension of the input domains
6380 If the number of provided C<isl_id>s is insufficient, then additional
6381 names are automatically generated.
6383 #include <isl/ast_build.h>
6384 __isl_give isl_ast_build *
6385 isl_ast_build_set_create_leaf(
6386 __isl_take isl_ast_build *control,
6387 __isl_give isl_ast_node *(*fn)(
6388 __isl_take isl_ast_build *build,
6389 void *user), void *user);
6392 C<isl_ast_build_set_create_leaf> function allows for the
6393 specification of a callback that should be called whenever the AST
6394 generator arrives at an element of the schedule domain.
6395 The callback should return an AST node that should be inserted
6396 at the corresponding position of the AST. The default action (when
6397 the callback is not set) is to continue generating parts of the AST to scan
6398 all the domain elements associated to the schedule domain element
6399 and to insert user nodes, ``calling'' the domain element, for each of them.
6400 The C<build> argument contains the current state of the C<isl_ast_build>.
6401 To ease nested AST generation (see L</"Nested AST Generation">),
6402 all control information that is
6403 specific to the current AST generation such as the options and
6404 the callbacks has been removed from this C<isl_ast_build>.
6405 The callback would typically return the result of a nested
6407 user defined node created using the following function.
6409 #include <isl/ast.h>
6410 __isl_give isl_ast_node *isl_ast_node_alloc_user(
6411 __isl_take isl_ast_expr *expr);
6413 #include <isl/ast_build.h>
6414 __isl_give isl_ast_build *
6415 isl_ast_build_set_at_each_domain(
6416 __isl_take isl_ast_build *build,
6417 __isl_give isl_ast_node *(*fn)(
6418 __isl_take isl_ast_node *node,
6419 __isl_keep isl_ast_build *build,
6420 void *user), void *user);
6421 __isl_give isl_ast_build *
6422 isl_ast_build_set_before_each_for(
6423 __isl_take isl_ast_build *build,
6424 __isl_give isl_id *(*fn)(
6425 __isl_keep isl_ast_build *build,
6426 void *user), void *user);
6427 __isl_give isl_ast_build *
6428 isl_ast_build_set_after_each_for(
6429 __isl_take isl_ast_build *build,
6430 __isl_give isl_ast_node *(*fn)(
6431 __isl_take isl_ast_node *node,
6432 __isl_keep isl_ast_build *build,
6433 void *user), void *user);
6435 The callback set by C<isl_ast_build_set_at_each_domain> will
6436 be called for each domain AST node.
6437 The callbacks set by C<isl_ast_build_set_before_each_for>
6438 and C<isl_ast_build_set_after_each_for> will be called
6439 for each for AST node. The first will be called in depth-first
6440 pre-order, while the second will be called in depth-first post-order.
6441 Since C<isl_ast_build_set_before_each_for> is called before the for
6442 node is actually constructed, it is only passed an C<isl_ast_build>.
6443 The returned C<isl_id> will be added as an annotation (using
6444 C<isl_ast_node_set_annotation>) to the constructed for node.
6445 In particular, if the user has also specified an C<after_each_for>
6446 callback, then the annotation can be retrieved from the node passed to
6447 that callback using C<isl_ast_node_get_annotation>.
6448 All callbacks should C<NULL> on failure.
6449 The given C<isl_ast_build> can be used to create new
6450 C<isl_ast_expr> objects using C<isl_ast_build_expr_from_pw_aff>
6451 or C<isl_ast_build_call_from_pw_multi_aff>.
6453 =head3 Nested AST Generation
6455 C<isl> allows the user to create an AST within the context
6456 of another AST. These nested ASTs are created using the
6457 same C<isl_ast_build_ast_from_schedule> function that is used to create the
6458 outer AST. The C<build> argument should be an C<isl_ast_build>
6459 passed to a callback set by
6460 C<isl_ast_build_set_create_leaf>.
6461 The space of the range of the C<schedule> argument should refer
6462 to this build. In particular, the space should be a wrapped
6463 relation and the domain of this wrapped relation should be the
6464 same as that of the range of the schedule returned by
6465 C<isl_ast_build_get_schedule> below.
6466 In practice, the new schedule is typically
6467 created by calling C<isl_union_map_range_product> on the old schedule
6468 and some extra piece of the schedule.
6469 The space of the schedule domain is also available from
6470 the C<isl_ast_build>.
6472 #include <isl/ast_build.h>
6473 __isl_give isl_union_map *isl_ast_build_get_schedule(
6474 __isl_keep isl_ast_build *build);
6475 __isl_give isl_space *isl_ast_build_get_schedule_space(
6476 __isl_keep isl_ast_build *build);
6477 __isl_give isl_ast_build *isl_ast_build_restrict(
6478 __isl_take isl_ast_build *build,
6479 __isl_take isl_set *set);
6481 The C<isl_ast_build_get_schedule> function returns a (partial)
6482 schedule for the domains elements for which part of the AST still needs to
6483 be generated in the current build.
6484 In particular, the domain elements are mapped to those iterations of the loops
6485 enclosing the current point of the AST generation inside which
6486 the domain elements are executed.
6487 No direct correspondence between
6488 the input schedule and this schedule should be assumed.
6489 The space obtained from C<isl_ast_build_get_schedule_space> can be used
6490 to create a set for C<isl_ast_build_restrict> to intersect
6491 with the current build. In particular, the set passed to
6492 C<isl_ast_build_restrict> can have additional parameters.
6493 The ids of the set dimensions in the space returned by
6494 C<isl_ast_build_get_schedule_space> correspond to the
6495 iterators of the already generated loops.
6496 The user should not rely on the ids of the output dimensions
6497 of the relations in the union relation returned by
6498 C<isl_ast_build_get_schedule> having any particular value.
6502 Although C<isl> is mainly meant to be used as a library,
6503 it also contains some basic applications that use some
6504 of the functionality of C<isl>.
6505 The input may be specified in either the L<isl format>
6506 or the L<PolyLib format>.
6508 =head2 C<isl_polyhedron_sample>
6510 C<isl_polyhedron_sample> takes a polyhedron as input and prints
6511 an integer element of the polyhedron, if there is any.
6512 The first column in the output is the denominator and is always
6513 equal to 1. If the polyhedron contains no integer points,
6514 then a vector of length zero is printed.
6518 C<isl_pip> takes the same input as the C<example> program
6519 from the C<piplib> distribution, i.e., a set of constraints
6520 on the parameters, a line containing only -1 and finally a set
6521 of constraints on a parametric polyhedron.
6522 The coefficients of the parameters appear in the last columns
6523 (but before the final constant column).
6524 The output is the lexicographic minimum of the parametric polyhedron.
6525 As C<isl> currently does not have its own output format, the output
6526 is just a dump of the internal state.
6528 =head2 C<isl_polyhedron_minimize>
6530 C<isl_polyhedron_minimize> computes the minimum of some linear
6531 or affine objective function over the integer points in a polyhedron.
6532 If an affine objective function
6533 is given, then the constant should appear in the last column.
6535 =head2 C<isl_polytope_scan>
6537 Given a polytope, C<isl_polytope_scan> prints
6538 all integer points in the polytope.
6540 =head2 C<isl_codegen>
6542 Given a schedule, a context set and an options relation,
6543 C<isl_codegen> prints out an AST that scans the domain elements
6544 of the schedule in the order of their image(s) taking into account
6545 the constraints in the context set.