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_params(
925 __isl_take isl_space *space);
926 __isl_give isl_space *isl_space_set_from_params(
927 __isl_take isl_space *space);
928 __isl_give isl_space *isl_space_reverse(__isl_take isl_space *space);
929 __isl_give isl_space *isl_space_join(__isl_take isl_space *left,
930 __isl_take isl_space *right);
931 __isl_give isl_space *isl_space_align_params(
932 __isl_take isl_space *space1, __isl_take isl_space *space2)
933 __isl_give isl_space *isl_space_insert_dims(__isl_take isl_space *space,
934 enum isl_dim_type type, unsigned pos, unsigned n);
935 __isl_give isl_space *isl_space_add_dims(__isl_take isl_space *space,
936 enum isl_dim_type type, unsigned n);
937 __isl_give isl_space *isl_space_drop_dims(__isl_take isl_space *space,
938 enum isl_dim_type type, unsigned first, unsigned n);
939 __isl_give isl_space *isl_space_move_dims(__isl_take isl_space *space,
940 enum isl_dim_type dst_type, unsigned dst_pos,
941 enum isl_dim_type src_type, unsigned src_pos,
943 __isl_give isl_space *isl_space_map_from_set(
944 __isl_take isl_space *space);
945 __isl_give isl_space *isl_space_map_from_domain_and_range(
946 __isl_take isl_space *domain,
947 __isl_take isl_space *range);
948 __isl_give isl_space *isl_space_zip(__isl_take isl_space *space);
949 __isl_give isl_space *isl_space_curry(
950 __isl_take isl_space *space);
951 __isl_give isl_space *isl_space_uncurry(
952 __isl_take isl_space *space);
954 Note that if dimensions are added or removed from a space, then
955 the name and the internal structure are lost.
959 A local space is essentially a space with
960 zero or more existentially quantified variables.
961 The local space of a (constraint of a) basic set or relation can be obtained
962 using the following functions.
964 #include <isl/constraint.h>
965 __isl_give isl_local_space *isl_constraint_get_local_space(
966 __isl_keep isl_constraint *constraint);
969 __isl_give isl_local_space *isl_basic_set_get_local_space(
970 __isl_keep isl_basic_set *bset);
973 __isl_give isl_local_space *isl_basic_map_get_local_space(
974 __isl_keep isl_basic_map *bmap);
976 A new local space can be created from a space using
978 #include <isl/local_space.h>
979 __isl_give isl_local_space *isl_local_space_from_space(
980 __isl_take isl_space *space);
982 They can be inspected, modified, copied and freed using the following functions.
984 #include <isl/local_space.h>
985 isl_ctx *isl_local_space_get_ctx(
986 __isl_keep isl_local_space *ls);
987 int isl_local_space_is_set(__isl_keep isl_local_space *ls);
988 int isl_local_space_dim(__isl_keep isl_local_space *ls,
989 enum isl_dim_type type);
990 int isl_local_space_has_dim_id(
991 __isl_keep isl_local_space *ls,
992 enum isl_dim_type type, unsigned pos);
993 __isl_give isl_id *isl_local_space_get_dim_id(
994 __isl_keep isl_local_space *ls,
995 enum isl_dim_type type, unsigned pos);
996 int isl_local_space_has_dim_name(
997 __isl_keep isl_local_space *ls,
998 enum isl_dim_type type, unsigned pos)
999 const char *isl_local_space_get_dim_name(
1000 __isl_keep isl_local_space *ls,
1001 enum isl_dim_type type, unsigned pos);
1002 __isl_give isl_local_space *isl_local_space_set_dim_name(
1003 __isl_take isl_local_space *ls,
1004 enum isl_dim_type type, unsigned pos, const char *s);
1005 __isl_give isl_local_space *isl_local_space_set_dim_id(
1006 __isl_take isl_local_space *ls,
1007 enum isl_dim_type type, unsigned pos,
1008 __isl_take isl_id *id);
1009 __isl_give isl_space *isl_local_space_get_space(
1010 __isl_keep isl_local_space *ls);
1011 __isl_give isl_aff *isl_local_space_get_div(
1012 __isl_keep isl_local_space *ls, int pos);
1013 __isl_give isl_local_space *isl_local_space_copy(
1014 __isl_keep isl_local_space *ls);
1015 void *isl_local_space_free(__isl_take isl_local_space *ls);
1017 Note that C<isl_local_space_get_div> can only be used on local spaces
1020 Two local spaces can be compared using
1022 int isl_local_space_is_equal(__isl_keep isl_local_space *ls1,
1023 __isl_keep isl_local_space *ls2);
1025 Local spaces can be created from other local spaces
1026 using the following functions.
1028 __isl_give isl_local_space *isl_local_space_domain(
1029 __isl_take isl_local_space *ls);
1030 __isl_give isl_local_space *isl_local_space_range(
1031 __isl_take isl_local_space *ls);
1032 __isl_give isl_local_space *isl_local_space_from_domain(
1033 __isl_take isl_local_space *ls);
1034 __isl_give isl_local_space *isl_local_space_intersect(
1035 __isl_take isl_local_space *ls1,
1036 __isl_take isl_local_space *ls2);
1037 __isl_give isl_local_space *isl_local_space_add_dims(
1038 __isl_take isl_local_space *ls,
1039 enum isl_dim_type type, unsigned n);
1040 __isl_give isl_local_space *isl_local_space_insert_dims(
1041 __isl_take isl_local_space *ls,
1042 enum isl_dim_type type, unsigned first, unsigned n);
1043 __isl_give isl_local_space *isl_local_space_drop_dims(
1044 __isl_take isl_local_space *ls,
1045 enum isl_dim_type type, unsigned first, unsigned n);
1047 =head2 Input and Output
1049 C<isl> supports its own input/output format, which is similar
1050 to the C<Omega> format, but also supports the C<PolyLib> format
1053 =head3 C<isl> format
1055 The C<isl> format is similar to that of C<Omega>, but has a different
1056 syntax for describing the parameters and allows for the definition
1057 of an existentially quantified variable as the integer division
1058 of an affine expression.
1059 For example, the set of integers C<i> between C<0> and C<n>
1060 such that C<i % 10 <= 6> can be described as
1062 [n] -> { [i] : exists (a = [i/10] : 0 <= i and i <= n and
1065 A set or relation can have several disjuncts, separated
1066 by the keyword C<or>. Each disjunct is either a conjunction
1067 of constraints or a projection (C<exists>) of a conjunction
1068 of constraints. The constraints are separated by the keyword
1071 =head3 C<PolyLib> format
1073 If the represented set is a union, then the first line
1074 contains a single number representing the number of disjuncts.
1075 Otherwise, a line containing the number C<1> is optional.
1077 Each disjunct is represented by a matrix of constraints.
1078 The first line contains two numbers representing
1079 the number of rows and columns,
1080 where the number of rows is equal to the number of constraints
1081 and the number of columns is equal to two plus the number of variables.
1082 The following lines contain the actual rows of the constraint matrix.
1083 In each row, the first column indicates whether the constraint
1084 is an equality (C<0>) or inequality (C<1>). The final column
1085 corresponds to the constant term.
1087 If the set is parametric, then the coefficients of the parameters
1088 appear in the last columns before the constant column.
1089 The coefficients of any existentially quantified variables appear
1090 between those of the set variables and those of the parameters.
1092 =head3 Extended C<PolyLib> format
1094 The extended C<PolyLib> format is nearly identical to the
1095 C<PolyLib> format. The only difference is that the line
1096 containing the number of rows and columns of a constraint matrix
1097 also contains four additional numbers:
1098 the number of output dimensions, the number of input dimensions,
1099 the number of local dimensions (i.e., the number of existentially
1100 quantified variables) and the number of parameters.
1101 For sets, the number of ``output'' dimensions is equal
1102 to the number of set dimensions, while the number of ``input''
1107 #include <isl/set.h>
1108 __isl_give isl_basic_set *isl_basic_set_read_from_file(
1109 isl_ctx *ctx, FILE *input);
1110 __isl_give isl_basic_set *isl_basic_set_read_from_str(
1111 isl_ctx *ctx, const char *str);
1112 __isl_give isl_set *isl_set_read_from_file(isl_ctx *ctx,
1114 __isl_give isl_set *isl_set_read_from_str(isl_ctx *ctx,
1117 #include <isl/map.h>
1118 __isl_give isl_basic_map *isl_basic_map_read_from_file(
1119 isl_ctx *ctx, FILE *input);
1120 __isl_give isl_basic_map *isl_basic_map_read_from_str(
1121 isl_ctx *ctx, const char *str);
1122 __isl_give isl_map *isl_map_read_from_file(
1123 isl_ctx *ctx, FILE *input);
1124 __isl_give isl_map *isl_map_read_from_str(isl_ctx *ctx,
1127 #include <isl/union_set.h>
1128 __isl_give isl_union_set *isl_union_set_read_from_file(
1129 isl_ctx *ctx, FILE *input);
1130 __isl_give isl_union_set *isl_union_set_read_from_str(
1131 isl_ctx *ctx, const char *str);
1133 #include <isl/union_map.h>
1134 __isl_give isl_union_map *isl_union_map_read_from_file(
1135 isl_ctx *ctx, FILE *input);
1136 __isl_give isl_union_map *isl_union_map_read_from_str(
1137 isl_ctx *ctx, const char *str);
1139 The input format is autodetected and may be either the C<PolyLib> format
1140 or the C<isl> format.
1144 Before anything can be printed, an C<isl_printer> needs to
1147 __isl_give isl_printer *isl_printer_to_file(isl_ctx *ctx,
1149 __isl_give isl_printer *isl_printer_to_str(isl_ctx *ctx);
1150 void *isl_printer_free(__isl_take isl_printer *printer);
1151 __isl_give char *isl_printer_get_str(
1152 __isl_keep isl_printer *printer);
1154 The printer can be inspected using the following functions.
1156 FILE *isl_printer_get_file(
1157 __isl_keep isl_printer *printer);
1158 int isl_printer_get_output_format(
1159 __isl_keep isl_printer *p);
1161 The behavior of the printer can be modified in various ways
1163 __isl_give isl_printer *isl_printer_set_output_format(
1164 __isl_take isl_printer *p, int output_format);
1165 __isl_give isl_printer *isl_printer_set_indent(
1166 __isl_take isl_printer *p, int indent);
1167 __isl_give isl_printer *isl_printer_indent(
1168 __isl_take isl_printer *p, int indent);
1169 __isl_give isl_printer *isl_printer_set_prefix(
1170 __isl_take isl_printer *p, const char *prefix);
1171 __isl_give isl_printer *isl_printer_set_suffix(
1172 __isl_take isl_printer *p, const char *suffix);
1174 The C<output_format> may be either C<ISL_FORMAT_ISL>, C<ISL_FORMAT_OMEGA>,
1175 C<ISL_FORMAT_POLYLIB>, C<ISL_FORMAT_EXT_POLYLIB> or C<ISL_FORMAT_LATEX>
1176 and defaults to C<ISL_FORMAT_ISL>.
1177 Each line in the output is indented by C<indent> (set by
1178 C<isl_printer_set_indent>) spaces
1179 (default: 0), prefixed by C<prefix> and suffixed by C<suffix>.
1180 In the C<PolyLib> format output,
1181 the coefficients of the existentially quantified variables
1182 appear between those of the set variables and those
1184 The function C<isl_printer_indent> increases the indentation
1185 by the specified amount (which may be negative).
1187 To actually print something, use
1189 #include <isl/printer.h>
1190 __isl_give isl_printer *isl_printer_print_double(
1191 __isl_take isl_printer *p, double d);
1193 #include <isl/set.h>
1194 __isl_give isl_printer *isl_printer_print_basic_set(
1195 __isl_take isl_printer *printer,
1196 __isl_keep isl_basic_set *bset);
1197 __isl_give isl_printer *isl_printer_print_set(
1198 __isl_take isl_printer *printer,
1199 __isl_keep isl_set *set);
1201 #include <isl/map.h>
1202 __isl_give isl_printer *isl_printer_print_basic_map(
1203 __isl_take isl_printer *printer,
1204 __isl_keep isl_basic_map *bmap);
1205 __isl_give isl_printer *isl_printer_print_map(
1206 __isl_take isl_printer *printer,
1207 __isl_keep isl_map *map);
1209 #include <isl/union_set.h>
1210 __isl_give isl_printer *isl_printer_print_union_set(
1211 __isl_take isl_printer *p,
1212 __isl_keep isl_union_set *uset);
1214 #include <isl/union_map.h>
1215 __isl_give isl_printer *isl_printer_print_union_map(
1216 __isl_take isl_printer *p,
1217 __isl_keep isl_union_map *umap);
1219 When called on a file printer, the following function flushes
1220 the file. When called on a string printer, the buffer is cleared.
1222 __isl_give isl_printer *isl_printer_flush(
1223 __isl_take isl_printer *p);
1225 =head2 Creating New Sets and Relations
1227 C<isl> has functions for creating some standard sets and relations.
1231 =item * Empty sets and relations
1233 __isl_give isl_basic_set *isl_basic_set_empty(
1234 __isl_take isl_space *space);
1235 __isl_give isl_basic_map *isl_basic_map_empty(
1236 __isl_take isl_space *space);
1237 __isl_give isl_set *isl_set_empty(
1238 __isl_take isl_space *space);
1239 __isl_give isl_map *isl_map_empty(
1240 __isl_take isl_space *space);
1241 __isl_give isl_union_set *isl_union_set_empty(
1242 __isl_take isl_space *space);
1243 __isl_give isl_union_map *isl_union_map_empty(
1244 __isl_take isl_space *space);
1246 For C<isl_union_set>s and C<isl_union_map>s, the space
1247 is only used to specify the parameters.
1249 =item * Universe sets and relations
1251 __isl_give isl_basic_set *isl_basic_set_universe(
1252 __isl_take isl_space *space);
1253 __isl_give isl_basic_map *isl_basic_map_universe(
1254 __isl_take isl_space *space);
1255 __isl_give isl_set *isl_set_universe(
1256 __isl_take isl_space *space);
1257 __isl_give isl_map *isl_map_universe(
1258 __isl_take isl_space *space);
1259 __isl_give isl_union_set *isl_union_set_universe(
1260 __isl_take isl_union_set *uset);
1261 __isl_give isl_union_map *isl_union_map_universe(
1262 __isl_take isl_union_map *umap);
1264 The sets and relations constructed by the functions above
1265 contain all integer values, while those constructed by the
1266 functions below only contain non-negative values.
1268 __isl_give isl_basic_set *isl_basic_set_nat_universe(
1269 __isl_take isl_space *space);
1270 __isl_give isl_basic_map *isl_basic_map_nat_universe(
1271 __isl_take isl_space *space);
1272 __isl_give isl_set *isl_set_nat_universe(
1273 __isl_take isl_space *space);
1274 __isl_give isl_map *isl_map_nat_universe(
1275 __isl_take isl_space *space);
1277 =item * Identity relations
1279 __isl_give isl_basic_map *isl_basic_map_identity(
1280 __isl_take isl_space *space);
1281 __isl_give isl_map *isl_map_identity(
1282 __isl_take isl_space *space);
1284 The number of input and output dimensions in C<space> needs
1287 =item * Lexicographic order
1289 __isl_give isl_map *isl_map_lex_lt(
1290 __isl_take isl_space *set_space);
1291 __isl_give isl_map *isl_map_lex_le(
1292 __isl_take isl_space *set_space);
1293 __isl_give isl_map *isl_map_lex_gt(
1294 __isl_take isl_space *set_space);
1295 __isl_give isl_map *isl_map_lex_ge(
1296 __isl_take isl_space *set_space);
1297 __isl_give isl_map *isl_map_lex_lt_first(
1298 __isl_take isl_space *space, unsigned n);
1299 __isl_give isl_map *isl_map_lex_le_first(
1300 __isl_take isl_space *space, unsigned n);
1301 __isl_give isl_map *isl_map_lex_gt_first(
1302 __isl_take isl_space *space, unsigned n);
1303 __isl_give isl_map *isl_map_lex_ge_first(
1304 __isl_take isl_space *space, unsigned n);
1306 The first four functions take a space for a B<set>
1307 and return relations that express that the elements in the domain
1308 are lexicographically less
1309 (C<isl_map_lex_lt>), less or equal (C<isl_map_lex_le>),
1310 greater (C<isl_map_lex_gt>) or greater or equal (C<isl_map_lex_ge>)
1311 than the elements in the range.
1312 The last four functions take a space for a map
1313 and return relations that express that the first C<n> dimensions
1314 in the domain are lexicographically less
1315 (C<isl_map_lex_lt_first>), less or equal (C<isl_map_lex_le_first>),
1316 greater (C<isl_map_lex_gt_first>) or greater or equal (C<isl_map_lex_ge_first>)
1317 than the first C<n> dimensions in the range.
1321 A basic set or relation can be converted to a set or relation
1322 using the following functions.
1324 __isl_give isl_set *isl_set_from_basic_set(
1325 __isl_take isl_basic_set *bset);
1326 __isl_give isl_map *isl_map_from_basic_map(
1327 __isl_take isl_basic_map *bmap);
1329 Sets and relations can be converted to union sets and relations
1330 using the following functions.
1332 __isl_give isl_union_set *isl_union_set_from_basic_set(
1333 __isl_take isl_basic_set *bset);
1334 __isl_give isl_union_map *isl_union_map_from_basic_map(
1335 __isl_take isl_basic_map *bmap);
1336 __isl_give isl_union_set *isl_union_set_from_set(
1337 __isl_take isl_set *set);
1338 __isl_give isl_union_map *isl_union_map_from_map(
1339 __isl_take isl_map *map);
1341 The inverse conversions below can only be used if the input
1342 union set or relation is known to contain elements in exactly one
1345 __isl_give isl_set *isl_set_from_union_set(
1346 __isl_take isl_union_set *uset);
1347 __isl_give isl_map *isl_map_from_union_map(
1348 __isl_take isl_union_map *umap);
1350 A zero-dimensional (basic) set can be constructed on a given parameter domain
1351 using the following function.
1353 __isl_give isl_basic_set *isl_basic_set_from_params(
1354 __isl_take isl_basic_set *bset);
1355 __isl_give isl_set *isl_set_from_params(
1356 __isl_take isl_set *set);
1358 Sets and relations can be copied and freed again using the following
1361 __isl_give isl_basic_set *isl_basic_set_copy(
1362 __isl_keep isl_basic_set *bset);
1363 __isl_give isl_set *isl_set_copy(__isl_keep isl_set *set);
1364 __isl_give isl_union_set *isl_union_set_copy(
1365 __isl_keep isl_union_set *uset);
1366 __isl_give isl_basic_map *isl_basic_map_copy(
1367 __isl_keep isl_basic_map *bmap);
1368 __isl_give isl_map *isl_map_copy(__isl_keep isl_map *map);
1369 __isl_give isl_union_map *isl_union_map_copy(
1370 __isl_keep isl_union_map *umap);
1371 void *isl_basic_set_free(__isl_take isl_basic_set *bset);
1372 void *isl_set_free(__isl_take isl_set *set);
1373 void *isl_union_set_free(__isl_take isl_union_set *uset);
1374 void *isl_basic_map_free(__isl_take isl_basic_map *bmap);
1375 void *isl_map_free(__isl_take isl_map *map);
1376 void *isl_union_map_free(__isl_take isl_union_map *umap);
1378 Other sets and relations can be constructed by starting
1379 from a universe set or relation, adding equality and/or
1380 inequality constraints and then projecting out the
1381 existentially quantified variables, if any.
1382 Constraints can be constructed, manipulated and
1383 added to (or removed from) (basic) sets and relations
1384 using the following functions.
1386 #include <isl/constraint.h>
1387 __isl_give isl_constraint *isl_equality_alloc(
1388 __isl_take isl_local_space *ls);
1389 __isl_give isl_constraint *isl_inequality_alloc(
1390 __isl_take isl_local_space *ls);
1391 __isl_give isl_constraint *isl_constraint_set_constant_si(
1392 __isl_take isl_constraint *constraint, int v);
1393 __isl_give isl_constraint *isl_constraint_set_constant_val(
1394 __isl_take isl_constraint *constraint,
1395 __isl_take isl_val *v);
1396 __isl_give isl_constraint *isl_constraint_set_coefficient_si(
1397 __isl_take isl_constraint *constraint,
1398 enum isl_dim_type type, int pos, int v);
1399 __isl_give isl_constraint *
1400 isl_constraint_set_coefficient_val(
1401 __isl_take isl_constraint *constraint,
1402 enum isl_dim_type type, int pos, isl_val *v);
1403 __isl_give isl_basic_map *isl_basic_map_add_constraint(
1404 __isl_take isl_basic_map *bmap,
1405 __isl_take isl_constraint *constraint);
1406 __isl_give isl_basic_set *isl_basic_set_add_constraint(
1407 __isl_take isl_basic_set *bset,
1408 __isl_take isl_constraint *constraint);
1409 __isl_give isl_map *isl_map_add_constraint(
1410 __isl_take isl_map *map,
1411 __isl_take isl_constraint *constraint);
1412 __isl_give isl_set *isl_set_add_constraint(
1413 __isl_take isl_set *set,
1414 __isl_take isl_constraint *constraint);
1415 __isl_give isl_basic_set *isl_basic_set_drop_constraint(
1416 __isl_take isl_basic_set *bset,
1417 __isl_take isl_constraint *constraint);
1419 For example, to create a set containing the even integers
1420 between 10 and 42, you would use the following code.
1423 isl_local_space *ls;
1425 isl_basic_set *bset;
1427 space = isl_space_set_alloc(ctx, 0, 2);
1428 bset = isl_basic_set_universe(isl_space_copy(space));
1429 ls = isl_local_space_from_space(space);
1431 c = isl_equality_alloc(isl_local_space_copy(ls));
1432 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
1433 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 2);
1434 bset = isl_basic_set_add_constraint(bset, c);
1436 c = isl_inequality_alloc(isl_local_space_copy(ls));
1437 c = isl_constraint_set_constant_si(c, -10);
1438 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
1439 bset = isl_basic_set_add_constraint(bset, c);
1441 c = isl_inequality_alloc(ls);
1442 c = isl_constraint_set_constant_si(c, 42);
1443 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
1444 bset = isl_basic_set_add_constraint(bset, c);
1446 bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 1);
1450 isl_basic_set *bset;
1451 bset = isl_basic_set_read_from_str(ctx,
1452 "{[i] : exists (a : i = 2a and i >= 10 and i <= 42)}");
1454 A basic set or relation can also be constructed from two matrices
1455 describing the equalities and the inequalities.
1457 __isl_give isl_basic_set *isl_basic_set_from_constraint_matrices(
1458 __isl_take isl_space *space,
1459 __isl_take isl_mat *eq, __isl_take isl_mat *ineq,
1460 enum isl_dim_type c1,
1461 enum isl_dim_type c2, enum isl_dim_type c3,
1462 enum isl_dim_type c4);
1463 __isl_give isl_basic_map *isl_basic_map_from_constraint_matrices(
1464 __isl_take isl_space *space,
1465 __isl_take isl_mat *eq, __isl_take isl_mat *ineq,
1466 enum isl_dim_type c1,
1467 enum isl_dim_type c2, enum isl_dim_type c3,
1468 enum isl_dim_type c4, enum isl_dim_type c5);
1470 The C<isl_dim_type> arguments indicate the order in which
1471 different kinds of variables appear in the input matrices
1472 and should be a permutation of C<isl_dim_cst>, C<isl_dim_param>,
1473 C<isl_dim_set> and C<isl_dim_div> for sets and
1474 of C<isl_dim_cst>, C<isl_dim_param>,
1475 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div> for relations.
1477 A (basic or union) set or relation can also be constructed from a
1478 (union) (piecewise) (multiple) affine expression
1479 or a list of affine expressions
1480 (See L<"Piecewise Quasi Affine Expressions"> and
1481 L<"Piecewise Multiple Quasi Affine Expressions">).
1483 __isl_give isl_basic_map *isl_basic_map_from_aff(
1484 __isl_take isl_aff *aff);
1485 __isl_give isl_map *isl_map_from_aff(
1486 __isl_take isl_aff *aff);
1487 __isl_give isl_set *isl_set_from_pw_aff(
1488 __isl_take isl_pw_aff *pwaff);
1489 __isl_give isl_map *isl_map_from_pw_aff(
1490 __isl_take isl_pw_aff *pwaff);
1491 __isl_give isl_basic_map *isl_basic_map_from_aff_list(
1492 __isl_take isl_space *domain_space,
1493 __isl_take isl_aff_list *list);
1494 __isl_give isl_basic_map *isl_basic_map_from_multi_aff(
1495 __isl_take isl_multi_aff *maff)
1496 __isl_give isl_map *isl_map_from_multi_aff(
1497 __isl_take isl_multi_aff *maff)
1498 __isl_give isl_set *isl_set_from_pw_multi_aff(
1499 __isl_take isl_pw_multi_aff *pma);
1500 __isl_give isl_map *isl_map_from_pw_multi_aff(
1501 __isl_take isl_pw_multi_aff *pma);
1502 __isl_give isl_union_map *
1503 isl_union_map_from_union_pw_multi_aff(
1504 __isl_take isl_union_pw_multi_aff *upma);
1506 The C<domain_dim> argument describes the domain of the resulting
1507 basic relation. It is required because the C<list> may consist
1508 of zero affine expressions.
1510 =head2 Inspecting Sets and Relations
1512 Usually, the user should not have to care about the actual constraints
1513 of the sets and maps, but should instead apply the abstract operations
1514 explained in the following sections.
1515 Occasionally, however, it may be required to inspect the individual
1516 coefficients of the constraints. This section explains how to do so.
1517 In these cases, it may also be useful to have C<isl> compute
1518 an explicit representation of the existentially quantified variables.
1520 __isl_give isl_set *isl_set_compute_divs(
1521 __isl_take isl_set *set);
1522 __isl_give isl_map *isl_map_compute_divs(
1523 __isl_take isl_map *map);
1524 __isl_give isl_union_set *isl_union_set_compute_divs(
1525 __isl_take isl_union_set *uset);
1526 __isl_give isl_union_map *isl_union_map_compute_divs(
1527 __isl_take isl_union_map *umap);
1529 This explicit representation defines the existentially quantified
1530 variables as integer divisions of the other variables, possibly
1531 including earlier existentially quantified variables.
1532 An explicitly represented existentially quantified variable therefore
1533 has a unique value when the values of the other variables are known.
1534 If, furthermore, the same existentials, i.e., existentials
1535 with the same explicit representations, should appear in the
1536 same order in each of the disjuncts of a set or map, then the user should call
1537 either of the following functions.
1539 __isl_give isl_set *isl_set_align_divs(
1540 __isl_take isl_set *set);
1541 __isl_give isl_map *isl_map_align_divs(
1542 __isl_take isl_map *map);
1544 Alternatively, the existentially quantified variables can be removed
1545 using the following functions, which compute an overapproximation.
1547 __isl_give isl_basic_set *isl_basic_set_remove_divs(
1548 __isl_take isl_basic_set *bset);
1549 __isl_give isl_basic_map *isl_basic_map_remove_divs(
1550 __isl_take isl_basic_map *bmap);
1551 __isl_give isl_set *isl_set_remove_divs(
1552 __isl_take isl_set *set);
1553 __isl_give isl_map *isl_map_remove_divs(
1554 __isl_take isl_map *map);
1556 It is also possible to only remove those divs that are defined
1557 in terms of a given range of dimensions or only those for which
1558 no explicit representation is known.
1560 __isl_give isl_basic_set *
1561 isl_basic_set_remove_divs_involving_dims(
1562 __isl_take isl_basic_set *bset,
1563 enum isl_dim_type type,
1564 unsigned first, unsigned n);
1565 __isl_give isl_basic_map *
1566 isl_basic_map_remove_divs_involving_dims(
1567 __isl_take isl_basic_map *bmap,
1568 enum isl_dim_type type,
1569 unsigned first, unsigned n);
1570 __isl_give isl_set *isl_set_remove_divs_involving_dims(
1571 __isl_take isl_set *set, enum isl_dim_type type,
1572 unsigned first, unsigned n);
1573 __isl_give isl_map *isl_map_remove_divs_involving_dims(
1574 __isl_take isl_map *map, enum isl_dim_type type,
1575 unsigned first, unsigned n);
1577 __isl_give isl_basic_set *
1578 isl_basic_set_remove_unknown_divs(
1579 __isl_take isl_basic_set *bset);
1580 __isl_give isl_set *isl_set_remove_unknown_divs(
1581 __isl_take isl_set *set);
1582 __isl_give isl_map *isl_map_remove_unknown_divs(
1583 __isl_take isl_map *map);
1585 To iterate over all the sets or maps in a union set or map, use
1587 int isl_union_set_foreach_set(__isl_keep isl_union_set *uset,
1588 int (*fn)(__isl_take isl_set *set, void *user),
1590 int isl_union_map_foreach_map(__isl_keep isl_union_map *umap,
1591 int (*fn)(__isl_take isl_map *map, void *user),
1594 The number of sets or maps in a union set or map can be obtained
1597 int isl_union_set_n_set(__isl_keep isl_union_set *uset);
1598 int isl_union_map_n_map(__isl_keep isl_union_map *umap);
1600 To extract the set or map in a given space from a union, use
1602 __isl_give isl_set *isl_union_set_extract_set(
1603 __isl_keep isl_union_set *uset,
1604 __isl_take isl_space *space);
1605 __isl_give isl_map *isl_union_map_extract_map(
1606 __isl_keep isl_union_map *umap,
1607 __isl_take isl_space *space);
1609 To iterate over all the basic sets or maps in a set or map, use
1611 int isl_set_foreach_basic_set(__isl_keep isl_set *set,
1612 int (*fn)(__isl_take isl_basic_set *bset, void *user),
1614 int isl_map_foreach_basic_map(__isl_keep isl_map *map,
1615 int (*fn)(__isl_take isl_basic_map *bmap, void *user),
1618 The callback function C<fn> should return 0 if successful and
1619 -1 if an error occurs. In the latter case, or if any other error
1620 occurs, the above functions will return -1.
1622 It should be noted that C<isl> does not guarantee that
1623 the basic sets or maps passed to C<fn> are disjoint.
1624 If this is required, then the user should call one of
1625 the following functions first.
1627 __isl_give isl_set *isl_set_make_disjoint(
1628 __isl_take isl_set *set);
1629 __isl_give isl_map *isl_map_make_disjoint(
1630 __isl_take isl_map *map);
1632 The number of basic sets in a set can be obtained
1635 int isl_set_n_basic_set(__isl_keep isl_set *set);
1637 To iterate over the constraints of a basic set or map, use
1639 #include <isl/constraint.h>
1641 int isl_basic_set_n_constraint(
1642 __isl_keep isl_basic_set *bset);
1643 int isl_basic_set_foreach_constraint(
1644 __isl_keep isl_basic_set *bset,
1645 int (*fn)(__isl_take isl_constraint *c, void *user),
1647 int isl_basic_map_foreach_constraint(
1648 __isl_keep isl_basic_map *bmap,
1649 int (*fn)(__isl_take isl_constraint *c, void *user),
1651 void *isl_constraint_free(__isl_take isl_constraint *c);
1653 Again, the callback function C<fn> should return 0 if successful and
1654 -1 if an error occurs. In the latter case, or if any other error
1655 occurs, the above functions will return -1.
1656 The constraint C<c> represents either an equality or an inequality.
1657 Use the following function to find out whether a constraint
1658 represents an equality. If not, it represents an inequality.
1660 int isl_constraint_is_equality(
1661 __isl_keep isl_constraint *constraint);
1663 The coefficients of the constraints can be inspected using
1664 the following functions.
1666 int isl_constraint_is_lower_bound(
1667 __isl_keep isl_constraint *constraint,
1668 enum isl_dim_type type, unsigned pos);
1669 int isl_constraint_is_upper_bound(
1670 __isl_keep isl_constraint *constraint,
1671 enum isl_dim_type type, unsigned pos);
1672 __isl_give isl_val *isl_constraint_get_constant_val(
1673 __isl_keep isl_constraint *constraint);
1674 __isl_give isl_val *isl_constraint_get_coefficient_val(
1675 __isl_keep isl_constraint *constraint,
1676 enum isl_dim_type type, int pos);
1677 int isl_constraint_involves_dims(
1678 __isl_keep isl_constraint *constraint,
1679 enum isl_dim_type type, unsigned first, unsigned n);
1681 The explicit representations of the existentially quantified
1682 variables can be inspected using the following function.
1683 Note that the user is only allowed to use this function
1684 if the inspected set or map is the result of a call
1685 to C<isl_set_compute_divs> or C<isl_map_compute_divs>.
1686 The existentially quantified variable is equal to the floor
1687 of the returned affine expression. The affine expression
1688 itself can be inspected using the functions in
1689 L<"Piecewise Quasi Affine Expressions">.
1691 __isl_give isl_aff *isl_constraint_get_div(
1692 __isl_keep isl_constraint *constraint, int pos);
1694 To obtain the constraints of a basic set or map in matrix
1695 form, use the following functions.
1697 __isl_give isl_mat *isl_basic_set_equalities_matrix(
1698 __isl_keep isl_basic_set *bset,
1699 enum isl_dim_type c1, enum isl_dim_type c2,
1700 enum isl_dim_type c3, enum isl_dim_type c4);
1701 __isl_give isl_mat *isl_basic_set_inequalities_matrix(
1702 __isl_keep isl_basic_set *bset,
1703 enum isl_dim_type c1, enum isl_dim_type c2,
1704 enum isl_dim_type c3, enum isl_dim_type c4);
1705 __isl_give isl_mat *isl_basic_map_equalities_matrix(
1706 __isl_keep isl_basic_map *bmap,
1707 enum isl_dim_type c1,
1708 enum isl_dim_type c2, enum isl_dim_type c3,
1709 enum isl_dim_type c4, enum isl_dim_type c5);
1710 __isl_give isl_mat *isl_basic_map_inequalities_matrix(
1711 __isl_keep isl_basic_map *bmap,
1712 enum isl_dim_type c1,
1713 enum isl_dim_type c2, enum isl_dim_type c3,
1714 enum isl_dim_type c4, enum isl_dim_type c5);
1716 The C<isl_dim_type> arguments dictate the order in which
1717 different kinds of variables appear in the resulting matrix
1718 and should be a permutation of C<isl_dim_cst>, C<isl_dim_param>,
1719 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div>.
1721 The number of parameters, input, output or set dimensions can
1722 be obtained using the following functions.
1724 unsigned isl_basic_set_dim(__isl_keep isl_basic_set *bset,
1725 enum isl_dim_type type);
1726 unsigned isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
1727 enum isl_dim_type type);
1728 unsigned isl_set_dim(__isl_keep isl_set *set,
1729 enum isl_dim_type type);
1730 unsigned isl_map_dim(__isl_keep isl_map *map,
1731 enum isl_dim_type type);
1733 To check whether the description of a set or relation depends
1734 on one or more given dimensions, it is not necessary to iterate over all
1735 constraints. Instead the following functions can be used.
1737 int isl_basic_set_involves_dims(
1738 __isl_keep isl_basic_set *bset,
1739 enum isl_dim_type type, unsigned first, unsigned n);
1740 int isl_set_involves_dims(__isl_keep isl_set *set,
1741 enum isl_dim_type type, unsigned first, unsigned n);
1742 int isl_basic_map_involves_dims(
1743 __isl_keep isl_basic_map *bmap,
1744 enum isl_dim_type type, unsigned first, unsigned n);
1745 int isl_map_involves_dims(__isl_keep isl_map *map,
1746 enum isl_dim_type type, unsigned first, unsigned n);
1748 Similarly, the following functions can be used to check whether
1749 a given dimension is involved in any lower or upper bound.
1751 int isl_set_dim_has_any_lower_bound(__isl_keep isl_set *set,
1752 enum isl_dim_type type, unsigned pos);
1753 int isl_set_dim_has_any_upper_bound(__isl_keep isl_set *set,
1754 enum isl_dim_type type, unsigned pos);
1756 Note that these functions return true even if there is a bound on
1757 the dimension on only some of the basic sets of C<set>.
1758 To check if they have a bound for all of the basic sets in C<set>,
1759 use the following functions instead.
1761 int isl_set_dim_has_lower_bound(__isl_keep isl_set *set,
1762 enum isl_dim_type type, unsigned pos);
1763 int isl_set_dim_has_upper_bound(__isl_keep isl_set *set,
1764 enum isl_dim_type type, unsigned pos);
1766 The identifiers or names of the domain and range spaces of a set
1767 or relation can be read off or set using the following functions.
1769 __isl_give isl_set *isl_set_set_tuple_id(
1770 __isl_take isl_set *set, __isl_take isl_id *id);
1771 __isl_give isl_set *isl_set_reset_tuple_id(
1772 __isl_take isl_set *set);
1773 int isl_set_has_tuple_id(__isl_keep isl_set *set);
1774 __isl_give isl_id *isl_set_get_tuple_id(
1775 __isl_keep isl_set *set);
1776 __isl_give isl_map *isl_map_set_tuple_id(
1777 __isl_take isl_map *map, enum isl_dim_type type,
1778 __isl_take isl_id *id);
1779 __isl_give isl_map *isl_map_reset_tuple_id(
1780 __isl_take isl_map *map, enum isl_dim_type type);
1781 int isl_map_has_tuple_id(__isl_keep isl_map *map,
1782 enum isl_dim_type type);
1783 __isl_give isl_id *isl_map_get_tuple_id(
1784 __isl_keep isl_map *map, enum isl_dim_type type);
1786 const char *isl_basic_set_get_tuple_name(
1787 __isl_keep isl_basic_set *bset);
1788 __isl_give isl_basic_set *isl_basic_set_set_tuple_name(
1789 __isl_take isl_basic_set *set, const char *s);
1790 int isl_set_has_tuple_name(__isl_keep isl_set *set);
1791 const char *isl_set_get_tuple_name(
1792 __isl_keep isl_set *set);
1793 const char *isl_basic_map_get_tuple_name(
1794 __isl_keep isl_basic_map *bmap,
1795 enum isl_dim_type type);
1796 __isl_give isl_basic_map *isl_basic_map_set_tuple_name(
1797 __isl_take isl_basic_map *bmap,
1798 enum isl_dim_type type, const char *s);
1799 int isl_map_has_tuple_name(__isl_keep isl_map *map,
1800 enum isl_dim_type type);
1801 const char *isl_map_get_tuple_name(
1802 __isl_keep isl_map *map,
1803 enum isl_dim_type type);
1805 As with C<isl_space_get_tuple_name>, the value returned points to
1806 an internal data structure.
1807 The identifiers, positions or names of individual dimensions can be
1808 read off using the following functions.
1810 __isl_give isl_id *isl_basic_set_get_dim_id(
1811 __isl_keep isl_basic_set *bset,
1812 enum isl_dim_type type, unsigned pos);
1813 __isl_give isl_set *isl_set_set_dim_id(
1814 __isl_take isl_set *set, enum isl_dim_type type,
1815 unsigned pos, __isl_take isl_id *id);
1816 int isl_set_has_dim_id(__isl_keep isl_set *set,
1817 enum isl_dim_type type, unsigned pos);
1818 __isl_give isl_id *isl_set_get_dim_id(
1819 __isl_keep isl_set *set, enum isl_dim_type type,
1821 int isl_basic_map_has_dim_id(
1822 __isl_keep isl_basic_map *bmap,
1823 enum isl_dim_type type, unsigned pos);
1824 __isl_give isl_map *isl_map_set_dim_id(
1825 __isl_take isl_map *map, enum isl_dim_type type,
1826 unsigned pos, __isl_take isl_id *id);
1827 int isl_map_has_dim_id(__isl_keep isl_map *map,
1828 enum isl_dim_type type, unsigned pos);
1829 __isl_give isl_id *isl_map_get_dim_id(
1830 __isl_keep isl_map *map, enum isl_dim_type type,
1833 int isl_set_find_dim_by_id(__isl_keep isl_set *set,
1834 enum isl_dim_type type, __isl_keep isl_id *id);
1835 int isl_map_find_dim_by_id(__isl_keep isl_map *map,
1836 enum isl_dim_type type, __isl_keep isl_id *id);
1837 int isl_set_find_dim_by_name(__isl_keep isl_set *set,
1838 enum isl_dim_type type, const char *name);
1839 int isl_map_find_dim_by_name(__isl_keep isl_map *map,
1840 enum isl_dim_type type, const char *name);
1842 const char *isl_constraint_get_dim_name(
1843 __isl_keep isl_constraint *constraint,
1844 enum isl_dim_type type, unsigned pos);
1845 const char *isl_basic_set_get_dim_name(
1846 __isl_keep isl_basic_set *bset,
1847 enum isl_dim_type type, unsigned pos);
1848 int isl_set_has_dim_name(__isl_keep isl_set *set,
1849 enum isl_dim_type type, unsigned pos);
1850 const char *isl_set_get_dim_name(
1851 __isl_keep isl_set *set,
1852 enum isl_dim_type type, unsigned pos);
1853 const char *isl_basic_map_get_dim_name(
1854 __isl_keep isl_basic_map *bmap,
1855 enum isl_dim_type type, unsigned pos);
1856 int isl_map_has_dim_name(__isl_keep isl_map *map,
1857 enum isl_dim_type type, unsigned pos);
1858 const char *isl_map_get_dim_name(
1859 __isl_keep isl_map *map,
1860 enum isl_dim_type type, unsigned pos);
1862 These functions are mostly useful to obtain the identifiers, positions
1863 or names of the parameters. Identifiers of individual dimensions are
1864 essentially only useful for printing. They are ignored by all other
1865 operations and may not be preserved across those operations.
1869 =head3 Unary Properties
1875 The following functions test whether the given set or relation
1876 contains any integer points. The ``plain'' variants do not perform
1877 any computations, but simply check if the given set or relation
1878 is already known to be empty.
1880 int isl_basic_set_plain_is_empty(__isl_keep isl_basic_set *bset);
1881 int isl_basic_set_is_empty(__isl_keep isl_basic_set *bset);
1882 int isl_set_plain_is_empty(__isl_keep isl_set *set);
1883 int isl_set_is_empty(__isl_keep isl_set *set);
1884 int isl_union_set_is_empty(__isl_keep isl_union_set *uset);
1885 int isl_basic_map_plain_is_empty(__isl_keep isl_basic_map *bmap);
1886 int isl_basic_map_is_empty(__isl_keep isl_basic_map *bmap);
1887 int isl_map_plain_is_empty(__isl_keep isl_map *map);
1888 int isl_map_is_empty(__isl_keep isl_map *map);
1889 int isl_union_map_is_empty(__isl_keep isl_union_map *umap);
1891 =item * Universality
1893 int isl_basic_set_is_universe(__isl_keep isl_basic_set *bset);
1894 int isl_basic_map_is_universe(__isl_keep isl_basic_map *bmap);
1895 int isl_set_plain_is_universe(__isl_keep isl_set *set);
1897 =item * Single-valuedness
1899 int isl_basic_map_is_single_valued(
1900 __isl_keep isl_basic_map *bmap);
1901 int isl_map_plain_is_single_valued(
1902 __isl_keep isl_map *map);
1903 int isl_map_is_single_valued(__isl_keep isl_map *map);
1904 int isl_union_map_is_single_valued(__isl_keep isl_union_map *umap);
1908 int isl_map_plain_is_injective(__isl_keep isl_map *map);
1909 int isl_map_is_injective(__isl_keep isl_map *map);
1910 int isl_union_map_plain_is_injective(
1911 __isl_keep isl_union_map *umap);
1912 int isl_union_map_is_injective(
1913 __isl_keep isl_union_map *umap);
1917 int isl_map_is_bijective(__isl_keep isl_map *map);
1918 int isl_union_map_is_bijective(__isl_keep isl_union_map *umap);
1922 __isl_give isl_val *
1923 isl_basic_map_plain_get_val_if_fixed(
1924 __isl_keep isl_basic_map *bmap,
1925 enum isl_dim_type type, unsigned pos);
1926 __isl_give isl_val *isl_set_plain_get_val_if_fixed(
1927 __isl_keep isl_set *set,
1928 enum isl_dim_type type, unsigned pos);
1929 __isl_give isl_val *isl_map_plain_get_val_if_fixed(
1930 __isl_keep isl_map *map,
1931 enum isl_dim_type type, unsigned pos);
1933 If the set or relation obviously lies on a hyperplane where the given dimension
1934 has a fixed value, then return that value.
1935 Otherwise return NaN.
1939 int isl_set_dim_residue_class_val(
1940 __isl_keep isl_set *set,
1941 int pos, __isl_give isl_val **modulo,
1942 __isl_give isl_val **residue);
1944 Check if the values of the given set dimension are equal to a fixed
1945 value modulo some integer value. If so, assign the modulo to C<*modulo>
1946 and the fixed value to C<*residue>. If the given dimension attains only
1947 a single value, then assign C<0> to C<*modulo> and the fixed value to
1949 If the dimension does not attain only a single value and if no modulo
1950 can be found then assign C<1> to C<*modulo> and C<1> to C<*residue>.
1954 To check whether a set is a parameter domain, use this function:
1956 int isl_set_is_params(__isl_keep isl_set *set);
1957 int isl_union_set_is_params(
1958 __isl_keep isl_union_set *uset);
1962 The following functions check whether the domain of the given
1963 (basic) set is a wrapped relation.
1965 int isl_basic_set_is_wrapping(
1966 __isl_keep isl_basic_set *bset);
1967 int isl_set_is_wrapping(__isl_keep isl_set *set);
1969 =item * Internal Product
1971 int isl_basic_map_can_zip(
1972 __isl_keep isl_basic_map *bmap);
1973 int isl_map_can_zip(__isl_keep isl_map *map);
1975 Check whether the product of domain and range of the given relation
1977 i.e., whether both domain and range are nested relations.
1981 int isl_basic_map_can_curry(
1982 __isl_keep isl_basic_map *bmap);
1983 int isl_map_can_curry(__isl_keep isl_map *map);
1985 Check whether the domain of the (basic) relation is a wrapped relation.
1987 int isl_basic_map_can_uncurry(
1988 __isl_keep isl_basic_map *bmap);
1989 int isl_map_can_uncurry(__isl_keep isl_map *map);
1991 Check whether the range of the (basic) relation is a wrapped relation.
1995 =head3 Binary Properties
2001 int isl_set_plain_is_equal(__isl_keep isl_set *set1,
2002 __isl_keep isl_set *set2);
2003 int isl_set_is_equal(__isl_keep isl_set *set1,
2004 __isl_keep isl_set *set2);
2005 int isl_union_set_is_equal(
2006 __isl_keep isl_union_set *uset1,
2007 __isl_keep isl_union_set *uset2);
2008 int isl_basic_map_is_equal(
2009 __isl_keep isl_basic_map *bmap1,
2010 __isl_keep isl_basic_map *bmap2);
2011 int isl_map_is_equal(__isl_keep isl_map *map1,
2012 __isl_keep isl_map *map2);
2013 int isl_map_plain_is_equal(__isl_keep isl_map *map1,
2014 __isl_keep isl_map *map2);
2015 int isl_union_map_is_equal(
2016 __isl_keep isl_union_map *umap1,
2017 __isl_keep isl_union_map *umap2);
2019 =item * Disjointness
2021 int isl_set_plain_is_disjoint(__isl_keep isl_set *set1,
2022 __isl_keep isl_set *set2);
2023 int isl_set_is_disjoint(__isl_keep isl_set *set1,
2024 __isl_keep isl_set *set2);
2025 int isl_map_is_disjoint(__isl_keep isl_map *map1,
2026 __isl_keep isl_map *map2);
2030 int isl_basic_set_is_subset(
2031 __isl_keep isl_basic_set *bset1,
2032 __isl_keep isl_basic_set *bset2);
2033 int isl_set_is_subset(__isl_keep isl_set *set1,
2034 __isl_keep isl_set *set2);
2035 int isl_set_is_strict_subset(
2036 __isl_keep isl_set *set1,
2037 __isl_keep isl_set *set2);
2038 int isl_union_set_is_subset(
2039 __isl_keep isl_union_set *uset1,
2040 __isl_keep isl_union_set *uset2);
2041 int isl_union_set_is_strict_subset(
2042 __isl_keep isl_union_set *uset1,
2043 __isl_keep isl_union_set *uset2);
2044 int isl_basic_map_is_subset(
2045 __isl_keep isl_basic_map *bmap1,
2046 __isl_keep isl_basic_map *bmap2);
2047 int isl_basic_map_is_strict_subset(
2048 __isl_keep isl_basic_map *bmap1,
2049 __isl_keep isl_basic_map *bmap2);
2050 int isl_map_is_subset(
2051 __isl_keep isl_map *map1,
2052 __isl_keep isl_map *map2);
2053 int isl_map_is_strict_subset(
2054 __isl_keep isl_map *map1,
2055 __isl_keep isl_map *map2);
2056 int isl_union_map_is_subset(
2057 __isl_keep isl_union_map *umap1,
2058 __isl_keep isl_union_map *umap2);
2059 int isl_union_map_is_strict_subset(
2060 __isl_keep isl_union_map *umap1,
2061 __isl_keep isl_union_map *umap2);
2063 Check whether the first argument is a (strict) subset of the
2068 int isl_set_plain_cmp(__isl_keep isl_set *set1,
2069 __isl_keep isl_set *set2);
2071 This function is useful for sorting C<isl_set>s.
2072 The order depends on the internal representation of the inputs.
2073 The order is fixed over different calls to the function (assuming
2074 the internal representation of the inputs has not changed), but may
2075 change over different versions of C<isl>.
2079 =head2 Unary Operations
2085 __isl_give isl_set *isl_set_complement(
2086 __isl_take isl_set *set);
2087 __isl_give isl_map *isl_map_complement(
2088 __isl_take isl_map *map);
2092 __isl_give isl_basic_map *isl_basic_map_reverse(
2093 __isl_take isl_basic_map *bmap);
2094 __isl_give isl_map *isl_map_reverse(
2095 __isl_take isl_map *map);
2096 __isl_give isl_union_map *isl_union_map_reverse(
2097 __isl_take isl_union_map *umap);
2101 __isl_give isl_basic_set *isl_basic_set_project_out(
2102 __isl_take isl_basic_set *bset,
2103 enum isl_dim_type type, unsigned first, unsigned n);
2104 __isl_give isl_basic_map *isl_basic_map_project_out(
2105 __isl_take isl_basic_map *bmap,
2106 enum isl_dim_type type, unsigned first, unsigned n);
2107 __isl_give isl_set *isl_set_project_out(__isl_take isl_set *set,
2108 enum isl_dim_type type, unsigned first, unsigned n);
2109 __isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
2110 enum isl_dim_type type, unsigned first, unsigned n);
2111 __isl_give isl_basic_set *isl_basic_set_params(
2112 __isl_take isl_basic_set *bset);
2113 __isl_give isl_basic_set *isl_basic_map_domain(
2114 __isl_take isl_basic_map *bmap);
2115 __isl_give isl_basic_set *isl_basic_map_range(
2116 __isl_take isl_basic_map *bmap);
2117 __isl_give isl_set *isl_set_params(__isl_take isl_set *set);
2118 __isl_give isl_set *isl_map_params(__isl_take isl_map *map);
2119 __isl_give isl_set *isl_map_domain(
2120 __isl_take isl_map *bmap);
2121 __isl_give isl_set *isl_map_range(
2122 __isl_take isl_map *map);
2123 __isl_give isl_set *isl_union_set_params(
2124 __isl_take isl_union_set *uset);
2125 __isl_give isl_set *isl_union_map_params(
2126 __isl_take isl_union_map *umap);
2127 __isl_give isl_union_set *isl_union_map_domain(
2128 __isl_take isl_union_map *umap);
2129 __isl_give isl_union_set *isl_union_map_range(
2130 __isl_take isl_union_map *umap);
2132 __isl_give isl_basic_map *isl_basic_map_domain_map(
2133 __isl_take isl_basic_map *bmap);
2134 __isl_give isl_basic_map *isl_basic_map_range_map(
2135 __isl_take isl_basic_map *bmap);
2136 __isl_give isl_map *isl_map_domain_map(__isl_take isl_map *map);
2137 __isl_give isl_map *isl_map_range_map(__isl_take isl_map *map);
2138 __isl_give isl_union_map *isl_union_map_domain_map(
2139 __isl_take isl_union_map *umap);
2140 __isl_give isl_union_map *isl_union_map_range_map(
2141 __isl_take isl_union_map *umap);
2143 The functions above construct a (basic, regular or union) relation
2144 that maps (a wrapped version of) the input relation to its domain or range.
2148 __isl_give isl_basic_set *isl_basic_set_eliminate(
2149 __isl_take isl_basic_set *bset,
2150 enum isl_dim_type type,
2151 unsigned first, unsigned n);
2152 __isl_give isl_set *isl_set_eliminate(
2153 __isl_take isl_set *set, enum isl_dim_type type,
2154 unsigned first, unsigned n);
2155 __isl_give isl_basic_map *isl_basic_map_eliminate(
2156 __isl_take isl_basic_map *bmap,
2157 enum isl_dim_type type,
2158 unsigned first, unsigned n);
2159 __isl_give isl_map *isl_map_eliminate(
2160 __isl_take isl_map *map, enum isl_dim_type type,
2161 unsigned first, unsigned n);
2163 Eliminate the coefficients for the given dimensions from the constraints,
2164 without removing the dimensions.
2168 __isl_give isl_basic_set *isl_basic_set_fix_si(
2169 __isl_take isl_basic_set *bset,
2170 enum isl_dim_type type, unsigned pos, int value);
2171 __isl_give isl_basic_set *isl_basic_set_fix_val(
2172 __isl_take isl_basic_set *bset,
2173 enum isl_dim_type type, unsigned pos,
2174 __isl_take isl_val *v);
2175 __isl_give isl_set *isl_set_fix_si(__isl_take isl_set *set,
2176 enum isl_dim_type type, unsigned pos, int value);
2177 __isl_give isl_set *isl_set_fix_val(
2178 __isl_take isl_set *set,
2179 enum isl_dim_type type, unsigned pos,
2180 __isl_take isl_val *v);
2181 __isl_give isl_basic_map *isl_basic_map_fix_si(
2182 __isl_take isl_basic_map *bmap,
2183 enum isl_dim_type type, unsigned pos, int value);
2184 __isl_give isl_basic_map *isl_basic_map_fix_val(
2185 __isl_take isl_basic_map *bmap,
2186 enum isl_dim_type type, unsigned pos,
2187 __isl_take isl_val *v);
2188 __isl_give isl_map *isl_map_fix_si(__isl_take isl_map *map,
2189 enum isl_dim_type type, unsigned pos, int value);
2190 __isl_give isl_map *isl_map_fix_val(
2191 __isl_take isl_map *map,
2192 enum isl_dim_type type, unsigned pos,
2193 __isl_take isl_val *v);
2195 Intersect the set or relation with the hyperplane where the given
2196 dimension has the fixed given value.
2198 __isl_give isl_basic_map *isl_basic_map_lower_bound_si(
2199 __isl_take isl_basic_map *bmap,
2200 enum isl_dim_type type, unsigned pos, int value);
2201 __isl_give isl_basic_map *isl_basic_map_upper_bound_si(
2202 __isl_take isl_basic_map *bmap,
2203 enum isl_dim_type type, unsigned pos, int value);
2204 __isl_give isl_set *isl_set_lower_bound_si(
2205 __isl_take isl_set *set,
2206 enum isl_dim_type type, unsigned pos, int value);
2207 __isl_give isl_set *isl_set_lower_bound_val(
2208 __isl_take isl_set *set,
2209 enum isl_dim_type type, unsigned pos,
2210 __isl_take isl_val *value);
2211 __isl_give isl_map *isl_map_lower_bound_si(
2212 __isl_take isl_map *map,
2213 enum isl_dim_type type, unsigned pos, int value);
2214 __isl_give isl_set *isl_set_upper_bound_si(
2215 __isl_take isl_set *set,
2216 enum isl_dim_type type, unsigned pos, int value);
2217 __isl_give isl_set *isl_set_upper_bound_val(
2218 __isl_take isl_set *set,
2219 enum isl_dim_type type, unsigned pos,
2220 __isl_take isl_val *value);
2221 __isl_give isl_map *isl_map_upper_bound_si(
2222 __isl_take isl_map *map,
2223 enum isl_dim_type type, unsigned pos, int value);
2225 Intersect the set or relation with the half-space where the given
2226 dimension has a value bounded by the fixed given integer value.
2228 __isl_give isl_set *isl_set_equate(__isl_take isl_set *set,
2229 enum isl_dim_type type1, int pos1,
2230 enum isl_dim_type type2, int pos2);
2231 __isl_give isl_basic_map *isl_basic_map_equate(
2232 __isl_take isl_basic_map *bmap,
2233 enum isl_dim_type type1, int pos1,
2234 enum isl_dim_type type2, int pos2);
2235 __isl_give isl_map *isl_map_equate(__isl_take isl_map *map,
2236 enum isl_dim_type type1, int pos1,
2237 enum isl_dim_type type2, int pos2);
2239 Intersect the set or relation with the hyperplane where the given
2240 dimensions are equal to each other.
2242 __isl_give isl_map *isl_map_oppose(__isl_take isl_map *map,
2243 enum isl_dim_type type1, int pos1,
2244 enum isl_dim_type type2, int pos2);
2246 Intersect the relation with the hyperplane where the given
2247 dimensions have opposite values.
2249 __isl_give isl_basic_map *isl_basic_map_order_ge(
2250 __isl_take isl_basic_map *bmap,
2251 enum isl_dim_type type1, int pos1,
2252 enum isl_dim_type type2, int pos2);
2253 __isl_give isl_map *isl_map_order_lt(__isl_take isl_map *map,
2254 enum isl_dim_type type1, int pos1,
2255 enum isl_dim_type type2, int pos2);
2256 __isl_give isl_basic_map *isl_basic_map_order_gt(
2257 __isl_take isl_basic_map *bmap,
2258 enum isl_dim_type type1, int pos1,
2259 enum isl_dim_type type2, int pos2);
2260 __isl_give isl_map *isl_map_order_gt(__isl_take isl_map *map,
2261 enum isl_dim_type type1, int pos1,
2262 enum isl_dim_type type2, int pos2);
2264 Intersect the relation with the half-space where the given
2265 dimensions satisfy the given ordering.
2269 __isl_give isl_map *isl_set_identity(
2270 __isl_take isl_set *set);
2271 __isl_give isl_union_map *isl_union_set_identity(
2272 __isl_take isl_union_set *uset);
2274 Construct an identity relation on the given (union) set.
2278 __isl_give isl_basic_set *isl_basic_map_deltas(
2279 __isl_take isl_basic_map *bmap);
2280 __isl_give isl_set *isl_map_deltas(__isl_take isl_map *map);
2281 __isl_give isl_union_set *isl_union_map_deltas(
2282 __isl_take isl_union_map *umap);
2284 These functions return a (basic) set containing the differences
2285 between image elements and corresponding domain elements in the input.
2287 __isl_give isl_basic_map *isl_basic_map_deltas_map(
2288 __isl_take isl_basic_map *bmap);
2289 __isl_give isl_map *isl_map_deltas_map(
2290 __isl_take isl_map *map);
2291 __isl_give isl_union_map *isl_union_map_deltas_map(
2292 __isl_take isl_union_map *umap);
2294 The functions above construct a (basic, regular or union) relation
2295 that maps (a wrapped version of) the input relation to its delta set.
2299 Simplify the representation of a set or relation by trying
2300 to combine pairs of basic sets or relations into a single
2301 basic set or relation.
2303 __isl_give isl_set *isl_set_coalesce(__isl_take isl_set *set);
2304 __isl_give isl_map *isl_map_coalesce(__isl_take isl_map *map);
2305 __isl_give isl_union_set *isl_union_set_coalesce(
2306 __isl_take isl_union_set *uset);
2307 __isl_give isl_union_map *isl_union_map_coalesce(
2308 __isl_take isl_union_map *umap);
2310 One of the methods for combining pairs of basic sets or relations
2311 can result in coefficients that are much larger than those that appear
2312 in the constraints of the input. By default, the coefficients are
2313 not allowed to grow larger, but this can be changed by unsetting
2314 the following option.
2316 int isl_options_set_coalesce_bounded_wrapping(
2317 isl_ctx *ctx, int val);
2318 int isl_options_get_coalesce_bounded_wrapping(
2321 =item * Detecting equalities
2323 __isl_give isl_basic_set *isl_basic_set_detect_equalities(
2324 __isl_take isl_basic_set *bset);
2325 __isl_give isl_basic_map *isl_basic_map_detect_equalities(
2326 __isl_take isl_basic_map *bmap);
2327 __isl_give isl_set *isl_set_detect_equalities(
2328 __isl_take isl_set *set);
2329 __isl_give isl_map *isl_map_detect_equalities(
2330 __isl_take isl_map *map);
2331 __isl_give isl_union_set *isl_union_set_detect_equalities(
2332 __isl_take isl_union_set *uset);
2333 __isl_give isl_union_map *isl_union_map_detect_equalities(
2334 __isl_take isl_union_map *umap);
2336 Simplify the representation of a set or relation by detecting implicit
2339 =item * Removing redundant constraints
2341 __isl_give isl_basic_set *isl_basic_set_remove_redundancies(
2342 __isl_take isl_basic_set *bset);
2343 __isl_give isl_set *isl_set_remove_redundancies(
2344 __isl_take isl_set *set);
2345 __isl_give isl_basic_map *isl_basic_map_remove_redundancies(
2346 __isl_take isl_basic_map *bmap);
2347 __isl_give isl_map *isl_map_remove_redundancies(
2348 __isl_take isl_map *map);
2352 __isl_give isl_basic_set *isl_set_convex_hull(
2353 __isl_take isl_set *set);
2354 __isl_give isl_basic_map *isl_map_convex_hull(
2355 __isl_take isl_map *map);
2357 If the input set or relation has any existentially quantified
2358 variables, then the result of these operations is currently undefined.
2362 __isl_give isl_basic_set *
2363 isl_set_unshifted_simple_hull(
2364 __isl_take isl_set *set);
2365 __isl_give isl_basic_map *
2366 isl_map_unshifted_simple_hull(
2367 __isl_take isl_map *map);
2368 __isl_give isl_basic_set *isl_set_simple_hull(
2369 __isl_take isl_set *set);
2370 __isl_give isl_basic_map *isl_map_simple_hull(
2371 __isl_take isl_map *map);
2372 __isl_give isl_union_map *isl_union_map_simple_hull(
2373 __isl_take isl_union_map *umap);
2375 These functions compute a single basic set or relation
2376 that contains the whole input set or relation.
2377 In particular, the output is described by translates
2378 of the constraints describing the basic sets or relations in the input.
2379 In case of C<isl_set_unshifted_simple_hull>, only the original
2380 constraints are used, without any translation.
2384 (See \autoref{s:simple hull}.)
2390 __isl_give isl_basic_set *isl_basic_set_affine_hull(
2391 __isl_take isl_basic_set *bset);
2392 __isl_give isl_basic_set *isl_set_affine_hull(
2393 __isl_take isl_set *set);
2394 __isl_give isl_union_set *isl_union_set_affine_hull(
2395 __isl_take isl_union_set *uset);
2396 __isl_give isl_basic_map *isl_basic_map_affine_hull(
2397 __isl_take isl_basic_map *bmap);
2398 __isl_give isl_basic_map *isl_map_affine_hull(
2399 __isl_take isl_map *map);
2400 __isl_give isl_union_map *isl_union_map_affine_hull(
2401 __isl_take isl_union_map *umap);
2403 In case of union sets and relations, the affine hull is computed
2406 =item * Polyhedral hull
2408 __isl_give isl_basic_set *isl_set_polyhedral_hull(
2409 __isl_take isl_set *set);
2410 __isl_give isl_basic_map *isl_map_polyhedral_hull(
2411 __isl_take isl_map *map);
2412 __isl_give isl_union_set *isl_union_set_polyhedral_hull(
2413 __isl_take isl_union_set *uset);
2414 __isl_give isl_union_map *isl_union_map_polyhedral_hull(
2415 __isl_take isl_union_map *umap);
2417 These functions compute a single basic set or relation
2418 not involving any existentially quantified variables
2419 that contains the whole input set or relation.
2420 In case of union sets and relations, the polyhedral hull is computed
2423 =item * Other approximations
2425 __isl_give isl_basic_set *
2426 isl_basic_set_drop_constraints_involving_dims(
2427 __isl_take isl_basic_set *bset,
2428 enum isl_dim_type type,
2429 unsigned first, unsigned n);
2430 __isl_give isl_basic_map *
2431 isl_basic_map_drop_constraints_involving_dims(
2432 __isl_take isl_basic_map *bmap,
2433 enum isl_dim_type type,
2434 unsigned first, unsigned n);
2435 __isl_give isl_basic_set *
2436 isl_basic_set_drop_constraints_not_involving_dims(
2437 __isl_take isl_basic_set *bset,
2438 enum isl_dim_type type,
2439 unsigned first, unsigned n);
2440 __isl_give isl_set *
2441 isl_set_drop_constraints_involving_dims(
2442 __isl_take isl_set *set,
2443 enum isl_dim_type type,
2444 unsigned first, unsigned n);
2445 __isl_give isl_map *
2446 isl_map_drop_constraints_involving_dims(
2447 __isl_take isl_map *map,
2448 enum isl_dim_type type,
2449 unsigned first, unsigned n);
2451 These functions drop any constraints (not) involving the specified dimensions.
2452 Note that the result depends on the representation of the input.
2456 __isl_give isl_basic_set *isl_basic_set_sample(
2457 __isl_take isl_basic_set *bset);
2458 __isl_give isl_basic_set *isl_set_sample(
2459 __isl_take isl_set *set);
2460 __isl_give isl_basic_map *isl_basic_map_sample(
2461 __isl_take isl_basic_map *bmap);
2462 __isl_give isl_basic_map *isl_map_sample(
2463 __isl_take isl_map *map);
2465 If the input (basic) set or relation is non-empty, then return
2466 a singleton subset of the input. Otherwise, return an empty set.
2468 =item * Optimization
2470 #include <isl/ilp.h>
2471 __isl_give isl_val *isl_basic_set_max_val(
2472 __isl_keep isl_basic_set *bset,
2473 __isl_keep isl_aff *obj);
2474 __isl_give isl_val *isl_set_min_val(
2475 __isl_keep isl_set *set,
2476 __isl_keep isl_aff *obj);
2477 __isl_give isl_val *isl_set_max_val(
2478 __isl_keep isl_set *set,
2479 __isl_keep isl_aff *obj);
2481 Compute the minimum or maximum of the integer affine expression C<obj>
2482 over the points in C<set>, returning the result in C<opt>.
2483 The result is C<NULL> in case of an error, the optimal value in case
2484 there is one, negative infinity or infinity if the problem is unbounded and
2485 NaN if the problem is empty.
2487 =item * Parametric optimization
2489 __isl_give isl_pw_aff *isl_set_dim_min(
2490 __isl_take isl_set *set, int pos);
2491 __isl_give isl_pw_aff *isl_set_dim_max(
2492 __isl_take isl_set *set, int pos);
2493 __isl_give isl_pw_aff *isl_map_dim_max(
2494 __isl_take isl_map *map, int pos);
2496 Compute the minimum or maximum of the given set or output dimension
2497 as a function of the parameters (and input dimensions), but independently
2498 of the other set or output dimensions.
2499 For lexicographic optimization, see L<"Lexicographic Optimization">.
2503 The following functions compute either the set of (rational) coefficient
2504 values of valid constraints for the given set or the set of (rational)
2505 values satisfying the constraints with coefficients from the given set.
2506 Internally, these two sets of functions perform essentially the
2507 same operations, except that the set of coefficients is assumed to
2508 be a cone, while the set of values may be any polyhedron.
2509 The current implementation is based on the Farkas lemma and
2510 Fourier-Motzkin elimination, but this may change or be made optional
2511 in future. In particular, future implementations may use different
2512 dualization algorithms or skip the elimination step.
2514 __isl_give isl_basic_set *isl_basic_set_coefficients(
2515 __isl_take isl_basic_set *bset);
2516 __isl_give isl_basic_set *isl_set_coefficients(
2517 __isl_take isl_set *set);
2518 __isl_give isl_union_set *isl_union_set_coefficients(
2519 __isl_take isl_union_set *bset);
2520 __isl_give isl_basic_set *isl_basic_set_solutions(
2521 __isl_take isl_basic_set *bset);
2522 __isl_give isl_basic_set *isl_set_solutions(
2523 __isl_take isl_set *set);
2524 __isl_give isl_union_set *isl_union_set_solutions(
2525 __isl_take isl_union_set *bset);
2529 __isl_give isl_map *isl_map_fixed_power_val(
2530 __isl_take isl_map *map,
2531 __isl_take isl_val *exp);
2532 __isl_give isl_union_map *
2533 isl_union_map_fixed_power_val(
2534 __isl_take isl_union_map *umap,
2535 __isl_take isl_val *exp);
2537 Compute the given power of C<map>, where C<exp> is assumed to be non-zero.
2538 If the exponent C<exp> is negative, then the -C<exp> th power of the inverse
2539 of C<map> is computed.
2541 __isl_give isl_map *isl_map_power(__isl_take isl_map *map,
2543 __isl_give isl_union_map *isl_union_map_power(
2544 __isl_take isl_union_map *umap, int *exact);
2546 Compute a parametric representation for all positive powers I<k> of C<map>.
2547 The result maps I<k> to a nested relation corresponding to the
2548 I<k>th power of C<map>.
2549 The result may be an overapproximation. If the result is known to be exact,
2550 then C<*exact> is set to C<1>.
2552 =item * Transitive closure
2554 __isl_give isl_map *isl_map_transitive_closure(
2555 __isl_take isl_map *map, int *exact);
2556 __isl_give isl_union_map *isl_union_map_transitive_closure(
2557 __isl_take isl_union_map *umap, int *exact);
2559 Compute the transitive closure of C<map>.
2560 The result may be an overapproximation. If the result is known to be exact,
2561 then C<*exact> is set to C<1>.
2563 =item * Reaching path lengths
2565 __isl_give isl_map *isl_map_reaching_path_lengths(
2566 __isl_take isl_map *map, int *exact);
2568 Compute a relation that maps each element in the range of C<map>
2569 to the lengths of all paths composed of edges in C<map> that
2570 end up in the given element.
2571 The result may be an overapproximation. If the result is known to be exact,
2572 then C<*exact> is set to C<1>.
2573 To compute the I<maximal> path length, the resulting relation
2574 should be postprocessed by C<isl_map_lexmax>.
2575 In particular, if the input relation is a dependence relation
2576 (mapping sources to sinks), then the maximal path length corresponds
2577 to the free schedule.
2578 Note, however, that C<isl_map_lexmax> expects the maximum to be
2579 finite, so if the path lengths are unbounded (possibly due to
2580 the overapproximation), then you will get an error message.
2584 __isl_give isl_basic_set *isl_basic_map_wrap(
2585 __isl_take isl_basic_map *bmap);
2586 __isl_give isl_set *isl_map_wrap(
2587 __isl_take isl_map *map);
2588 __isl_give isl_union_set *isl_union_map_wrap(
2589 __isl_take isl_union_map *umap);
2590 __isl_give isl_basic_map *isl_basic_set_unwrap(
2591 __isl_take isl_basic_set *bset);
2592 __isl_give isl_map *isl_set_unwrap(
2593 __isl_take isl_set *set);
2594 __isl_give isl_union_map *isl_union_set_unwrap(
2595 __isl_take isl_union_set *uset);
2599 Remove any internal structure of domain (and range) of the given
2600 set or relation. If there is any such internal structure in the input,
2601 then the name of the space is also removed.
2603 __isl_give isl_basic_set *isl_basic_set_flatten(
2604 __isl_take isl_basic_set *bset);
2605 __isl_give isl_set *isl_set_flatten(
2606 __isl_take isl_set *set);
2607 __isl_give isl_basic_map *isl_basic_map_flatten_domain(
2608 __isl_take isl_basic_map *bmap);
2609 __isl_give isl_basic_map *isl_basic_map_flatten_range(
2610 __isl_take isl_basic_map *bmap);
2611 __isl_give isl_map *isl_map_flatten_range(
2612 __isl_take isl_map *map);
2613 __isl_give isl_map *isl_map_flatten_domain(
2614 __isl_take isl_map *map);
2615 __isl_give isl_basic_map *isl_basic_map_flatten(
2616 __isl_take isl_basic_map *bmap);
2617 __isl_give isl_map *isl_map_flatten(
2618 __isl_take isl_map *map);
2620 __isl_give isl_map *isl_set_flatten_map(
2621 __isl_take isl_set *set);
2623 The function above constructs a relation
2624 that maps the input set to a flattened version of the set.
2628 Lift the input set to a space with extra dimensions corresponding
2629 to the existentially quantified variables in the input.
2630 In particular, the result lives in a wrapped map where the domain
2631 is the original space and the range corresponds to the original
2632 existentially quantified variables.
2634 __isl_give isl_basic_set *isl_basic_set_lift(
2635 __isl_take isl_basic_set *bset);
2636 __isl_give isl_set *isl_set_lift(
2637 __isl_take isl_set *set);
2638 __isl_give isl_union_set *isl_union_set_lift(
2639 __isl_take isl_union_set *uset);
2641 Given a local space that contains the existentially quantified
2642 variables of a set, a basic relation that, when applied to
2643 a basic set, has essentially the same effect as C<isl_basic_set_lift>,
2644 can be constructed using the following function.
2646 #include <isl/local_space.h>
2647 __isl_give isl_basic_map *isl_local_space_lifting(
2648 __isl_take isl_local_space *ls);
2650 =item * Internal Product
2652 __isl_give isl_basic_map *isl_basic_map_zip(
2653 __isl_take isl_basic_map *bmap);
2654 __isl_give isl_map *isl_map_zip(
2655 __isl_take isl_map *map);
2656 __isl_give isl_union_map *isl_union_map_zip(
2657 __isl_take isl_union_map *umap);
2659 Given a relation with nested relations for domain and range,
2660 interchange the range of the domain with the domain of the range.
2664 __isl_give isl_basic_map *isl_basic_map_curry(
2665 __isl_take isl_basic_map *bmap);
2666 __isl_give isl_basic_map *isl_basic_map_uncurry(
2667 __isl_take isl_basic_map *bmap);
2668 __isl_give isl_map *isl_map_curry(
2669 __isl_take isl_map *map);
2670 __isl_give isl_map *isl_map_uncurry(
2671 __isl_take isl_map *map);
2672 __isl_give isl_union_map *isl_union_map_curry(
2673 __isl_take isl_union_map *umap);
2674 __isl_give isl_union_map *isl_union_map_uncurry(
2675 __isl_take isl_union_map *umap);
2677 Given a relation with a nested relation for domain,
2678 the C<curry> functions
2679 move the range of the nested relation out of the domain
2680 and use it as the domain of a nested relation in the range,
2681 with the original range as range of this nested relation.
2682 The C<uncurry> functions perform the inverse operation.
2684 =item * Aligning parameters
2686 __isl_give isl_basic_set *isl_basic_set_align_params(
2687 __isl_take isl_basic_set *bset,
2688 __isl_take isl_space *model);
2689 __isl_give isl_set *isl_set_align_params(
2690 __isl_take isl_set *set,
2691 __isl_take isl_space *model);
2692 __isl_give isl_basic_map *isl_basic_map_align_params(
2693 __isl_take isl_basic_map *bmap,
2694 __isl_take isl_space *model);
2695 __isl_give isl_map *isl_map_align_params(
2696 __isl_take isl_map *map,
2697 __isl_take isl_space *model);
2699 Change the order of the parameters of the given set or relation
2700 such that the first parameters match those of C<model>.
2701 This may involve the introduction of extra parameters.
2702 All parameters need to be named.
2704 =item * Dimension manipulation
2706 __isl_give isl_basic_set *isl_basic_set_add_dims(
2707 __isl_take isl_basic_set *bset,
2708 enum isl_dim_type type, unsigned n);
2709 __isl_give isl_set *isl_set_add_dims(
2710 __isl_take isl_set *set,
2711 enum isl_dim_type type, unsigned n);
2712 __isl_give isl_map *isl_map_add_dims(
2713 __isl_take isl_map *map,
2714 enum isl_dim_type type, unsigned n);
2715 __isl_give isl_basic_set *isl_basic_set_insert_dims(
2716 __isl_take isl_basic_set *bset,
2717 enum isl_dim_type type, unsigned pos,
2719 __isl_give isl_basic_map *isl_basic_map_insert_dims(
2720 __isl_take isl_basic_map *bmap,
2721 enum isl_dim_type type, unsigned pos,
2723 __isl_give isl_set *isl_set_insert_dims(
2724 __isl_take isl_set *set,
2725 enum isl_dim_type type, unsigned pos, unsigned n);
2726 __isl_give isl_map *isl_map_insert_dims(
2727 __isl_take isl_map *map,
2728 enum isl_dim_type type, unsigned pos, unsigned n);
2729 __isl_give isl_basic_set *isl_basic_set_move_dims(
2730 __isl_take isl_basic_set *bset,
2731 enum isl_dim_type dst_type, unsigned dst_pos,
2732 enum isl_dim_type src_type, unsigned src_pos,
2734 __isl_give isl_basic_map *isl_basic_map_move_dims(
2735 __isl_take isl_basic_map *bmap,
2736 enum isl_dim_type dst_type, unsigned dst_pos,
2737 enum isl_dim_type src_type, unsigned src_pos,
2739 __isl_give isl_set *isl_set_move_dims(
2740 __isl_take isl_set *set,
2741 enum isl_dim_type dst_type, unsigned dst_pos,
2742 enum isl_dim_type src_type, unsigned src_pos,
2744 __isl_give isl_map *isl_map_move_dims(
2745 __isl_take isl_map *map,
2746 enum isl_dim_type dst_type, unsigned dst_pos,
2747 enum isl_dim_type src_type, unsigned src_pos,
2750 It is usually not advisable to directly change the (input or output)
2751 space of a set or a relation as this removes the name and the internal
2752 structure of the space. However, the above functions can be useful
2753 to add new parameters, assuming
2754 C<isl_set_align_params> and C<isl_map_align_params>
2759 =head2 Binary Operations
2761 The two arguments of a binary operation not only need to live
2762 in the same C<isl_ctx>, they currently also need to have
2763 the same (number of) parameters.
2765 =head3 Basic Operations
2769 =item * Intersection
2771 __isl_give isl_basic_set *isl_basic_set_intersect_params(
2772 __isl_take isl_basic_set *bset1,
2773 __isl_take isl_basic_set *bset2);
2774 __isl_give isl_basic_set *isl_basic_set_intersect(
2775 __isl_take isl_basic_set *bset1,
2776 __isl_take isl_basic_set *bset2);
2777 __isl_give isl_set *isl_set_intersect_params(
2778 __isl_take isl_set *set,
2779 __isl_take isl_set *params);
2780 __isl_give isl_set *isl_set_intersect(
2781 __isl_take isl_set *set1,
2782 __isl_take isl_set *set2);
2783 __isl_give isl_union_set *isl_union_set_intersect_params(
2784 __isl_take isl_union_set *uset,
2785 __isl_take isl_set *set);
2786 __isl_give isl_union_map *isl_union_map_intersect_params(
2787 __isl_take isl_union_map *umap,
2788 __isl_take isl_set *set);
2789 __isl_give isl_union_set *isl_union_set_intersect(
2790 __isl_take isl_union_set *uset1,
2791 __isl_take isl_union_set *uset2);
2792 __isl_give isl_basic_map *isl_basic_map_intersect_domain(
2793 __isl_take isl_basic_map *bmap,
2794 __isl_take isl_basic_set *bset);
2795 __isl_give isl_basic_map *isl_basic_map_intersect_range(
2796 __isl_take isl_basic_map *bmap,
2797 __isl_take isl_basic_set *bset);
2798 __isl_give isl_basic_map *isl_basic_map_intersect(
2799 __isl_take isl_basic_map *bmap1,
2800 __isl_take isl_basic_map *bmap2);
2801 __isl_give isl_map *isl_map_intersect_params(
2802 __isl_take isl_map *map,
2803 __isl_take isl_set *params);
2804 __isl_give isl_map *isl_map_intersect_domain(
2805 __isl_take isl_map *map,
2806 __isl_take isl_set *set);
2807 __isl_give isl_map *isl_map_intersect_range(
2808 __isl_take isl_map *map,
2809 __isl_take isl_set *set);
2810 __isl_give isl_map *isl_map_intersect(
2811 __isl_take isl_map *map1,
2812 __isl_take isl_map *map2);
2813 __isl_give isl_union_map *isl_union_map_intersect_domain(
2814 __isl_take isl_union_map *umap,
2815 __isl_take isl_union_set *uset);
2816 __isl_give isl_union_map *isl_union_map_intersect_range(
2817 __isl_take isl_union_map *umap,
2818 __isl_take isl_union_set *uset);
2819 __isl_give isl_union_map *isl_union_map_intersect(
2820 __isl_take isl_union_map *umap1,
2821 __isl_take isl_union_map *umap2);
2823 The second argument to the C<_params> functions needs to be
2824 a parametric (basic) set. For the other functions, a parametric set
2825 for either argument is only allowed if the other argument is
2826 a parametric set as well.
2830 __isl_give isl_set *isl_basic_set_union(
2831 __isl_take isl_basic_set *bset1,
2832 __isl_take isl_basic_set *bset2);
2833 __isl_give isl_map *isl_basic_map_union(
2834 __isl_take isl_basic_map *bmap1,
2835 __isl_take isl_basic_map *bmap2);
2836 __isl_give isl_set *isl_set_union(
2837 __isl_take isl_set *set1,
2838 __isl_take isl_set *set2);
2839 __isl_give isl_map *isl_map_union(
2840 __isl_take isl_map *map1,
2841 __isl_take isl_map *map2);
2842 __isl_give isl_union_set *isl_union_set_union(
2843 __isl_take isl_union_set *uset1,
2844 __isl_take isl_union_set *uset2);
2845 __isl_give isl_union_map *isl_union_map_union(
2846 __isl_take isl_union_map *umap1,
2847 __isl_take isl_union_map *umap2);
2849 =item * Set difference
2851 __isl_give isl_set *isl_set_subtract(
2852 __isl_take isl_set *set1,
2853 __isl_take isl_set *set2);
2854 __isl_give isl_map *isl_map_subtract(
2855 __isl_take isl_map *map1,
2856 __isl_take isl_map *map2);
2857 __isl_give isl_map *isl_map_subtract_domain(
2858 __isl_take isl_map *map,
2859 __isl_take isl_set *dom);
2860 __isl_give isl_map *isl_map_subtract_range(
2861 __isl_take isl_map *map,
2862 __isl_take isl_set *dom);
2863 __isl_give isl_union_set *isl_union_set_subtract(
2864 __isl_take isl_union_set *uset1,
2865 __isl_take isl_union_set *uset2);
2866 __isl_give isl_union_map *isl_union_map_subtract(
2867 __isl_take isl_union_map *umap1,
2868 __isl_take isl_union_map *umap2);
2869 __isl_give isl_union_map *isl_union_map_subtract_domain(
2870 __isl_take isl_union_map *umap,
2871 __isl_take isl_union_set *dom);
2872 __isl_give isl_union_map *isl_union_map_subtract_range(
2873 __isl_take isl_union_map *umap,
2874 __isl_take isl_union_set *dom);
2878 __isl_give isl_basic_set *isl_basic_set_apply(
2879 __isl_take isl_basic_set *bset,
2880 __isl_take isl_basic_map *bmap);
2881 __isl_give isl_set *isl_set_apply(
2882 __isl_take isl_set *set,
2883 __isl_take isl_map *map);
2884 __isl_give isl_union_set *isl_union_set_apply(
2885 __isl_take isl_union_set *uset,
2886 __isl_take isl_union_map *umap);
2887 __isl_give isl_basic_map *isl_basic_map_apply_domain(
2888 __isl_take isl_basic_map *bmap1,
2889 __isl_take isl_basic_map *bmap2);
2890 __isl_give isl_basic_map *isl_basic_map_apply_range(
2891 __isl_take isl_basic_map *bmap1,
2892 __isl_take isl_basic_map *bmap2);
2893 __isl_give isl_map *isl_map_apply_domain(
2894 __isl_take isl_map *map1,
2895 __isl_take isl_map *map2);
2896 __isl_give isl_union_map *isl_union_map_apply_domain(
2897 __isl_take isl_union_map *umap1,
2898 __isl_take isl_union_map *umap2);
2899 __isl_give isl_map *isl_map_apply_range(
2900 __isl_take isl_map *map1,
2901 __isl_take isl_map *map2);
2902 __isl_give isl_union_map *isl_union_map_apply_range(
2903 __isl_take isl_union_map *umap1,
2904 __isl_take isl_union_map *umap2);
2908 __isl_give isl_basic_set *
2909 isl_basic_set_preimage_multi_aff(
2910 __isl_take isl_basic_set *bset,
2911 __isl_take isl_multi_aff *ma);
2912 __isl_give isl_set *isl_set_preimage_multi_aff(
2913 __isl_take isl_set *set,
2914 __isl_take isl_multi_aff *ma);
2915 __isl_give isl_set *isl_set_preimage_pw_multi_aff(
2916 __isl_take isl_set *set,
2917 __isl_take isl_pw_multi_aff *pma);
2918 __isl_give isl_map *isl_map_preimage_domain_multi_aff(
2919 __isl_take isl_map *map,
2920 __isl_take isl_multi_aff *ma);
2921 __isl_give isl_union_map *
2922 isl_union_map_preimage_domain_multi_aff(
2923 __isl_take isl_union_map *umap,
2924 __isl_take isl_multi_aff *ma);
2926 These functions compute the preimage of the given set or map domain under
2927 the given function. In other words, the expression is plugged
2928 into the set description or into the domain of the map.
2929 Objects of types C<isl_multi_aff> and C<isl_pw_multi_aff> are described in
2930 L</"Piecewise Multiple Quasi Affine Expressions">.
2932 =item * Cartesian Product
2934 __isl_give isl_set *isl_set_product(
2935 __isl_take isl_set *set1,
2936 __isl_take isl_set *set2);
2937 __isl_give isl_union_set *isl_union_set_product(
2938 __isl_take isl_union_set *uset1,
2939 __isl_take isl_union_set *uset2);
2940 __isl_give isl_basic_map *isl_basic_map_domain_product(
2941 __isl_take isl_basic_map *bmap1,
2942 __isl_take isl_basic_map *bmap2);
2943 __isl_give isl_basic_map *isl_basic_map_range_product(
2944 __isl_take isl_basic_map *bmap1,
2945 __isl_take isl_basic_map *bmap2);
2946 __isl_give isl_basic_map *isl_basic_map_product(
2947 __isl_take isl_basic_map *bmap1,
2948 __isl_take isl_basic_map *bmap2);
2949 __isl_give isl_map *isl_map_domain_product(
2950 __isl_take isl_map *map1,
2951 __isl_take isl_map *map2);
2952 __isl_give isl_map *isl_map_range_product(
2953 __isl_take isl_map *map1,
2954 __isl_take isl_map *map2);
2955 __isl_give isl_union_map *isl_union_map_domain_product(
2956 __isl_take isl_union_map *umap1,
2957 __isl_take isl_union_map *umap2);
2958 __isl_give isl_union_map *isl_union_map_range_product(
2959 __isl_take isl_union_map *umap1,
2960 __isl_take isl_union_map *umap2);
2961 __isl_give isl_map *isl_map_product(
2962 __isl_take isl_map *map1,
2963 __isl_take isl_map *map2);
2964 __isl_give isl_union_map *isl_union_map_product(
2965 __isl_take isl_union_map *umap1,
2966 __isl_take isl_union_map *umap2);
2968 The above functions compute the cross product of the given
2969 sets or relations. The domains and ranges of the results
2970 are wrapped maps between domains and ranges of the inputs.
2971 To obtain a ``flat'' product, use the following functions
2974 __isl_give isl_basic_set *isl_basic_set_flat_product(
2975 __isl_take isl_basic_set *bset1,
2976 __isl_take isl_basic_set *bset2);
2977 __isl_give isl_set *isl_set_flat_product(
2978 __isl_take isl_set *set1,
2979 __isl_take isl_set *set2);
2980 __isl_give isl_basic_map *isl_basic_map_flat_range_product(
2981 __isl_take isl_basic_map *bmap1,
2982 __isl_take isl_basic_map *bmap2);
2983 __isl_give isl_map *isl_map_flat_domain_product(
2984 __isl_take isl_map *map1,
2985 __isl_take isl_map *map2);
2986 __isl_give isl_map *isl_map_flat_range_product(
2987 __isl_take isl_map *map1,
2988 __isl_take isl_map *map2);
2989 __isl_give isl_union_map *isl_union_map_flat_range_product(
2990 __isl_take isl_union_map *umap1,
2991 __isl_take isl_union_map *umap2);
2992 __isl_give isl_basic_map *isl_basic_map_flat_product(
2993 __isl_take isl_basic_map *bmap1,
2994 __isl_take isl_basic_map *bmap2);
2995 __isl_give isl_map *isl_map_flat_product(
2996 __isl_take isl_map *map1,
2997 __isl_take isl_map *map2);
2999 =item * Simplification
3001 __isl_give isl_basic_set *isl_basic_set_gist(
3002 __isl_take isl_basic_set *bset,
3003 __isl_take isl_basic_set *context);
3004 __isl_give isl_set *isl_set_gist(__isl_take isl_set *set,
3005 __isl_take isl_set *context);
3006 __isl_give isl_set *isl_set_gist_params(
3007 __isl_take isl_set *set,
3008 __isl_take isl_set *context);
3009 __isl_give isl_union_set *isl_union_set_gist(
3010 __isl_take isl_union_set *uset,
3011 __isl_take isl_union_set *context);
3012 __isl_give isl_union_set *isl_union_set_gist_params(
3013 __isl_take isl_union_set *uset,
3014 __isl_take isl_set *set);
3015 __isl_give isl_basic_map *isl_basic_map_gist(
3016 __isl_take isl_basic_map *bmap,
3017 __isl_take isl_basic_map *context);
3018 __isl_give isl_map *isl_map_gist(__isl_take isl_map *map,
3019 __isl_take isl_map *context);
3020 __isl_give isl_map *isl_map_gist_params(
3021 __isl_take isl_map *map,
3022 __isl_take isl_set *context);
3023 __isl_give isl_map *isl_map_gist_domain(
3024 __isl_take isl_map *map,
3025 __isl_take isl_set *context);
3026 __isl_give isl_map *isl_map_gist_range(
3027 __isl_take isl_map *map,
3028 __isl_take isl_set *context);
3029 __isl_give isl_union_map *isl_union_map_gist(
3030 __isl_take isl_union_map *umap,
3031 __isl_take isl_union_map *context);
3032 __isl_give isl_union_map *isl_union_map_gist_params(
3033 __isl_take isl_union_map *umap,
3034 __isl_take isl_set *set);
3035 __isl_give isl_union_map *isl_union_map_gist_domain(
3036 __isl_take isl_union_map *umap,
3037 __isl_take isl_union_set *uset);
3038 __isl_give isl_union_map *isl_union_map_gist_range(
3039 __isl_take isl_union_map *umap,
3040 __isl_take isl_union_set *uset);
3042 The gist operation returns a set or relation that has the
3043 same intersection with the context as the input set or relation.
3044 Any implicit equality in the intersection is made explicit in the result,
3045 while all inequalities that are redundant with respect to the intersection
3047 In case of union sets and relations, the gist operation is performed
3052 =head3 Lexicographic Optimization
3054 Given a (basic) set C<set> (or C<bset>) and a zero-dimensional domain C<dom>,
3055 the following functions
3056 compute a set that contains the lexicographic minimum or maximum
3057 of the elements in C<set> (or C<bset>) for those values of the parameters
3058 that satisfy C<dom>.
3059 If C<empty> is not C<NULL>, then C<*empty> is assigned a set
3060 that contains the parameter values in C<dom> for which C<set> (or C<bset>)
3062 In other words, the union of the parameter values
3063 for which the result is non-empty and of C<*empty>
3066 __isl_give isl_set *isl_basic_set_partial_lexmin(
3067 __isl_take isl_basic_set *bset,
3068 __isl_take isl_basic_set *dom,
3069 __isl_give isl_set **empty);
3070 __isl_give isl_set *isl_basic_set_partial_lexmax(
3071 __isl_take isl_basic_set *bset,
3072 __isl_take isl_basic_set *dom,
3073 __isl_give isl_set **empty);
3074 __isl_give isl_set *isl_set_partial_lexmin(
3075 __isl_take isl_set *set, __isl_take isl_set *dom,
3076 __isl_give isl_set **empty);
3077 __isl_give isl_set *isl_set_partial_lexmax(
3078 __isl_take isl_set *set, __isl_take isl_set *dom,
3079 __isl_give isl_set **empty);
3081 Given a (basic) set C<set> (or C<bset>), the following functions simply
3082 return a set containing the lexicographic minimum or maximum
3083 of the elements in C<set> (or C<bset>).
3084 In case of union sets, the optimum is computed per space.
3086 __isl_give isl_set *isl_basic_set_lexmin(
3087 __isl_take isl_basic_set *bset);
3088 __isl_give isl_set *isl_basic_set_lexmax(
3089 __isl_take isl_basic_set *bset);
3090 __isl_give isl_set *isl_set_lexmin(
3091 __isl_take isl_set *set);
3092 __isl_give isl_set *isl_set_lexmax(
3093 __isl_take isl_set *set);
3094 __isl_give isl_union_set *isl_union_set_lexmin(
3095 __isl_take isl_union_set *uset);
3096 __isl_give isl_union_set *isl_union_set_lexmax(
3097 __isl_take isl_union_set *uset);
3099 Given a (basic) relation C<map> (or C<bmap>) and a domain C<dom>,
3100 the following functions
3101 compute a relation that maps each element of C<dom>
3102 to the single lexicographic minimum or maximum
3103 of the elements that are associated to that same
3104 element in C<map> (or C<bmap>).
3105 If C<empty> is not C<NULL>, then C<*empty> is assigned a set
3106 that contains the elements in C<dom> that do not map
3107 to any elements in C<map> (or C<bmap>).
3108 In other words, the union of the domain of the result and of C<*empty>
3111 __isl_give isl_map *isl_basic_map_partial_lexmax(
3112 __isl_take isl_basic_map *bmap,
3113 __isl_take isl_basic_set *dom,
3114 __isl_give isl_set **empty);
3115 __isl_give isl_map *isl_basic_map_partial_lexmin(
3116 __isl_take isl_basic_map *bmap,
3117 __isl_take isl_basic_set *dom,
3118 __isl_give isl_set **empty);
3119 __isl_give isl_map *isl_map_partial_lexmax(
3120 __isl_take isl_map *map, __isl_take isl_set *dom,
3121 __isl_give isl_set **empty);
3122 __isl_give isl_map *isl_map_partial_lexmin(
3123 __isl_take isl_map *map, __isl_take isl_set *dom,
3124 __isl_give isl_set **empty);
3126 Given a (basic) map C<map> (or C<bmap>), the following functions simply
3127 return a map mapping each element in the domain of
3128 C<map> (or C<bmap>) to the lexicographic minimum or maximum
3129 of all elements associated to that element.
3130 In case of union relations, the optimum is computed per space.
3132 __isl_give isl_map *isl_basic_map_lexmin(
3133 __isl_take isl_basic_map *bmap);
3134 __isl_give isl_map *isl_basic_map_lexmax(
3135 __isl_take isl_basic_map *bmap);
3136 __isl_give isl_map *isl_map_lexmin(
3137 __isl_take isl_map *map);
3138 __isl_give isl_map *isl_map_lexmax(
3139 __isl_take isl_map *map);
3140 __isl_give isl_union_map *isl_union_map_lexmin(
3141 __isl_take isl_union_map *umap);
3142 __isl_give isl_union_map *isl_union_map_lexmax(
3143 __isl_take isl_union_map *umap);
3145 The following functions return their result in the form of
3146 a piecewise multi-affine expression
3147 (See L<"Piecewise Multiple Quasi Affine Expressions">),
3148 but are otherwise equivalent to the corresponding functions
3149 returning a basic set or relation.
3151 __isl_give isl_pw_multi_aff *
3152 isl_basic_map_lexmin_pw_multi_aff(
3153 __isl_take isl_basic_map *bmap);
3154 __isl_give isl_pw_multi_aff *
3155 isl_basic_set_partial_lexmin_pw_multi_aff(
3156 __isl_take isl_basic_set *bset,
3157 __isl_take isl_basic_set *dom,
3158 __isl_give isl_set **empty);
3159 __isl_give isl_pw_multi_aff *
3160 isl_basic_set_partial_lexmax_pw_multi_aff(
3161 __isl_take isl_basic_set *bset,
3162 __isl_take isl_basic_set *dom,
3163 __isl_give isl_set **empty);
3164 __isl_give isl_pw_multi_aff *
3165 isl_basic_map_partial_lexmin_pw_multi_aff(
3166 __isl_take isl_basic_map *bmap,
3167 __isl_take isl_basic_set *dom,
3168 __isl_give isl_set **empty);
3169 __isl_give isl_pw_multi_aff *
3170 isl_basic_map_partial_lexmax_pw_multi_aff(
3171 __isl_take isl_basic_map *bmap,
3172 __isl_take isl_basic_set *dom,
3173 __isl_give isl_set **empty);
3174 __isl_give isl_pw_multi_aff *isl_set_lexmin_pw_multi_aff(
3175 __isl_take isl_set *set);
3176 __isl_give isl_pw_multi_aff *isl_set_lexmax_pw_multi_aff(
3177 __isl_take isl_set *set);
3178 __isl_give isl_pw_multi_aff *isl_map_lexmin_pw_multi_aff(
3179 __isl_take isl_map *map);
3180 __isl_give isl_pw_multi_aff *isl_map_lexmax_pw_multi_aff(
3181 __isl_take isl_map *map);
3185 Lists are defined over several element types, including
3186 C<isl_val>, C<isl_id>, C<isl_aff>, C<isl_pw_aff>, C<isl_constraint>,
3187 C<isl_basic_set>, C<isl_set>, C<isl_ast_expr> and C<isl_ast_node>.
3188 Here we take lists of C<isl_set>s as an example.
3189 Lists can be created, copied, modified and freed using the following functions.
3191 #include <isl/list.h>
3192 __isl_give isl_set_list *isl_set_list_from_set(
3193 __isl_take isl_set *el);
3194 __isl_give isl_set_list *isl_set_list_alloc(
3195 isl_ctx *ctx, int n);
3196 __isl_give isl_set_list *isl_set_list_copy(
3197 __isl_keep isl_set_list *list);
3198 __isl_give isl_set_list *isl_set_list_insert(
3199 __isl_take isl_set_list *list, unsigned pos,
3200 __isl_take isl_set *el);
3201 __isl_give isl_set_list *isl_set_list_add(
3202 __isl_take isl_set_list *list,
3203 __isl_take isl_set *el);
3204 __isl_give isl_set_list *isl_set_list_drop(
3205 __isl_take isl_set_list *list,
3206 unsigned first, unsigned n);
3207 __isl_give isl_set_list *isl_set_list_set_set(
3208 __isl_take isl_set_list *list, int index,
3209 __isl_take isl_set *set);
3210 __isl_give isl_set_list *isl_set_list_concat(
3211 __isl_take isl_set_list *list1,
3212 __isl_take isl_set_list *list2);
3213 __isl_give isl_set_list *isl_set_list_sort(
3214 __isl_take isl_set_list *list,
3215 int (*cmp)(__isl_keep isl_set *a,
3216 __isl_keep isl_set *b, void *user),
3218 void *isl_set_list_free(__isl_take isl_set_list *list);
3220 C<isl_set_list_alloc> creates an empty list with a capacity for
3221 C<n> elements. C<isl_set_list_from_set> creates a list with a single
3224 Lists can be inspected using the following functions.
3226 #include <isl/list.h>
3227 isl_ctx *isl_set_list_get_ctx(__isl_keep isl_set_list *list);
3228 int isl_set_list_n_set(__isl_keep isl_set_list *list);
3229 __isl_give isl_set *isl_set_list_get_set(
3230 __isl_keep isl_set_list *list, int index);
3231 int isl_set_list_foreach(__isl_keep isl_set_list *list,
3232 int (*fn)(__isl_take isl_set *el, void *user),
3234 int isl_set_list_foreach_scc(__isl_keep isl_set_list *list,
3235 int (*follows)(__isl_keep isl_set *a,
3236 __isl_keep isl_set *b, void *user),
3238 int (*fn)(__isl_take isl_set *el, void *user),
3241 The function C<isl_set_list_foreach_scc> calls C<fn> on each of the
3242 strongly connected components of the graph with as vertices the elements
3243 of C<list> and a directed edge from vertex C<b> to vertex C<a>
3244 iff C<follows(a, b)> returns C<1>. The callbacks C<follows> and C<fn>
3245 should return C<-1> on error.
3247 Lists can be printed using
3249 #include <isl/list.h>
3250 __isl_give isl_printer *isl_printer_print_set_list(
3251 __isl_take isl_printer *p,
3252 __isl_keep isl_set_list *list);
3254 =head2 Multiple Values
3256 An C<isl_multi_val> object represents a sequence of zero or more values,
3257 living in a set space.
3259 An C<isl_multi_val> can be constructed from an C<isl_val_list>
3260 using the following function
3262 #include <isl/val.h>
3263 __isl_give isl_multi_val *isl_multi_val_from_val_list(
3264 __isl_take isl_space *space,
3265 __isl_take isl_val_list *list);
3267 The zero multiple value (with value zero for each set dimension)
3268 can be created using the following function.
3270 #include <isl/val.h>
3271 __isl_give isl_multi_val *isl_multi_val_zero(
3272 __isl_take isl_space *space);
3274 Multiple values can be copied and freed using
3276 #include <isl/val.h>
3277 __isl_give isl_multi_val *isl_multi_val_copy(
3278 __isl_keep isl_multi_val *mv);
3279 void *isl_multi_val_free(__isl_take isl_multi_val *mv);
3281 They can be inspected using
3283 #include <isl/val.h>
3284 isl_ctx *isl_multi_val_get_ctx(
3285 __isl_keep isl_multi_val *mv);
3286 unsigned isl_multi_val_dim(__isl_keep isl_multi_val *mv,
3287 enum isl_dim_type type);
3288 __isl_give isl_val *isl_multi_val_get_val(
3289 __isl_keep isl_multi_val *mv, int pos);
3290 const char *isl_multi_val_get_tuple_name(
3291 __isl_keep isl_multi_val *mv,
3292 enum isl_dim_type type);
3294 They can be modified using
3296 #include <isl/val.h>
3297 __isl_give isl_multi_val *isl_multi_val_set_val(
3298 __isl_take isl_multi_val *mv, int pos,
3299 __isl_take isl_val *val);
3300 __isl_give isl_multi_val *isl_multi_val_set_dim_name(
3301 __isl_take isl_multi_val *mv,
3302 enum isl_dim_type type, unsigned pos, const char *s);
3303 __isl_give isl_multi_val *isl_multi_val_set_tuple_name(
3304 __isl_take isl_multi_val *mv,
3305 enum isl_dim_type type, const char *s);
3306 __isl_give isl_multi_val *isl_multi_val_set_tuple_id(
3307 __isl_take isl_multi_val *mv,
3308 enum isl_dim_type type, __isl_take isl_id *id);
3310 __isl_give isl_multi_val *isl_multi_val_insert_dims(
3311 __isl_take isl_multi_val *mv,
3312 enum isl_dim_type type, unsigned first, unsigned n);
3313 __isl_give isl_multi_val *isl_multi_val_add_dims(
3314 __isl_take isl_multi_val *mv,
3315 enum isl_dim_type type, unsigned n);
3316 __isl_give isl_multi_val *isl_multi_val_drop_dims(
3317 __isl_take isl_multi_val *mv,
3318 enum isl_dim_type type, unsigned first, unsigned n);
3322 #include <isl/val.h>
3323 __isl_give isl_multi_val *isl_multi_val_align_params(
3324 __isl_take isl_multi_val *mv,
3325 __isl_take isl_space *model);
3326 __isl_give isl_multi_val *isl_multi_val_range_splice(
3327 __isl_take isl_multi_val *mv1, unsigned pos,
3328 __isl_take isl_multi_val *mv2);
3329 __isl_give isl_multi_val *isl_multi_val_range_product(
3330 __isl_take isl_multi_val *mv1,
3331 __isl_take isl_multi_val *mv2);
3332 __isl_give isl_multi_val *isl_multi_val_flat_range_product(
3333 __isl_take isl_multi_val *mv1,
3334 __isl_take isl_multi_aff *mv2);
3335 __isl_give isl_multi_val *isl_multi_val_add_val(
3336 __isl_take isl_multi_val *mv,
3337 __isl_take isl_val *v);
3338 __isl_give isl_multi_val *isl_multi_val_mod_val(
3339 __isl_take isl_multi_val *mv,
3340 __isl_take isl_val *v);
3341 __isl_give isl_multi_val *isl_multi_val_scale_val(
3342 __isl_take isl_multi_val *mv,
3343 __isl_take isl_val *v);
3344 __isl_give isl_multi_val *isl_multi_val_scale_multi_val(
3345 __isl_take isl_multi_val *mv1,
3346 __isl_take isl_multi_val *mv2);
3350 Vectors can be created, copied and freed using the following functions.
3352 #include <isl/vec.h>
3353 __isl_give isl_vec *isl_vec_alloc(isl_ctx *ctx,
3355 __isl_give isl_vec *isl_vec_copy(__isl_keep isl_vec *vec);
3356 void *isl_vec_free(__isl_take isl_vec *vec);
3358 Note that the elements of a newly created vector may have arbitrary values.
3359 The elements can be changed and inspected using the following functions.
3361 isl_ctx *isl_vec_get_ctx(__isl_keep isl_vec *vec);
3362 int isl_vec_size(__isl_keep isl_vec *vec);
3363 __isl_give isl_val *isl_vec_get_element_val(
3364 __isl_keep isl_vec *vec, int pos);
3365 __isl_give isl_vec *isl_vec_set_element_si(
3366 __isl_take isl_vec *vec, int pos, int v);
3367 __isl_give isl_vec *isl_vec_set_element_val(
3368 __isl_take isl_vec *vec, int pos,
3369 __isl_take isl_val *v);
3370 __isl_give isl_vec *isl_vec_set_si(__isl_take isl_vec *vec,
3372 __isl_give isl_vec *isl_vec_set_val(
3373 __isl_take isl_vec *vec, __isl_take isl_val *v);
3374 int isl_vec_cmp_element(__isl_keep isl_vec *vec1,
3375 __isl_keep isl_vec *vec2, int pos);
3377 C<isl_vec_get_element> will return a negative value if anything went wrong.
3378 In that case, the value of C<*v> is undefined.
3380 The following function can be used to concatenate two vectors.
3382 __isl_give isl_vec *isl_vec_concat(__isl_take isl_vec *vec1,
3383 __isl_take isl_vec *vec2);
3387 Matrices can be created, copied and freed using the following functions.
3389 #include <isl/mat.h>
3390 __isl_give isl_mat *isl_mat_alloc(isl_ctx *ctx,
3391 unsigned n_row, unsigned n_col);
3392 __isl_give isl_mat *isl_mat_copy(__isl_keep isl_mat *mat);
3393 void *isl_mat_free(__isl_take isl_mat *mat);
3395 Note that the elements of a newly created matrix may have arbitrary values.
3396 The elements can be changed and inspected using the following functions.
3398 isl_ctx *isl_mat_get_ctx(__isl_keep isl_mat *mat);
3399 int isl_mat_rows(__isl_keep isl_mat *mat);
3400 int isl_mat_cols(__isl_keep isl_mat *mat);
3401 __isl_give isl_val *isl_mat_get_element_val(
3402 __isl_keep isl_mat *mat, int row, int col);
3403 __isl_give isl_mat *isl_mat_set_element_si(__isl_take isl_mat *mat,
3404 int row, int col, int v);
3405 __isl_give isl_mat *isl_mat_set_element_val(
3406 __isl_take isl_mat *mat, int row, int col,
3407 __isl_take isl_val *v);
3409 C<isl_mat_get_element> will return a negative value if anything went wrong.
3410 In that case, the value of C<*v> is undefined.
3412 The following function can be used to compute the (right) inverse
3413 of a matrix, i.e., a matrix such that the product of the original
3414 and the inverse (in that order) is a multiple of the identity matrix.
3415 The input matrix is assumed to be of full row-rank.
3417 __isl_give isl_mat *isl_mat_right_inverse(__isl_take isl_mat *mat);
3419 The following function can be used to compute the (right) kernel
3420 (or null space) of a matrix, i.e., a matrix such that the product of
3421 the original and the kernel (in that order) is the zero matrix.
3423 __isl_give isl_mat *isl_mat_right_kernel(__isl_take isl_mat *mat);
3425 =head2 Piecewise Quasi Affine Expressions
3427 The zero quasi affine expression or the quasi affine expression
3428 that is equal to a specified dimension on a given domain can be created using
3430 __isl_give isl_aff *isl_aff_zero_on_domain(
3431 __isl_take isl_local_space *ls);
3432 __isl_give isl_pw_aff *isl_pw_aff_zero_on_domain(
3433 __isl_take isl_local_space *ls);
3434 __isl_give isl_aff *isl_aff_var_on_domain(
3435 __isl_take isl_local_space *ls,
3436 enum isl_dim_type type, unsigned pos);
3437 __isl_give isl_pw_aff *isl_pw_aff_var_on_domain(
3438 __isl_take isl_local_space *ls,
3439 enum isl_dim_type type, unsigned pos);
3441 Note that the space in which the resulting objects live is a map space
3442 with the given space as domain and a one-dimensional range.
3444 An empty piecewise quasi affine expression (one with no cells)
3445 or a piecewise quasi affine expression with a single cell can
3446 be created using the following functions.
3448 #include <isl/aff.h>
3449 __isl_give isl_pw_aff *isl_pw_aff_empty(
3450 __isl_take isl_space *space);
3451 __isl_give isl_pw_aff *isl_pw_aff_alloc(
3452 __isl_take isl_set *set, __isl_take isl_aff *aff);
3453 __isl_give isl_pw_aff *isl_pw_aff_from_aff(
3454 __isl_take isl_aff *aff);
3456 A piecewise quasi affine expression that is equal to 1 on a set
3457 and 0 outside the set can be created using the following function.
3459 #include <isl/aff.h>
3460 __isl_give isl_pw_aff *isl_set_indicator_function(
3461 __isl_take isl_set *set);
3463 Quasi affine expressions can be copied and freed using
3465 #include <isl/aff.h>
3466 __isl_give isl_aff *isl_aff_copy(__isl_keep isl_aff *aff);
3467 void *isl_aff_free(__isl_take isl_aff *aff);
3469 __isl_give isl_pw_aff *isl_pw_aff_copy(
3470 __isl_keep isl_pw_aff *pwaff);
3471 void *isl_pw_aff_free(__isl_take isl_pw_aff *pwaff);
3473 A (rational) bound on a dimension can be extracted from an C<isl_constraint>
3474 using the following function. The constraint is required to have
3475 a non-zero coefficient for the specified dimension.
3477 #include <isl/constraint.h>
3478 __isl_give isl_aff *isl_constraint_get_bound(
3479 __isl_keep isl_constraint *constraint,
3480 enum isl_dim_type type, int pos);
3482 The entire affine expression of the constraint can also be extracted
3483 using the following function.
3485 #include <isl/constraint.h>
3486 __isl_give isl_aff *isl_constraint_get_aff(
3487 __isl_keep isl_constraint *constraint);
3489 Conversely, an equality constraint equating
3490 the affine expression to zero or an inequality constraint enforcing
3491 the affine expression to be non-negative, can be constructed using
3493 __isl_give isl_constraint *isl_equality_from_aff(
3494 __isl_take isl_aff *aff);
3495 __isl_give isl_constraint *isl_inequality_from_aff(
3496 __isl_take isl_aff *aff);
3498 The expression can be inspected using
3500 #include <isl/aff.h>
3501 isl_ctx *isl_aff_get_ctx(__isl_keep isl_aff *aff);
3502 int isl_aff_dim(__isl_keep isl_aff *aff,
3503 enum isl_dim_type type);
3504 __isl_give isl_local_space *isl_aff_get_domain_local_space(
3505 __isl_keep isl_aff *aff);
3506 __isl_give isl_local_space *isl_aff_get_local_space(
3507 __isl_keep isl_aff *aff);
3508 const char *isl_aff_get_dim_name(__isl_keep isl_aff *aff,
3509 enum isl_dim_type type, unsigned pos);
3510 const char *isl_pw_aff_get_dim_name(
3511 __isl_keep isl_pw_aff *pa,
3512 enum isl_dim_type type, unsigned pos);
3513 int isl_pw_aff_has_dim_id(__isl_keep isl_pw_aff *pa,
3514 enum isl_dim_type type, unsigned pos);
3515 __isl_give isl_id *isl_pw_aff_get_dim_id(
3516 __isl_keep isl_pw_aff *pa,
3517 enum isl_dim_type type, unsigned pos);
3518 __isl_give isl_id *isl_pw_aff_get_tuple_id(
3519 __isl_keep isl_pw_aff *pa,
3520 enum isl_dim_type type);
3521 __isl_give isl_val *isl_aff_get_constant_val(
3522 __isl_keep isl_aff *aff);
3523 __isl_give isl_val *isl_aff_get_coefficient_val(
3524 __isl_keep isl_aff *aff,
3525 enum isl_dim_type type, int pos);
3526 __isl_give isl_val *isl_aff_get_denominator_val(
3527 __isl_keep isl_aff *aff);
3528 __isl_give isl_aff *isl_aff_get_div(
3529 __isl_keep isl_aff *aff, int pos);
3531 int isl_pw_aff_n_piece(__isl_keep isl_pw_aff *pwaff);
3532 int isl_pw_aff_foreach_piece(__isl_keep isl_pw_aff *pwaff,
3533 int (*fn)(__isl_take isl_set *set,
3534 __isl_take isl_aff *aff,
3535 void *user), void *user);
3537 int isl_aff_is_cst(__isl_keep isl_aff *aff);
3538 int isl_pw_aff_is_cst(__isl_keep isl_pw_aff *pwaff);
3540 int isl_aff_involves_dims(__isl_keep isl_aff *aff,
3541 enum isl_dim_type type, unsigned first, unsigned n);
3542 int isl_pw_aff_involves_dims(__isl_keep isl_pw_aff *pwaff,
3543 enum isl_dim_type type, unsigned first, unsigned n);
3545 isl_ctx *isl_pw_aff_get_ctx(__isl_keep isl_pw_aff *pwaff);
3546 unsigned isl_pw_aff_dim(__isl_keep isl_pw_aff *pwaff,
3547 enum isl_dim_type type);
3548 int isl_pw_aff_is_empty(__isl_keep isl_pw_aff *pwaff);
3550 It can be modified using
3552 #include <isl/aff.h>
3553 __isl_give isl_pw_aff *isl_pw_aff_set_tuple_id(
3554 __isl_take isl_pw_aff *pwaff,
3555 enum isl_dim_type type, __isl_take isl_id *id);
3556 __isl_give isl_aff *isl_aff_set_dim_name(
3557 __isl_take isl_aff *aff, enum isl_dim_type type,
3558 unsigned pos, const char *s);
3559 __isl_give isl_aff *isl_aff_set_dim_id(
3560 __isl_take isl_aff *aff, enum isl_dim_type type,
3561 unsigned pos, __isl_take isl_id *id);
3562 __isl_give isl_pw_aff *isl_pw_aff_set_dim_id(
3563 __isl_take isl_pw_aff *pma,
3564 enum isl_dim_type type, unsigned pos,
3565 __isl_take isl_id *id);
3566 __isl_give isl_aff *isl_aff_set_constant_si(
3567 __isl_take isl_aff *aff, int v);
3568 __isl_give isl_aff *isl_aff_set_constant_val(
3569 __isl_take isl_aff *aff, __isl_take isl_val *v);
3570 __isl_give isl_aff *isl_aff_set_coefficient_si(
3571 __isl_take isl_aff *aff,
3572 enum isl_dim_type type, int pos, int v);
3573 __isl_give isl_aff *isl_aff_set_coefficient_val(
3574 __isl_take isl_aff *aff,
3575 enum isl_dim_type type, int pos,
3576 __isl_take isl_val *v);
3578 __isl_give isl_aff *isl_aff_add_constant_si(
3579 __isl_take isl_aff *aff, int v);
3580 __isl_give isl_aff *isl_aff_add_constant_val(
3581 __isl_take isl_aff *aff, __isl_take isl_val *v);
3582 __isl_give isl_aff *isl_aff_add_constant_num_si(
3583 __isl_take isl_aff *aff, int v);
3584 __isl_give isl_aff *isl_aff_add_coefficient_si(
3585 __isl_take isl_aff *aff,
3586 enum isl_dim_type type, int pos, int v);
3587 __isl_give isl_aff *isl_aff_add_coefficient_val(
3588 __isl_take isl_aff *aff,
3589 enum isl_dim_type type, int pos,
3590 __isl_take isl_val *v);
3592 __isl_give isl_aff *isl_aff_insert_dims(
3593 __isl_take isl_aff *aff,
3594 enum isl_dim_type type, unsigned first, unsigned n);
3595 __isl_give isl_pw_aff *isl_pw_aff_insert_dims(
3596 __isl_take isl_pw_aff *pwaff,
3597 enum isl_dim_type type, unsigned first, unsigned n);
3598 __isl_give isl_aff *isl_aff_add_dims(
3599 __isl_take isl_aff *aff,
3600 enum isl_dim_type type, unsigned n);
3601 __isl_give isl_pw_aff *isl_pw_aff_add_dims(
3602 __isl_take isl_pw_aff *pwaff,
3603 enum isl_dim_type type, unsigned n);
3604 __isl_give isl_aff *isl_aff_drop_dims(
3605 __isl_take isl_aff *aff,
3606 enum isl_dim_type type, unsigned first, unsigned n);
3607 __isl_give isl_pw_aff *isl_pw_aff_drop_dims(
3608 __isl_take isl_pw_aff *pwaff,
3609 enum isl_dim_type type, unsigned first, unsigned n);
3611 Note that C<isl_aff_set_constant_si> and C<isl_aff_set_coefficient_si>
3612 set the I<numerator> of the constant or coefficient, while
3613 C<isl_aff_set_constant_val> and C<isl_aff_set_coefficient_val> set
3614 the constant or coefficient as a whole.
3615 The C<add_constant> and C<add_coefficient> functions add an integer
3616 or rational value to
3617 the possibly rational constant or coefficient.
3618 The C<add_constant_num> functions add an integer value to
3621 To check whether an affine expressions is obviously zero
3622 or obviously equal to some other affine expression, use
3624 #include <isl/aff.h>
3625 int isl_aff_plain_is_zero(__isl_keep isl_aff *aff);
3626 int isl_aff_plain_is_equal(__isl_keep isl_aff *aff1,
3627 __isl_keep isl_aff *aff2);
3628 int isl_pw_aff_plain_is_equal(
3629 __isl_keep isl_pw_aff *pwaff1,
3630 __isl_keep isl_pw_aff *pwaff2);
3634 #include <isl/aff.h>
3635 __isl_give isl_aff *isl_aff_add(__isl_take isl_aff *aff1,
3636 __isl_take isl_aff *aff2);
3637 __isl_give isl_pw_aff *isl_pw_aff_add(
3638 __isl_take isl_pw_aff *pwaff1,
3639 __isl_take isl_pw_aff *pwaff2);
3640 __isl_give isl_pw_aff *isl_pw_aff_min(
3641 __isl_take isl_pw_aff *pwaff1,
3642 __isl_take isl_pw_aff *pwaff2);
3643 __isl_give isl_pw_aff *isl_pw_aff_max(
3644 __isl_take isl_pw_aff *pwaff1,
3645 __isl_take isl_pw_aff *pwaff2);
3646 __isl_give isl_aff *isl_aff_sub(__isl_take isl_aff *aff1,
3647 __isl_take isl_aff *aff2);
3648 __isl_give isl_pw_aff *isl_pw_aff_sub(
3649 __isl_take isl_pw_aff *pwaff1,
3650 __isl_take isl_pw_aff *pwaff2);
3651 __isl_give isl_aff *isl_aff_neg(__isl_take isl_aff *aff);
3652 __isl_give isl_pw_aff *isl_pw_aff_neg(
3653 __isl_take isl_pw_aff *pwaff);
3654 __isl_give isl_aff *isl_aff_ceil(__isl_take isl_aff *aff);
3655 __isl_give isl_pw_aff *isl_pw_aff_ceil(
3656 __isl_take isl_pw_aff *pwaff);
3657 __isl_give isl_aff *isl_aff_floor(__isl_take isl_aff *aff);
3658 __isl_give isl_pw_aff *isl_pw_aff_floor(
3659 __isl_take isl_pw_aff *pwaff);
3660 __isl_give isl_aff *isl_aff_mod_val(__isl_take isl_aff *aff,
3661 __isl_take isl_val *mod);
3662 __isl_give isl_pw_aff *isl_pw_aff_mod_val(
3663 __isl_take isl_pw_aff *pa,
3664 __isl_take isl_val *mod);
3665 __isl_give isl_aff *isl_aff_scale_val(__isl_take isl_aff *aff,
3666 __isl_take isl_val *v);
3667 __isl_give isl_pw_aff *isl_pw_aff_scale_val(
3668 __isl_take isl_pw_aff *pa, __isl_take isl_val *v);
3669 __isl_give isl_aff *isl_aff_scale_down_ui(
3670 __isl_take isl_aff *aff, unsigned f);
3671 __isl_give isl_aff *isl_aff_scale_down_val(
3672 __isl_take isl_aff *aff, __isl_take isl_val *v);
3673 __isl_give isl_pw_aff *isl_pw_aff_scale_down_val(
3674 __isl_take isl_pw_aff *pa,
3675 __isl_take isl_val *f);
3677 __isl_give isl_pw_aff *isl_pw_aff_list_min(
3678 __isl_take isl_pw_aff_list *list);
3679 __isl_give isl_pw_aff *isl_pw_aff_list_max(
3680 __isl_take isl_pw_aff_list *list);
3682 __isl_give isl_pw_aff *isl_pw_aff_coalesce(
3683 __isl_take isl_pw_aff *pwqp);
3685 __isl_give isl_aff *isl_aff_align_params(
3686 __isl_take isl_aff *aff,
3687 __isl_take isl_space *model);
3688 __isl_give isl_pw_aff *isl_pw_aff_align_params(
3689 __isl_take isl_pw_aff *pwaff,
3690 __isl_take isl_space *model);
3692 __isl_give isl_aff *isl_aff_project_domain_on_params(
3693 __isl_take isl_aff *aff);
3695 __isl_give isl_aff *isl_aff_gist_params(
3696 __isl_take isl_aff *aff,
3697 __isl_take isl_set *context);
3698 __isl_give isl_aff *isl_aff_gist(__isl_take isl_aff *aff,
3699 __isl_take isl_set *context);
3700 __isl_give isl_pw_aff *isl_pw_aff_gist_params(
3701 __isl_take isl_pw_aff *pwaff,
3702 __isl_take isl_set *context);
3703 __isl_give isl_pw_aff *isl_pw_aff_gist(
3704 __isl_take isl_pw_aff *pwaff,
3705 __isl_take isl_set *context);
3707 __isl_give isl_set *isl_pw_aff_domain(
3708 __isl_take isl_pw_aff *pwaff);
3709 __isl_give isl_pw_aff *isl_pw_aff_intersect_domain(
3710 __isl_take isl_pw_aff *pa,
3711 __isl_take isl_set *set);
3712 __isl_give isl_pw_aff *isl_pw_aff_intersect_params(
3713 __isl_take isl_pw_aff *pa,
3714 __isl_take isl_set *set);
3716 __isl_give isl_aff *isl_aff_mul(__isl_take isl_aff *aff1,
3717 __isl_take isl_aff *aff2);
3718 __isl_give isl_aff *isl_aff_div(__isl_take isl_aff *aff1,
3719 __isl_take isl_aff *aff2);
3720 __isl_give isl_pw_aff *isl_pw_aff_mul(
3721 __isl_take isl_pw_aff *pwaff1,
3722 __isl_take isl_pw_aff *pwaff2);
3723 __isl_give isl_pw_aff *isl_pw_aff_div(
3724 __isl_take isl_pw_aff *pa1,
3725 __isl_take isl_pw_aff *pa2);
3726 __isl_give isl_pw_aff *isl_pw_aff_tdiv_q(
3727 __isl_take isl_pw_aff *pa1,
3728 __isl_take isl_pw_aff *pa2);
3729 __isl_give isl_pw_aff *isl_pw_aff_tdiv_r(
3730 __isl_take isl_pw_aff *pa1,
3731 __isl_take isl_pw_aff *pa2);
3733 When multiplying two affine expressions, at least one of the two needs
3734 to be a constant. Similarly, when dividing an affine expression by another,
3735 the second expression needs to be a constant.
3736 C<isl_pw_aff_tdiv_q> computes the quotient of an integer division with
3737 rounding towards zero. C<isl_pw_aff_tdiv_r> computes the corresponding
3740 #include <isl/aff.h>
3741 __isl_give isl_aff *isl_aff_pullback_multi_aff(
3742 __isl_take isl_aff *aff,
3743 __isl_take isl_multi_aff *ma);
3744 __isl_give isl_pw_aff *isl_pw_aff_pullback_multi_aff(
3745 __isl_take isl_pw_aff *pa,
3746 __isl_take isl_multi_aff *ma);
3747 __isl_give isl_pw_aff *isl_pw_aff_pullback_pw_multi_aff(
3748 __isl_take isl_pw_aff *pa,
3749 __isl_take isl_pw_multi_aff *pma);
3751 These functions precompose the input expression by the given
3752 C<isl_multi_aff> or C<isl_pw_multi_aff>. In other words,
3753 the C<isl_multi_aff> or C<isl_pw_multi_aff> is plugged
3754 into the (piecewise) affine expression.
3755 Objects of type C<isl_multi_aff> are described in
3756 L</"Piecewise Multiple Quasi Affine Expressions">.
3758 #include <isl/aff.h>
3759 __isl_give isl_basic_set *isl_aff_zero_basic_set(
3760 __isl_take isl_aff *aff);
3761 __isl_give isl_basic_set *isl_aff_neg_basic_set(
3762 __isl_take isl_aff *aff);
3763 __isl_give isl_basic_set *isl_aff_le_basic_set(
3764 __isl_take isl_aff *aff1, __isl_take isl_aff *aff2);
3765 __isl_give isl_basic_set *isl_aff_ge_basic_set(
3766 __isl_take isl_aff *aff1, __isl_take isl_aff *aff2);
3767 __isl_give isl_set *isl_pw_aff_eq_set(
3768 __isl_take isl_pw_aff *pwaff1,
3769 __isl_take isl_pw_aff *pwaff2);
3770 __isl_give isl_set *isl_pw_aff_ne_set(
3771 __isl_take isl_pw_aff *pwaff1,
3772 __isl_take isl_pw_aff *pwaff2);
3773 __isl_give isl_set *isl_pw_aff_le_set(
3774 __isl_take isl_pw_aff *pwaff1,
3775 __isl_take isl_pw_aff *pwaff2);
3776 __isl_give isl_set *isl_pw_aff_lt_set(
3777 __isl_take isl_pw_aff *pwaff1,
3778 __isl_take isl_pw_aff *pwaff2);
3779 __isl_give isl_set *isl_pw_aff_ge_set(
3780 __isl_take isl_pw_aff *pwaff1,
3781 __isl_take isl_pw_aff *pwaff2);
3782 __isl_give isl_set *isl_pw_aff_gt_set(
3783 __isl_take isl_pw_aff *pwaff1,
3784 __isl_take isl_pw_aff *pwaff2);
3786 __isl_give isl_set *isl_pw_aff_list_eq_set(
3787 __isl_take isl_pw_aff_list *list1,
3788 __isl_take isl_pw_aff_list *list2);
3789 __isl_give isl_set *isl_pw_aff_list_ne_set(
3790 __isl_take isl_pw_aff_list *list1,
3791 __isl_take isl_pw_aff_list *list2);
3792 __isl_give isl_set *isl_pw_aff_list_le_set(
3793 __isl_take isl_pw_aff_list *list1,
3794 __isl_take isl_pw_aff_list *list2);
3795 __isl_give isl_set *isl_pw_aff_list_lt_set(
3796 __isl_take isl_pw_aff_list *list1,
3797 __isl_take isl_pw_aff_list *list2);
3798 __isl_give isl_set *isl_pw_aff_list_ge_set(
3799 __isl_take isl_pw_aff_list *list1,
3800 __isl_take isl_pw_aff_list *list2);
3801 __isl_give isl_set *isl_pw_aff_list_gt_set(
3802 __isl_take isl_pw_aff_list *list1,
3803 __isl_take isl_pw_aff_list *list2);
3805 The function C<isl_aff_neg_basic_set> returns a basic set
3806 containing those elements in the domain space
3807 of C<aff> where C<aff> is negative.
3808 The function C<isl_aff_ge_basic_set> returns a basic set
3809 containing those elements in the shared space
3810 of C<aff1> and C<aff2> where C<aff1> is greater than or equal to C<aff2>.
3811 The function C<isl_pw_aff_ge_set> returns a set
3812 containing those elements in the shared domain
3813 of C<pwaff1> and C<pwaff2> where C<pwaff1> is greater than or equal to C<pwaff2>.
3814 The functions operating on C<isl_pw_aff_list> apply the corresponding
3815 C<isl_pw_aff> function to each pair of elements in the two lists.
3817 #include <isl/aff.h>
3818 __isl_give isl_set *isl_pw_aff_nonneg_set(
3819 __isl_take isl_pw_aff *pwaff);
3820 __isl_give isl_set *isl_pw_aff_zero_set(
3821 __isl_take isl_pw_aff *pwaff);
3822 __isl_give isl_set *isl_pw_aff_non_zero_set(
3823 __isl_take isl_pw_aff *pwaff);
3825 The function C<isl_pw_aff_nonneg_set> returns a set
3826 containing those elements in the domain
3827 of C<pwaff> where C<pwaff> is non-negative.
3829 #include <isl/aff.h>
3830 __isl_give isl_pw_aff *isl_pw_aff_cond(
3831 __isl_take isl_pw_aff *cond,
3832 __isl_take isl_pw_aff *pwaff_true,
3833 __isl_take isl_pw_aff *pwaff_false);
3835 The function C<isl_pw_aff_cond> performs a conditional operator
3836 and returns an expression that is equal to C<pwaff_true>
3837 for elements where C<cond> is non-zero and equal to C<pwaff_false> for elements
3838 where C<cond> is zero.
3840 #include <isl/aff.h>
3841 __isl_give isl_pw_aff *isl_pw_aff_union_min(
3842 __isl_take isl_pw_aff *pwaff1,
3843 __isl_take isl_pw_aff *pwaff2);
3844 __isl_give isl_pw_aff *isl_pw_aff_union_max(
3845 __isl_take isl_pw_aff *pwaff1,
3846 __isl_take isl_pw_aff *pwaff2);
3847 __isl_give isl_pw_aff *isl_pw_aff_union_add(
3848 __isl_take isl_pw_aff *pwaff1,
3849 __isl_take isl_pw_aff *pwaff2);
3851 The function C<isl_pw_aff_union_max> computes a piecewise quasi-affine
3852 expression with a domain that is the union of those of C<pwaff1> and
3853 C<pwaff2> and such that on each cell, the quasi-affine expression is
3854 the maximum of those of C<pwaff1> and C<pwaff2>. If only one of
3855 C<pwaff1> or C<pwaff2> is defined on a given cell, then the
3856 associated expression is the defined one.
3858 An expression can be read from input using
3860 #include <isl/aff.h>
3861 __isl_give isl_aff *isl_aff_read_from_str(
3862 isl_ctx *ctx, const char *str);
3863 __isl_give isl_pw_aff *isl_pw_aff_read_from_str(
3864 isl_ctx *ctx, const char *str);
3866 An expression can be printed using
3868 #include <isl/aff.h>
3869 __isl_give isl_printer *isl_printer_print_aff(
3870 __isl_take isl_printer *p, __isl_keep isl_aff *aff);
3872 __isl_give isl_printer *isl_printer_print_pw_aff(
3873 __isl_take isl_printer *p,
3874 __isl_keep isl_pw_aff *pwaff);
3876 =head2 Piecewise Multiple Quasi Affine Expressions
3878 An C<isl_multi_aff> object represents a sequence of
3879 zero or more affine expressions, all defined on the same domain space.
3880 Similarly, an C<isl_multi_pw_aff> object represents a sequence of
3881 zero or more piecewise affine expressions.
3883 An C<isl_multi_aff> can be constructed from a single
3884 C<isl_aff> or an C<isl_aff_list> using the
3885 following functions. Similarly for C<isl_multi_pw_aff>.
3887 #include <isl/aff.h>
3888 __isl_give isl_multi_aff *isl_multi_aff_from_aff(
3889 __isl_take isl_aff *aff);
3890 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_pw_aff(
3891 __isl_take isl_pw_aff *pa);
3892 __isl_give isl_multi_aff *isl_multi_aff_from_aff_list(
3893 __isl_take isl_space *space,
3894 __isl_take isl_aff_list *list);
3896 An empty piecewise multiple quasi affine expression (one with no cells),
3897 the zero piecewise multiple quasi affine expression (with value zero
3898 for each output dimension),
3899 a piecewise multiple quasi affine expression with a single cell (with
3900 either a universe or a specified domain) or
3901 a zero-dimensional piecewise multiple quasi affine expression
3903 can be created using the following functions.
3905 #include <isl/aff.h>
3906 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_empty(
3907 __isl_take isl_space *space);
3908 __isl_give isl_multi_aff *isl_multi_aff_zero(
3909 __isl_take isl_space *space);
3910 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_zero(
3911 __isl_take isl_space *space);
3912 __isl_give isl_multi_aff *isl_multi_aff_identity(
3913 __isl_take isl_space *space);
3914 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_identity(
3915 __isl_take isl_space *space);
3916 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_identity(
3917 __isl_take isl_space *space);
3918 __isl_give isl_pw_multi_aff *
3919 isl_pw_multi_aff_from_multi_aff(
3920 __isl_take isl_multi_aff *ma);
3921 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_alloc(
3922 __isl_take isl_set *set,
3923 __isl_take isl_multi_aff *maff);
3924 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_domain(
3925 __isl_take isl_set *set);
3927 __isl_give isl_union_pw_multi_aff *
3928 isl_union_pw_multi_aff_empty(
3929 __isl_take isl_space *space);
3930 __isl_give isl_union_pw_multi_aff *
3931 isl_union_pw_multi_aff_add_pw_multi_aff(
3932 __isl_take isl_union_pw_multi_aff *upma,
3933 __isl_take isl_pw_multi_aff *pma);
3934 __isl_give isl_union_pw_multi_aff *
3935 isl_union_pw_multi_aff_from_domain(
3936 __isl_take isl_union_set *uset);
3938 A piecewise multiple quasi affine expression can also be initialized
3939 from an C<isl_set> or C<isl_map>, provided the C<isl_set> is a singleton
3940 and the C<isl_map> is single-valued.
3941 In case of a conversion from an C<isl_union_set> or an C<isl_union_map>
3942 to an C<isl_union_pw_multi_aff>, these properties need to hold in each space.
3944 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_set(
3945 __isl_take isl_set *set);
3946 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_map(
3947 __isl_take isl_map *map);
3949 __isl_give isl_union_pw_multi_aff *
3950 isl_union_pw_multi_aff_from_union_set(
3951 __isl_take isl_union_set *uset);
3952 __isl_give isl_union_pw_multi_aff *
3953 isl_union_pw_multi_aff_from_union_map(
3954 __isl_take isl_union_map *umap);
3956 Multiple quasi affine expressions can be copied and freed using
3958 #include <isl/aff.h>
3959 __isl_give isl_multi_aff *isl_multi_aff_copy(
3960 __isl_keep isl_multi_aff *maff);
3961 void *isl_multi_aff_free(__isl_take isl_multi_aff *maff);
3963 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_copy(
3964 __isl_keep isl_pw_multi_aff *pma);
3965 void *isl_pw_multi_aff_free(
3966 __isl_take isl_pw_multi_aff *pma);
3968 __isl_give isl_union_pw_multi_aff *
3969 isl_union_pw_multi_aff_copy(
3970 __isl_keep isl_union_pw_multi_aff *upma);
3971 void *isl_union_pw_multi_aff_free(
3972 __isl_take isl_union_pw_multi_aff *upma);
3974 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_copy(
3975 __isl_keep isl_multi_pw_aff *mpa);
3976 void *isl_multi_pw_aff_free(
3977 __isl_take isl_multi_pw_aff *mpa);
3979 The expression can be inspected using
3981 #include <isl/aff.h>
3982 isl_ctx *isl_multi_aff_get_ctx(
3983 __isl_keep isl_multi_aff *maff);
3984 isl_ctx *isl_pw_multi_aff_get_ctx(
3985 __isl_keep isl_pw_multi_aff *pma);
3986 isl_ctx *isl_union_pw_multi_aff_get_ctx(
3987 __isl_keep isl_union_pw_multi_aff *upma);
3988 isl_ctx *isl_multi_pw_aff_get_ctx(
3989 __isl_keep isl_multi_pw_aff *mpa);
3990 unsigned isl_multi_aff_dim(__isl_keep isl_multi_aff *maff,
3991 enum isl_dim_type type);
3992 unsigned isl_pw_multi_aff_dim(
3993 __isl_keep isl_pw_multi_aff *pma,
3994 enum isl_dim_type type);
3995 unsigned isl_multi_pw_aff_dim(
3996 __isl_keep isl_multi_pw_aff *mpa,
3997 enum isl_dim_type type);
3998 __isl_give isl_aff *isl_multi_aff_get_aff(
3999 __isl_keep isl_multi_aff *multi, int pos);
4000 __isl_give isl_pw_aff *isl_pw_multi_aff_get_pw_aff(
4001 __isl_keep isl_pw_multi_aff *pma, int pos);
4002 __isl_give isl_pw_aff *isl_multi_pw_aff_get_pw_aff(
4003 __isl_keep isl_multi_pw_aff *mpa, int pos);
4004 const char *isl_pw_multi_aff_get_dim_name(
4005 __isl_keep isl_pw_multi_aff *pma,
4006 enum isl_dim_type type, unsigned pos);
4007 __isl_give isl_id *isl_pw_multi_aff_get_dim_id(
4008 __isl_keep isl_pw_multi_aff *pma,
4009 enum isl_dim_type type, unsigned pos);
4010 const char *isl_multi_aff_get_tuple_name(
4011 __isl_keep isl_multi_aff *multi,
4012 enum isl_dim_type type);
4013 int isl_pw_multi_aff_has_tuple_name(
4014 __isl_keep isl_pw_multi_aff *pma,
4015 enum isl_dim_type type);
4016 const char *isl_pw_multi_aff_get_tuple_name(
4017 __isl_keep isl_pw_multi_aff *pma,
4018 enum isl_dim_type type);
4019 int isl_pw_multi_aff_has_tuple_id(
4020 __isl_keep isl_pw_multi_aff *pma,
4021 enum isl_dim_type type);
4022 __isl_give isl_id *isl_pw_multi_aff_get_tuple_id(
4023 __isl_keep isl_pw_multi_aff *pma,
4024 enum isl_dim_type type);
4026 int isl_pw_multi_aff_foreach_piece(
4027 __isl_keep isl_pw_multi_aff *pma,
4028 int (*fn)(__isl_take isl_set *set,
4029 __isl_take isl_multi_aff *maff,
4030 void *user), void *user);
4032 int isl_union_pw_multi_aff_foreach_pw_multi_aff(
4033 __isl_keep isl_union_pw_multi_aff *upma,
4034 int (*fn)(__isl_take isl_pw_multi_aff *pma,
4035 void *user), void *user);
4037 It can be modified using
4039 #include <isl/aff.h>
4040 __isl_give isl_multi_aff *isl_multi_aff_set_aff(
4041 __isl_take isl_multi_aff *multi, int pos,
4042 __isl_take isl_aff *aff);
4043 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_pw_aff(
4044 __isl_take isl_pw_multi_aff *pma, unsigned pos,
4045 __isl_take isl_pw_aff *pa);
4046 __isl_give isl_multi_aff *isl_multi_aff_set_dim_name(
4047 __isl_take isl_multi_aff *maff,
4048 enum isl_dim_type type, unsigned pos, const char *s);
4049 __isl_give isl_multi_aff *isl_multi_aff_set_tuple_name(
4050 __isl_take isl_multi_aff *maff,
4051 enum isl_dim_type type, const char *s);
4052 __isl_give isl_multi_aff *isl_multi_aff_set_tuple_id(
4053 __isl_take isl_multi_aff *maff,
4054 enum isl_dim_type type, __isl_take isl_id *id);
4055 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_tuple_id(
4056 __isl_take isl_pw_multi_aff *pma,
4057 enum isl_dim_type type, __isl_take isl_id *id);
4059 __isl_give isl_multi_pw_aff *
4060 isl_multi_pw_aff_set_dim_name(
4061 __isl_take isl_multi_pw_aff *mpa,
4062 enum isl_dim_type type, unsigned pos, const char *s);
4063 __isl_give isl_multi_pw_aff *
4064 isl_multi_pw_aff_set_tuple_name(
4065 __isl_take isl_multi_pw_aff *mpa,
4066 enum isl_dim_type type, const char *s);
4068 __isl_give isl_multi_aff *isl_multi_aff_insert_dims(
4069 __isl_take isl_multi_aff *ma,
4070 enum isl_dim_type type, unsigned first, unsigned n);
4071 __isl_give isl_multi_aff *isl_multi_aff_add_dims(
4072 __isl_take isl_multi_aff *ma,
4073 enum isl_dim_type type, unsigned n);
4074 __isl_give isl_multi_aff *isl_multi_aff_drop_dims(
4075 __isl_take isl_multi_aff *maff,
4076 enum isl_dim_type type, unsigned first, unsigned n);
4077 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_drop_dims(
4078 __isl_take isl_pw_multi_aff *pma,
4079 enum isl_dim_type type, unsigned first, unsigned n);
4081 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_insert_dims(
4082 __isl_take isl_multi_pw_aff *mpa,
4083 enum isl_dim_type type, unsigned first, unsigned n);
4084 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_add_dims(
4085 __isl_take isl_multi_pw_aff *mpa,
4086 enum isl_dim_type type, unsigned n);
4088 To check whether two multiple affine expressions are
4089 obviously equal to each other, use
4091 int isl_multi_aff_plain_is_equal(__isl_keep isl_multi_aff *maff1,
4092 __isl_keep isl_multi_aff *maff2);
4093 int isl_pw_multi_aff_plain_is_equal(
4094 __isl_keep isl_pw_multi_aff *pma1,
4095 __isl_keep isl_pw_multi_aff *pma2);
4099 #include <isl/aff.h>
4100 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmin(
4101 __isl_take isl_pw_multi_aff *pma1,
4102 __isl_take isl_pw_multi_aff *pma2);
4103 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmax(
4104 __isl_take isl_pw_multi_aff *pma1,
4105 __isl_take isl_pw_multi_aff *pma2);
4106 __isl_give isl_multi_aff *isl_multi_aff_add(
4107 __isl_take isl_multi_aff *maff1,
4108 __isl_take isl_multi_aff *maff2);
4109 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_add(
4110 __isl_take isl_pw_multi_aff *pma1,
4111 __isl_take isl_pw_multi_aff *pma2);
4112 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_add(
4113 __isl_take isl_union_pw_multi_aff *upma1,
4114 __isl_take isl_union_pw_multi_aff *upma2);
4115 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_add(
4116 __isl_take isl_pw_multi_aff *pma1,
4117 __isl_take isl_pw_multi_aff *pma2);
4118 __isl_give isl_multi_aff *isl_multi_aff_sub(
4119 __isl_take isl_multi_aff *ma1,
4120 __isl_take isl_multi_aff *ma2);
4121 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_sub(
4122 __isl_take isl_pw_multi_aff *pma1,
4123 __isl_take isl_pw_multi_aff *pma2);
4124 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_sub(
4125 __isl_take isl_union_pw_multi_aff *upma1,
4126 __isl_take isl_union_pw_multi_aff *upma2);
4128 C<isl_multi_aff_sub> subtracts the second argument from the first.
4130 __isl_give isl_multi_aff *isl_multi_aff_scale_val(
4131 __isl_take isl_multi_aff *ma,
4132 __isl_take isl_val *v);
4133 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_val(
4134 __isl_take isl_pw_multi_aff *pma,
4135 __isl_take isl_val *v);
4136 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_scale_val(
4137 __isl_take isl_multi_pw_aff *mpa,
4138 __isl_take isl_val *v);
4139 __isl_give isl_multi_aff *isl_multi_aff_scale_multi_val(
4140 __isl_take isl_multi_aff *ma,
4141 __isl_take isl_multi_val *mv);
4142 __isl_give isl_pw_multi_aff *
4143 isl_pw_multi_aff_scale_multi_val(
4144 __isl_take isl_pw_multi_aff *pma,
4145 __isl_take isl_multi_val *mv);
4146 __isl_give isl_multi_pw_aff *
4147 isl_multi_pw_aff_scale_multi_val(
4148 __isl_take isl_multi_pw_aff *mpa,
4149 __isl_take isl_multi_val *mv);
4150 __isl_give isl_union_pw_multi_aff *
4151 isl_union_pw_multi_aff_scale_multi_val(
4152 __isl_take isl_union_pw_multi_aff *upma,
4153 __isl_take isl_multi_val *mv);
4155 C<isl_multi_aff_scale_multi_val> scales the elements of C<ma>
4156 by the corresponding elements of C<mv>.
4158 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_params(
4159 __isl_take isl_pw_multi_aff *pma,
4160 __isl_take isl_set *set);
4161 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_domain(
4162 __isl_take isl_pw_multi_aff *pma,
4163 __isl_take isl_set *set);
4164 __isl_give isl_union_pw_multi_aff *
4165 isl_union_pw_multi_aff_intersect_domain(
4166 __isl_take isl_union_pw_multi_aff *upma,
4167 __isl_take isl_union_set *uset);
4168 __isl_give isl_multi_aff *isl_multi_aff_lift(
4169 __isl_take isl_multi_aff *maff,
4170 __isl_give isl_local_space **ls);
4171 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_coalesce(
4172 __isl_take isl_pw_multi_aff *pma);
4173 __isl_give isl_multi_aff *isl_multi_aff_align_params(
4174 __isl_take isl_multi_aff *multi,
4175 __isl_take isl_space *model);
4176 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_align_params(
4177 __isl_take isl_pw_multi_aff *pma,
4178 __isl_take isl_space *model);
4179 __isl_give isl_pw_multi_aff *
4180 isl_pw_multi_aff_project_domain_on_params(
4181 __isl_take isl_pw_multi_aff *pma);
4182 __isl_give isl_multi_aff *isl_multi_aff_gist_params(
4183 __isl_take isl_multi_aff *maff,
4184 __isl_take isl_set *context);
4185 __isl_give isl_multi_aff *isl_multi_aff_gist(
4186 __isl_take isl_multi_aff *maff,
4187 __isl_take isl_set *context);
4188 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist_params(
4189 __isl_take isl_pw_multi_aff *pma,
4190 __isl_take isl_set *set);
4191 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist(
4192 __isl_take isl_pw_multi_aff *pma,
4193 __isl_take isl_set *set);
4194 __isl_give isl_set *isl_pw_multi_aff_domain(
4195 __isl_take isl_pw_multi_aff *pma);
4196 __isl_give isl_union_set *isl_union_pw_multi_aff_domain(
4197 __isl_take isl_union_pw_multi_aff *upma);
4198 __isl_give isl_multi_aff *isl_multi_aff_range_splice(
4199 __isl_take isl_multi_aff *ma1, unsigned pos,
4200 __isl_take isl_multi_aff *ma2);
4201 __isl_give isl_multi_aff *isl_multi_aff_splice(
4202 __isl_take isl_multi_aff *ma1,
4203 unsigned in_pos, unsigned out_pos,
4204 __isl_take isl_multi_aff *ma2);
4205 __isl_give isl_multi_aff *isl_multi_aff_range_product(
4206 __isl_take isl_multi_aff *ma1,
4207 __isl_take isl_multi_aff *ma2);
4208 __isl_give isl_multi_aff *isl_multi_aff_flat_range_product(
4209 __isl_take isl_multi_aff *ma1,
4210 __isl_take isl_multi_aff *ma2);
4211 __isl_give isl_multi_aff *isl_multi_aff_product(
4212 __isl_take isl_multi_aff *ma1,
4213 __isl_take isl_multi_aff *ma2);
4214 __isl_give isl_pw_multi_aff *
4215 isl_pw_multi_aff_range_product(
4216 __isl_take isl_pw_multi_aff *pma1,
4217 __isl_take isl_pw_multi_aff *pma2);
4218 __isl_give isl_pw_multi_aff *
4219 isl_pw_multi_aff_flat_range_product(
4220 __isl_take isl_pw_multi_aff *pma1,
4221 __isl_take isl_pw_multi_aff *pma2);
4222 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_product(
4223 __isl_take isl_pw_multi_aff *pma1,
4224 __isl_take isl_pw_multi_aff *pma2);
4225 __isl_give isl_union_pw_multi_aff *
4226 isl_union_pw_multi_aff_flat_range_product(
4227 __isl_take isl_union_pw_multi_aff *upma1,
4228 __isl_take isl_union_pw_multi_aff *upma2);
4229 __isl_give isl_multi_pw_aff *
4230 isl_multi_pw_aff_range_splice(
4231 __isl_take isl_multi_pw_aff *mpa1, unsigned pos,
4232 __isl_take isl_multi_pw_aff *mpa2);
4233 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_splice(
4234 __isl_take isl_multi_pw_aff *mpa1,
4235 unsigned in_pos, unsigned out_pos,
4236 __isl_take isl_multi_pw_aff *mpa2);
4237 __isl_give isl_multi_pw_aff *
4238 isl_multi_pw_aff_range_product(
4239 __isl_take isl_multi_pw_aff *mpa1,
4240 __isl_take isl_multi_pw_aff *mpa2);
4241 __isl_give isl_multi_pw_aff *
4242 isl_multi_pw_aff_flat_range_product(
4243 __isl_take isl_multi_pw_aff *mpa1,
4244 __isl_take isl_multi_pw_aff *mpa2);
4246 If the C<ls> argument of C<isl_multi_aff_lift> is not C<NULL>,
4247 then it is assigned the local space that lies at the basis of
4248 the lifting applied.
4250 #include <isl/aff.h>
4251 __isl_give isl_multi_aff *isl_multi_aff_pullback_multi_aff(
4252 __isl_take isl_multi_aff *ma1,
4253 __isl_take isl_multi_aff *ma2);
4254 __isl_give isl_pw_multi_aff *
4255 isl_pw_multi_aff_pullback_multi_aff(
4256 __isl_take isl_pw_multi_aff *pma,
4257 __isl_take isl_multi_aff *ma);
4258 __isl_give isl_pw_multi_aff *
4259 isl_pw_multi_aff_pullback_pw_multi_aff(
4260 __isl_take isl_pw_multi_aff *pma1,
4261 __isl_take isl_pw_multi_aff *pma2);
4263 The function C<isl_multi_aff_pullback_multi_aff> precomposes C<ma1> by C<ma2>.
4264 In other words, C<ma2> is plugged
4267 __isl_give isl_set *isl_multi_aff_lex_le_set(
4268 __isl_take isl_multi_aff *ma1,
4269 __isl_take isl_multi_aff *ma2);
4270 __isl_give isl_set *isl_multi_aff_lex_ge_set(
4271 __isl_take isl_multi_aff *ma1,
4272 __isl_take isl_multi_aff *ma2);
4274 The function C<isl_multi_aff_lex_le_set> returns a set
4275 containing those elements in the shared domain space
4276 where C<ma1> is lexicographically smaller than or
4279 An expression can be read from input using
4281 #include <isl/aff.h>
4282 __isl_give isl_multi_aff *isl_multi_aff_read_from_str(
4283 isl_ctx *ctx, const char *str);
4284 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_read_from_str(
4285 isl_ctx *ctx, const char *str);
4286 __isl_give isl_union_pw_multi_aff *
4287 isl_union_pw_multi_aff_read_from_str(
4288 isl_ctx *ctx, const char *str);
4290 An expression can be printed using
4292 #include <isl/aff.h>
4293 __isl_give isl_printer *isl_printer_print_multi_aff(
4294 __isl_take isl_printer *p,
4295 __isl_keep isl_multi_aff *maff);
4296 __isl_give isl_printer *isl_printer_print_pw_multi_aff(
4297 __isl_take isl_printer *p,
4298 __isl_keep isl_pw_multi_aff *pma);
4299 __isl_give isl_printer *isl_printer_print_union_pw_multi_aff(
4300 __isl_take isl_printer *p,
4301 __isl_keep isl_union_pw_multi_aff *upma);
4302 __isl_give isl_printer *isl_printer_print_multi_pw_aff(
4303 __isl_take isl_printer *p,
4304 __isl_keep isl_multi_pw_aff *mpa);
4308 Points are elements of a set. They can be used to construct
4309 simple sets (boxes) or they can be used to represent the
4310 individual elements of a set.
4311 The zero point (the origin) can be created using
4313 __isl_give isl_point *isl_point_zero(__isl_take isl_space *space);
4315 The coordinates of a point can be inspected, set and changed
4318 __isl_give isl_val *isl_point_get_coordinate_val(
4319 __isl_keep isl_point *pnt,
4320 enum isl_dim_type type, int pos);
4321 __isl_give isl_point *isl_point_set_coordinate_val(
4322 __isl_take isl_point *pnt,
4323 enum isl_dim_type type, int pos,
4324 __isl_take isl_val *v);
4326 __isl_give isl_point *isl_point_add_ui(
4327 __isl_take isl_point *pnt,
4328 enum isl_dim_type type, int pos, unsigned val);
4329 __isl_give isl_point *isl_point_sub_ui(
4330 __isl_take isl_point *pnt,
4331 enum isl_dim_type type, int pos, unsigned val);
4333 Other properties can be obtained using
4335 isl_ctx *isl_point_get_ctx(__isl_keep isl_point *pnt);
4337 Points can be copied or freed using
4339 __isl_give isl_point *isl_point_copy(
4340 __isl_keep isl_point *pnt);
4341 void isl_point_free(__isl_take isl_point *pnt);
4343 A singleton set can be created from a point using
4345 __isl_give isl_basic_set *isl_basic_set_from_point(
4346 __isl_take isl_point *pnt);
4347 __isl_give isl_set *isl_set_from_point(
4348 __isl_take isl_point *pnt);
4350 and a box can be created from two opposite extremal points using
4352 __isl_give isl_basic_set *isl_basic_set_box_from_points(
4353 __isl_take isl_point *pnt1,
4354 __isl_take isl_point *pnt2);
4355 __isl_give isl_set *isl_set_box_from_points(
4356 __isl_take isl_point *pnt1,
4357 __isl_take isl_point *pnt2);
4359 All elements of a B<bounded> (union) set can be enumerated using
4360 the following functions.
4362 int isl_set_foreach_point(__isl_keep isl_set *set,
4363 int (*fn)(__isl_take isl_point *pnt, void *user),
4365 int isl_union_set_foreach_point(__isl_keep isl_union_set *uset,
4366 int (*fn)(__isl_take isl_point *pnt, void *user),
4369 The function C<fn> is called for each integer point in
4370 C<set> with as second argument the last argument of
4371 the C<isl_set_foreach_point> call. The function C<fn>
4372 should return C<0> on success and C<-1> on failure.
4373 In the latter case, C<isl_set_foreach_point> will stop
4374 enumerating and return C<-1> as well.
4375 If the enumeration is performed successfully and to completion,
4376 then C<isl_set_foreach_point> returns C<0>.
4378 To obtain a single point of a (basic) set, use
4380 __isl_give isl_point *isl_basic_set_sample_point(
4381 __isl_take isl_basic_set *bset);
4382 __isl_give isl_point *isl_set_sample_point(
4383 __isl_take isl_set *set);
4385 If C<set> does not contain any (integer) points, then the
4386 resulting point will be ``void'', a property that can be
4389 int isl_point_is_void(__isl_keep isl_point *pnt);
4391 =head2 Piecewise Quasipolynomials
4393 A piecewise quasipolynomial is a particular kind of function that maps
4394 a parametric point to a rational value.
4395 More specifically, a quasipolynomial is a polynomial expression in greatest
4396 integer parts of affine expressions of parameters and variables.
4397 A piecewise quasipolynomial is a subdivision of a given parametric
4398 domain into disjoint cells with a quasipolynomial associated to
4399 each cell. The value of the piecewise quasipolynomial at a given
4400 point is the value of the quasipolynomial associated to the cell
4401 that contains the point. Outside of the union of cells,
4402 the value is assumed to be zero.
4403 For example, the piecewise quasipolynomial
4405 [n] -> { [x] -> ((1 + n) - x) : x <= n and x >= 0 }
4407 maps C<x> to C<1 + n - x> for values of C<x> between C<0> and C<n>.
4408 A given piecewise quasipolynomial has a fixed domain dimension.
4409 Union piecewise quasipolynomials are used to contain piecewise quasipolynomials
4410 defined over different domains.
4411 Piecewise quasipolynomials are mainly used by the C<barvinok>
4412 library for representing the number of elements in a parametric set or map.
4413 For example, the piecewise quasipolynomial above represents
4414 the number of points in the map
4416 [n] -> { [x] -> [y] : x,y >= 0 and 0 <= x + y <= n }
4418 =head3 Input and Output
4420 Piecewise quasipolynomials can be read from input using
4422 __isl_give isl_union_pw_qpolynomial *
4423 isl_union_pw_qpolynomial_read_from_str(
4424 isl_ctx *ctx, const char *str);
4426 Quasipolynomials and piecewise quasipolynomials can be printed
4427 using the following functions.
4429 __isl_give isl_printer *isl_printer_print_qpolynomial(
4430 __isl_take isl_printer *p,
4431 __isl_keep isl_qpolynomial *qp);
4433 __isl_give isl_printer *isl_printer_print_pw_qpolynomial(
4434 __isl_take isl_printer *p,
4435 __isl_keep isl_pw_qpolynomial *pwqp);
4437 __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial(
4438 __isl_take isl_printer *p,
4439 __isl_keep isl_union_pw_qpolynomial *upwqp);
4441 The output format of the printer
4442 needs to be set to either C<ISL_FORMAT_ISL> or C<ISL_FORMAT_C>.
4443 For C<isl_printer_print_union_pw_qpolynomial>, only C<ISL_FORMAT_ISL>
4445 In case of printing in C<ISL_FORMAT_C>, the user may want
4446 to set the names of all dimensions
4448 __isl_give isl_qpolynomial *isl_qpolynomial_set_dim_name(
4449 __isl_take isl_qpolynomial *qp,
4450 enum isl_dim_type type, unsigned pos,
4452 __isl_give isl_pw_qpolynomial *
4453 isl_pw_qpolynomial_set_dim_name(
4454 __isl_take isl_pw_qpolynomial *pwqp,
4455 enum isl_dim_type type, unsigned pos,
4458 =head3 Creating New (Piecewise) Quasipolynomials
4460 Some simple quasipolynomials can be created using the following functions.
4461 More complicated quasipolynomials can be created by applying
4462 operations such as addition and multiplication
4463 on the resulting quasipolynomials
4465 __isl_give isl_qpolynomial *isl_qpolynomial_zero_on_domain(
4466 __isl_take isl_space *domain);
4467 __isl_give isl_qpolynomial *isl_qpolynomial_one_on_domain(
4468 __isl_take isl_space *domain);
4469 __isl_give isl_qpolynomial *isl_qpolynomial_infty_on_domain(
4470 __isl_take isl_space *domain);
4471 __isl_give isl_qpolynomial *isl_qpolynomial_neginfty_on_domain(
4472 __isl_take isl_space *domain);
4473 __isl_give isl_qpolynomial *isl_qpolynomial_nan_on_domain(
4474 __isl_take isl_space *domain);
4475 __isl_give isl_qpolynomial *isl_qpolynomial_val_on_domain(
4476 __isl_take isl_space *domain,
4477 __isl_take isl_val *val);
4478 __isl_give isl_qpolynomial *isl_qpolynomial_var_on_domain(
4479 __isl_take isl_space *domain,
4480 enum isl_dim_type type, unsigned pos);
4481 __isl_give isl_qpolynomial *isl_qpolynomial_from_aff(
4482 __isl_take isl_aff *aff);
4484 Note that the space in which a quasipolynomial lives is a map space
4485 with a one-dimensional range. The C<domain> argument in some of
4486 the functions above corresponds to the domain of this map space.
4488 The zero piecewise quasipolynomial or a piecewise quasipolynomial
4489 with a single cell can be created using the following functions.
4490 Multiple of these single cell piecewise quasipolynomials can
4491 be combined to create more complicated piecewise quasipolynomials.
4493 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_zero(
4494 __isl_take isl_space *space);
4495 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_alloc(
4496 __isl_take isl_set *set,
4497 __isl_take isl_qpolynomial *qp);
4498 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_from_qpolynomial(
4499 __isl_take isl_qpolynomial *qp);
4500 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_from_pw_aff(
4501 __isl_take isl_pw_aff *pwaff);
4503 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_zero(
4504 __isl_take isl_space *space);
4505 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_from_pw_qpolynomial(
4506 __isl_take isl_pw_qpolynomial *pwqp);
4507 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add_pw_qpolynomial(
4508 __isl_take isl_union_pw_qpolynomial *upwqp,
4509 __isl_take isl_pw_qpolynomial *pwqp);
4511 Quasipolynomials can be copied and freed again using the following
4514 __isl_give isl_qpolynomial *isl_qpolynomial_copy(
4515 __isl_keep isl_qpolynomial *qp);
4516 void *isl_qpolynomial_free(__isl_take isl_qpolynomial *qp);
4518 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_copy(
4519 __isl_keep isl_pw_qpolynomial *pwqp);
4520 void *isl_pw_qpolynomial_free(
4521 __isl_take isl_pw_qpolynomial *pwqp);
4523 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_copy(
4524 __isl_keep isl_union_pw_qpolynomial *upwqp);
4525 void *isl_union_pw_qpolynomial_free(
4526 __isl_take isl_union_pw_qpolynomial *upwqp);
4528 =head3 Inspecting (Piecewise) Quasipolynomials
4530 To iterate over all piecewise quasipolynomials in a union
4531 piecewise quasipolynomial, use the following function
4533 int isl_union_pw_qpolynomial_foreach_pw_qpolynomial(
4534 __isl_keep isl_union_pw_qpolynomial *upwqp,
4535 int (*fn)(__isl_take isl_pw_qpolynomial *pwqp, void *user),
4538 To extract the piecewise quasipolynomial in a given space from a union, use
4540 __isl_give isl_pw_qpolynomial *
4541 isl_union_pw_qpolynomial_extract_pw_qpolynomial(
4542 __isl_keep isl_union_pw_qpolynomial *upwqp,
4543 __isl_take isl_space *space);
4545 To iterate over the cells in a piecewise quasipolynomial,
4546 use either of the following two functions
4548 int isl_pw_qpolynomial_foreach_piece(
4549 __isl_keep isl_pw_qpolynomial *pwqp,
4550 int (*fn)(__isl_take isl_set *set,
4551 __isl_take isl_qpolynomial *qp,
4552 void *user), void *user);
4553 int isl_pw_qpolynomial_foreach_lifted_piece(
4554 __isl_keep isl_pw_qpolynomial *pwqp,
4555 int (*fn)(__isl_take isl_set *set,
4556 __isl_take isl_qpolynomial *qp,
4557 void *user), void *user);
4559 As usual, the function C<fn> should return C<0> on success
4560 and C<-1> on failure. The difference between
4561 C<isl_pw_qpolynomial_foreach_piece> and
4562 C<isl_pw_qpolynomial_foreach_lifted_piece> is that
4563 C<isl_pw_qpolynomial_foreach_lifted_piece> will first
4564 compute unique representations for all existentially quantified
4565 variables and then turn these existentially quantified variables
4566 into extra set variables, adapting the associated quasipolynomial
4567 accordingly. This means that the C<set> passed to C<fn>
4568 will not have any existentially quantified variables, but that
4569 the dimensions of the sets may be different for different
4570 invocations of C<fn>.
4572 The constant term of a quasipolynomial can be extracted using
4574 __isl_give isl_val *isl_qpolynomial_get_constant_val(
4575 __isl_keep isl_qpolynomial *qp);
4577 To iterate over all terms in a quasipolynomial,
4580 int isl_qpolynomial_foreach_term(
4581 __isl_keep isl_qpolynomial *qp,
4582 int (*fn)(__isl_take isl_term *term,
4583 void *user), void *user);
4585 The terms themselves can be inspected and freed using
4588 unsigned isl_term_dim(__isl_keep isl_term *term,
4589 enum isl_dim_type type);
4590 __isl_give isl_val *isl_term_get_coefficient_val(
4591 __isl_keep isl_term *term);
4592 int isl_term_get_exp(__isl_keep isl_term *term,
4593 enum isl_dim_type type, unsigned pos);
4594 __isl_give isl_aff *isl_term_get_div(
4595 __isl_keep isl_term *term, unsigned pos);
4596 void isl_term_free(__isl_take isl_term *term);
4598 Each term is a product of parameters, set variables and
4599 integer divisions. The function C<isl_term_get_exp>
4600 returns the exponent of a given dimensions in the given term.
4602 =head3 Properties of (Piecewise) Quasipolynomials
4604 To check whether two union piecewise quasipolynomials are
4605 obviously equal, use
4607 int isl_union_pw_qpolynomial_plain_is_equal(
4608 __isl_keep isl_union_pw_qpolynomial *upwqp1,
4609 __isl_keep isl_union_pw_qpolynomial *upwqp2);
4611 =head3 Operations on (Piecewise) Quasipolynomials
4613 __isl_give isl_qpolynomial *isl_qpolynomial_scale_val(
4614 __isl_take isl_qpolynomial *qp,
4615 __isl_take isl_val *v);
4616 __isl_give isl_qpolynomial *isl_qpolynomial_neg(
4617 __isl_take isl_qpolynomial *qp);
4618 __isl_give isl_qpolynomial *isl_qpolynomial_add(
4619 __isl_take isl_qpolynomial *qp1,
4620 __isl_take isl_qpolynomial *qp2);
4621 __isl_give isl_qpolynomial *isl_qpolynomial_sub(
4622 __isl_take isl_qpolynomial *qp1,
4623 __isl_take isl_qpolynomial *qp2);
4624 __isl_give isl_qpolynomial *isl_qpolynomial_mul(
4625 __isl_take isl_qpolynomial *qp1,
4626 __isl_take isl_qpolynomial *qp2);
4627 __isl_give isl_qpolynomial *isl_qpolynomial_pow(
4628 __isl_take isl_qpolynomial *qp, unsigned exponent);
4630 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_fix_val(
4631 __isl_take isl_pw_qpolynomial *pwqp,
4632 enum isl_dim_type type, unsigned n,
4633 __isl_take isl_val *v);
4634 __isl_give isl_pw_qpolynomial *
4635 isl_pw_qpolynomial_scale_val(
4636 __isl_take isl_pw_qpolynomial *pwqp,
4637 __isl_take isl_val *v);
4638 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add(
4639 __isl_take isl_pw_qpolynomial *pwqp1,
4640 __isl_take isl_pw_qpolynomial *pwqp2);
4641 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_sub(
4642 __isl_take isl_pw_qpolynomial *pwqp1,
4643 __isl_take isl_pw_qpolynomial *pwqp2);
4644 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add_disjoint(
4645 __isl_take isl_pw_qpolynomial *pwqp1,
4646 __isl_take isl_pw_qpolynomial *pwqp2);
4647 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_neg(
4648 __isl_take isl_pw_qpolynomial *pwqp);
4649 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_mul(
4650 __isl_take isl_pw_qpolynomial *pwqp1,
4651 __isl_take isl_pw_qpolynomial *pwqp2);
4652 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_pow(
4653 __isl_take isl_pw_qpolynomial *pwqp, unsigned exponent);
4655 __isl_give isl_union_pw_qpolynomial *
4656 isl_union_pw_qpolynomial_scale_val(
4657 __isl_take isl_union_pw_qpolynomial *upwqp,
4658 __isl_take isl_val *v);
4659 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add(
4660 __isl_take isl_union_pw_qpolynomial *upwqp1,
4661 __isl_take isl_union_pw_qpolynomial *upwqp2);
4662 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_sub(
4663 __isl_take isl_union_pw_qpolynomial *upwqp1,
4664 __isl_take isl_union_pw_qpolynomial *upwqp2);
4665 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_mul(
4666 __isl_take isl_union_pw_qpolynomial *upwqp1,
4667 __isl_take isl_union_pw_qpolynomial *upwqp2);
4669 __isl_give isl_val *isl_pw_qpolynomial_eval(
4670 __isl_take isl_pw_qpolynomial *pwqp,
4671 __isl_take isl_point *pnt);
4673 __isl_give isl_val *isl_union_pw_qpolynomial_eval(
4674 __isl_take isl_union_pw_qpolynomial *upwqp,
4675 __isl_take isl_point *pnt);
4677 __isl_give isl_set *isl_pw_qpolynomial_domain(
4678 __isl_take isl_pw_qpolynomial *pwqp);
4679 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_intersect_domain(
4680 __isl_take isl_pw_qpolynomial *pwpq,
4681 __isl_take isl_set *set);
4682 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_intersect_params(
4683 __isl_take isl_pw_qpolynomial *pwpq,
4684 __isl_take isl_set *set);
4686 __isl_give isl_union_set *isl_union_pw_qpolynomial_domain(
4687 __isl_take isl_union_pw_qpolynomial *upwqp);
4688 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_intersect_domain(
4689 __isl_take isl_union_pw_qpolynomial *upwpq,
4690 __isl_take isl_union_set *uset);
4691 __isl_give isl_union_pw_qpolynomial *
4692 isl_union_pw_qpolynomial_intersect_params(
4693 __isl_take isl_union_pw_qpolynomial *upwpq,
4694 __isl_take isl_set *set);
4696 __isl_give isl_qpolynomial *isl_qpolynomial_align_params(
4697 __isl_take isl_qpolynomial *qp,
4698 __isl_take isl_space *model);
4700 __isl_give isl_qpolynomial *isl_qpolynomial_project_domain_on_params(
4701 __isl_take isl_qpolynomial *qp);
4702 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_project_domain_on_params(
4703 __isl_take isl_pw_qpolynomial *pwqp);
4705 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_coalesce(
4706 __isl_take isl_union_pw_qpolynomial *upwqp);
4708 __isl_give isl_qpolynomial *isl_qpolynomial_gist_params(
4709 __isl_take isl_qpolynomial *qp,
4710 __isl_take isl_set *context);
4711 __isl_give isl_qpolynomial *isl_qpolynomial_gist(
4712 __isl_take isl_qpolynomial *qp,
4713 __isl_take isl_set *context);
4715 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist_params(
4716 __isl_take isl_pw_qpolynomial *pwqp,
4717 __isl_take isl_set *context);
4718 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist(
4719 __isl_take isl_pw_qpolynomial *pwqp,
4720 __isl_take isl_set *context);
4722 __isl_give isl_union_pw_qpolynomial *
4723 isl_union_pw_qpolynomial_gist_params(
4724 __isl_take isl_union_pw_qpolynomial *upwqp,
4725 __isl_take isl_set *context);
4726 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_gist(
4727 __isl_take isl_union_pw_qpolynomial *upwqp,
4728 __isl_take isl_union_set *context);
4730 The gist operation applies the gist operation to each of
4731 the cells in the domain of the input piecewise quasipolynomial.
4732 The context is also exploited
4733 to simplify the quasipolynomials associated to each cell.
4735 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_to_polynomial(
4736 __isl_take isl_pw_qpolynomial *pwqp, int sign);
4737 __isl_give isl_union_pw_qpolynomial *
4738 isl_union_pw_qpolynomial_to_polynomial(
4739 __isl_take isl_union_pw_qpolynomial *upwqp, int sign);
4741 Approximate each quasipolynomial by a polynomial. If C<sign> is positive,
4742 the polynomial will be an overapproximation. If C<sign> is negative,
4743 it will be an underapproximation. If C<sign> is zero, the approximation
4744 will lie somewhere in between.
4746 =head2 Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions
4748 A piecewise quasipolynomial reduction is a piecewise
4749 reduction (or fold) of quasipolynomials.
4750 In particular, the reduction can be maximum or a minimum.
4751 The objects are mainly used to represent the result of
4752 an upper or lower bound on a quasipolynomial over its domain,
4753 i.e., as the result of the following function.
4755 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_bound(
4756 __isl_take isl_pw_qpolynomial *pwqp,
4757 enum isl_fold type, int *tight);
4759 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_bound(
4760 __isl_take isl_union_pw_qpolynomial *upwqp,
4761 enum isl_fold type, int *tight);
4763 The C<type> argument may be either C<isl_fold_min> or C<isl_fold_max>.
4764 If C<tight> is not C<NULL>, then C<*tight> is set to C<1>
4765 is the returned bound is known be tight, i.e., for each value
4766 of the parameters there is at least
4767 one element in the domain that reaches the bound.
4768 If the domain of C<pwqp> is not wrapping, then the bound is computed
4769 over all elements in that domain and the result has a purely parametric
4770 domain. If the domain of C<pwqp> is wrapping, then the bound is
4771 computed over the range of the wrapped relation. The domain of the
4772 wrapped relation becomes the domain of the result.
4774 A (piecewise) quasipolynomial reduction can be copied or freed using the
4775 following functions.
4777 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_copy(
4778 __isl_keep isl_qpolynomial_fold *fold);
4779 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_copy(
4780 __isl_keep isl_pw_qpolynomial_fold *pwf);
4781 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_copy(
4782 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
4783 void isl_qpolynomial_fold_free(
4784 __isl_take isl_qpolynomial_fold *fold);
4785 void *isl_pw_qpolynomial_fold_free(
4786 __isl_take isl_pw_qpolynomial_fold *pwf);
4787 void *isl_union_pw_qpolynomial_fold_free(
4788 __isl_take isl_union_pw_qpolynomial_fold *upwf);
4790 =head3 Printing Piecewise Quasipolynomial Reductions
4792 Piecewise quasipolynomial reductions can be printed
4793 using the following function.
4795 __isl_give isl_printer *isl_printer_print_pw_qpolynomial_fold(
4796 __isl_take isl_printer *p,
4797 __isl_keep isl_pw_qpolynomial_fold *pwf);
4798 __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial_fold(
4799 __isl_take isl_printer *p,
4800 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
4802 For C<isl_printer_print_pw_qpolynomial_fold>,
4803 output format of the printer
4804 needs to be set to either C<ISL_FORMAT_ISL> or C<ISL_FORMAT_C>.
4805 For C<isl_printer_print_union_pw_qpolynomial_fold>,
4806 output format of the printer
4807 needs to be set to C<ISL_FORMAT_ISL>.
4808 In case of printing in C<ISL_FORMAT_C>, the user may want
4809 to set the names of all dimensions
4811 __isl_give isl_pw_qpolynomial_fold *
4812 isl_pw_qpolynomial_fold_set_dim_name(
4813 __isl_take isl_pw_qpolynomial_fold *pwf,
4814 enum isl_dim_type type, unsigned pos,
4817 =head3 Inspecting (Piecewise) Quasipolynomial Reductions
4819 To iterate over all piecewise quasipolynomial reductions in a union
4820 piecewise quasipolynomial reduction, use the following function
4822 int isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(
4823 __isl_keep isl_union_pw_qpolynomial_fold *upwf,
4824 int (*fn)(__isl_take isl_pw_qpolynomial_fold *pwf,
4825 void *user), void *user);
4827 To iterate over the cells in a piecewise quasipolynomial reduction,
4828 use either of the following two functions
4830 int isl_pw_qpolynomial_fold_foreach_piece(
4831 __isl_keep isl_pw_qpolynomial_fold *pwf,
4832 int (*fn)(__isl_take isl_set *set,
4833 __isl_take isl_qpolynomial_fold *fold,
4834 void *user), void *user);
4835 int isl_pw_qpolynomial_fold_foreach_lifted_piece(
4836 __isl_keep isl_pw_qpolynomial_fold *pwf,
4837 int (*fn)(__isl_take isl_set *set,
4838 __isl_take isl_qpolynomial_fold *fold,
4839 void *user), void *user);
4841 See L<Inspecting (Piecewise) Quasipolynomials> for an explanation
4842 of the difference between these two functions.
4844 To iterate over all quasipolynomials in a reduction, use
4846 int isl_qpolynomial_fold_foreach_qpolynomial(
4847 __isl_keep isl_qpolynomial_fold *fold,
4848 int (*fn)(__isl_take isl_qpolynomial *qp,
4849 void *user), void *user);
4851 =head3 Properties of Piecewise Quasipolynomial Reductions
4853 To check whether two union piecewise quasipolynomial reductions are
4854 obviously equal, use
4856 int isl_union_pw_qpolynomial_fold_plain_is_equal(
4857 __isl_keep isl_union_pw_qpolynomial_fold *upwf1,
4858 __isl_keep isl_union_pw_qpolynomial_fold *upwf2);
4860 =head3 Operations on Piecewise Quasipolynomial Reductions
4862 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_scale_val(
4863 __isl_take isl_qpolynomial_fold *fold,
4864 __isl_take isl_val *v);
4865 __isl_give isl_pw_qpolynomial_fold *
4866 isl_pw_qpolynomial_fold_scale_val(
4867 __isl_take isl_pw_qpolynomial_fold *pwf,
4868 __isl_take isl_val *v);
4869 __isl_give isl_union_pw_qpolynomial_fold *
4870 isl_union_pw_qpolynomial_fold_scale_val(
4871 __isl_take isl_union_pw_qpolynomial_fold *upwf,
4872 __isl_take isl_val *v);
4874 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_add(
4875 __isl_take isl_pw_qpolynomial_fold *pwf1,
4876 __isl_take isl_pw_qpolynomial_fold *pwf2);
4878 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_fold(
4879 __isl_take isl_pw_qpolynomial_fold *pwf1,
4880 __isl_take isl_pw_qpolynomial_fold *pwf2);
4882 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_fold(
4883 __isl_take isl_union_pw_qpolynomial_fold *upwf1,
4884 __isl_take isl_union_pw_qpolynomial_fold *upwf2);
4886 __isl_give isl_val *isl_pw_qpolynomial_fold_eval(
4887 __isl_take isl_pw_qpolynomial_fold *pwf,
4888 __isl_take isl_point *pnt);
4890 __isl_give isl_val *isl_union_pw_qpolynomial_fold_eval(
4891 __isl_take isl_union_pw_qpolynomial_fold *upwf,
4892 __isl_take isl_point *pnt);
4894 __isl_give isl_pw_qpolynomial_fold *
4895 isl_pw_qpolynomial_fold_intersect_params(
4896 __isl_take isl_pw_qpolynomial_fold *pwf,
4897 __isl_take isl_set *set);
4899 __isl_give isl_union_set *isl_union_pw_qpolynomial_fold_domain(
4900 __isl_take isl_union_pw_qpolynomial_fold *upwf);
4901 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_intersect_domain(
4902 __isl_take isl_union_pw_qpolynomial_fold *upwf,
4903 __isl_take isl_union_set *uset);
4904 __isl_give isl_union_pw_qpolynomial_fold *
4905 isl_union_pw_qpolynomial_fold_intersect_params(
4906 __isl_take isl_union_pw_qpolynomial_fold *upwf,
4907 __isl_take isl_set *set);
4909 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_project_domain_on_params(
4910 __isl_take isl_pw_qpolynomial_fold *pwf);
4912 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_coalesce(
4913 __isl_take isl_pw_qpolynomial_fold *pwf);
4915 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_coalesce(
4916 __isl_take isl_union_pw_qpolynomial_fold *upwf);
4918 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist_params(
4919 __isl_take isl_qpolynomial_fold *fold,
4920 __isl_take isl_set *context);
4921 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist(
4922 __isl_take isl_qpolynomial_fold *fold,
4923 __isl_take isl_set *context);
4925 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_gist(
4926 __isl_take isl_pw_qpolynomial_fold *pwf,
4927 __isl_take isl_set *context);
4928 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_gist_params(
4929 __isl_take isl_pw_qpolynomial_fold *pwf,
4930 __isl_take isl_set *context);
4932 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_gist(
4933 __isl_take isl_union_pw_qpolynomial_fold *upwf,
4934 __isl_take isl_union_set *context);
4935 __isl_give isl_union_pw_qpolynomial_fold *
4936 isl_union_pw_qpolynomial_fold_gist_params(
4937 __isl_take isl_union_pw_qpolynomial_fold *upwf,
4938 __isl_take isl_set *context);
4940 The gist operation applies the gist operation to each of
4941 the cells in the domain of the input piecewise quasipolynomial reduction.
4942 In future, the operation will also exploit the context
4943 to simplify the quasipolynomial reductions associated to each cell.
4945 __isl_give isl_pw_qpolynomial_fold *
4946 isl_set_apply_pw_qpolynomial_fold(
4947 __isl_take isl_set *set,
4948 __isl_take isl_pw_qpolynomial_fold *pwf,
4950 __isl_give isl_pw_qpolynomial_fold *
4951 isl_map_apply_pw_qpolynomial_fold(
4952 __isl_take isl_map *map,
4953 __isl_take isl_pw_qpolynomial_fold *pwf,
4955 __isl_give isl_union_pw_qpolynomial_fold *
4956 isl_union_set_apply_union_pw_qpolynomial_fold(
4957 __isl_take isl_union_set *uset,
4958 __isl_take isl_union_pw_qpolynomial_fold *upwf,
4960 __isl_give isl_union_pw_qpolynomial_fold *
4961 isl_union_map_apply_union_pw_qpolynomial_fold(
4962 __isl_take isl_union_map *umap,
4963 __isl_take isl_union_pw_qpolynomial_fold *upwf,
4966 The functions taking a map
4967 compose the given map with the given piecewise quasipolynomial reduction.
4968 That is, compute a bound (of the same type as C<pwf> or C<upwf> itself)
4969 over all elements in the intersection of the range of the map
4970 and the domain of the piecewise quasipolynomial reduction
4971 as a function of an element in the domain of the map.
4972 The functions taking a set compute a bound over all elements in the
4973 intersection of the set and the domain of the
4974 piecewise quasipolynomial reduction.
4976 =head2 Parametric Vertex Enumeration
4978 The parametric vertex enumeration described in this section
4979 is mainly intended to be used internally and by the C<barvinok>
4982 #include <isl/vertices.h>
4983 __isl_give isl_vertices *isl_basic_set_compute_vertices(
4984 __isl_keep isl_basic_set *bset);
4986 The function C<isl_basic_set_compute_vertices> performs the
4987 actual computation of the parametric vertices and the chamber
4988 decomposition and store the result in an C<isl_vertices> object.
4989 This information can be queried by either iterating over all
4990 the vertices or iterating over all the chambers or cells
4991 and then iterating over all vertices that are active on the chamber.
4993 int isl_vertices_foreach_vertex(
4994 __isl_keep isl_vertices *vertices,
4995 int (*fn)(__isl_take isl_vertex *vertex, void *user),
4998 int isl_vertices_foreach_cell(
4999 __isl_keep isl_vertices *vertices,
5000 int (*fn)(__isl_take isl_cell *cell, void *user),
5002 int isl_cell_foreach_vertex(__isl_keep isl_cell *cell,
5003 int (*fn)(__isl_take isl_vertex *vertex, void *user),
5006 Other operations that can be performed on an C<isl_vertices> object are
5009 isl_ctx *isl_vertices_get_ctx(
5010 __isl_keep isl_vertices *vertices);
5011 int isl_vertices_get_n_vertices(
5012 __isl_keep isl_vertices *vertices);
5013 void isl_vertices_free(__isl_take isl_vertices *vertices);
5015 Vertices can be inspected and destroyed using the following functions.
5017 isl_ctx *isl_vertex_get_ctx(__isl_keep isl_vertex *vertex);
5018 int isl_vertex_get_id(__isl_keep isl_vertex *vertex);
5019 __isl_give isl_basic_set *isl_vertex_get_domain(
5020 __isl_keep isl_vertex *vertex);
5021 __isl_give isl_basic_set *isl_vertex_get_expr(
5022 __isl_keep isl_vertex *vertex);
5023 void isl_vertex_free(__isl_take isl_vertex *vertex);
5025 C<isl_vertex_get_expr> returns a singleton parametric set describing
5026 the vertex, while C<isl_vertex_get_domain> returns the activity domain
5028 Note that C<isl_vertex_get_domain> and C<isl_vertex_get_expr> return
5029 B<rational> basic sets, so they should mainly be used for inspection
5030 and should not be mixed with integer sets.
5032 Chambers can be inspected and destroyed using the following functions.
5034 isl_ctx *isl_cell_get_ctx(__isl_keep isl_cell *cell);
5035 __isl_give isl_basic_set *isl_cell_get_domain(
5036 __isl_keep isl_cell *cell);
5037 void isl_cell_free(__isl_take isl_cell *cell);
5039 =head1 Polyhedral Compilation Library
5041 This section collects functionality in C<isl> that has been specifically
5042 designed for use during polyhedral compilation.
5044 =head2 Dependence Analysis
5046 C<isl> contains specialized functionality for performing
5047 array dataflow analysis. That is, given a I<sink> access relation
5048 and a collection of possible I<source> access relations,
5049 C<isl> can compute relations that describe
5050 for each iteration of the sink access, which iteration
5051 of which of the source access relations was the last
5052 to access the same data element before the given iteration
5054 The resulting dependence relations map source iterations
5055 to the corresponding sink iterations.
5056 To compute standard flow dependences, the sink should be
5057 a read, while the sources should be writes.
5058 If any of the source accesses are marked as being I<may>
5059 accesses, then there will be a dependence from the last
5060 I<must> access B<and> from any I<may> access that follows
5061 this last I<must> access.
5062 In particular, if I<all> sources are I<may> accesses,
5063 then memory based dependence analysis is performed.
5064 If, on the other hand, all sources are I<must> accesses,
5065 then value based dependence analysis is performed.
5067 #include <isl/flow.h>
5069 typedef int (*isl_access_level_before)(void *first, void *second);
5071 __isl_give isl_access_info *isl_access_info_alloc(
5072 __isl_take isl_map *sink,
5073 void *sink_user, isl_access_level_before fn,
5075 __isl_give isl_access_info *isl_access_info_add_source(
5076 __isl_take isl_access_info *acc,
5077 __isl_take isl_map *source, int must,
5079 void *isl_access_info_free(__isl_take isl_access_info *acc);
5081 __isl_give isl_flow *isl_access_info_compute_flow(
5082 __isl_take isl_access_info *acc);
5084 int isl_flow_foreach(__isl_keep isl_flow *deps,
5085 int (*fn)(__isl_take isl_map *dep, int must,
5086 void *dep_user, void *user),
5088 __isl_give isl_map *isl_flow_get_no_source(
5089 __isl_keep isl_flow *deps, int must);
5090 void isl_flow_free(__isl_take isl_flow *deps);
5092 The function C<isl_access_info_compute_flow> performs the actual
5093 dependence analysis. The other functions are used to construct
5094 the input for this function or to read off the output.
5096 The input is collected in an C<isl_access_info>, which can
5097 be created through a call to C<isl_access_info_alloc>.
5098 The arguments to this functions are the sink access relation
5099 C<sink>, a token C<sink_user> used to identify the sink
5100 access to the user, a callback function for specifying the
5101 relative order of source and sink accesses, and the number
5102 of source access relations that will be added.
5103 The callback function has type C<int (*)(void *first, void *second)>.
5104 The function is called with two user supplied tokens identifying
5105 either a source or the sink and it should return the shared nesting
5106 level and the relative order of the two accesses.
5107 In particular, let I<n> be the number of loops shared by
5108 the two accesses. If C<first> precedes C<second> textually,
5109 then the function should return I<2 * n + 1>; otherwise,
5110 it should return I<2 * n>.
5111 The sources can be added to the C<isl_access_info> by performing
5112 (at most) C<max_source> calls to C<isl_access_info_add_source>.
5113 C<must> indicates whether the source is a I<must> access
5114 or a I<may> access. Note that a multi-valued access relation
5115 should only be marked I<must> if every iteration in the domain
5116 of the relation accesses I<all> elements in its image.
5117 The C<source_user> token is again used to identify
5118 the source access. The range of the source access relation
5119 C<source> should have the same dimension as the range
5120 of the sink access relation.
5121 The C<isl_access_info_free> function should usually not be
5122 called explicitly, because it is called implicitly by
5123 C<isl_access_info_compute_flow>.
5125 The result of the dependence analysis is collected in an
5126 C<isl_flow>. There may be elements of
5127 the sink access for which no preceding source access could be
5128 found or for which all preceding sources are I<may> accesses.
5129 The relations containing these elements can be obtained through
5130 calls to C<isl_flow_get_no_source>, the first with C<must> set
5131 and the second with C<must> unset.
5132 In the case of standard flow dependence analysis,
5133 with the sink a read and the sources I<must> writes,
5134 the first relation corresponds to the reads from uninitialized
5135 array elements and the second relation is empty.
5136 The actual flow dependences can be extracted using
5137 C<isl_flow_foreach>. This function will call the user-specified
5138 callback function C<fn> for each B<non-empty> dependence between
5139 a source and the sink. The callback function is called
5140 with four arguments, the actual flow dependence relation
5141 mapping source iterations to sink iterations, a boolean that
5142 indicates whether it is a I<must> or I<may> dependence, a token
5143 identifying the source and an additional C<void *> with value
5144 equal to the third argument of the C<isl_flow_foreach> call.
5145 A dependence is marked I<must> if it originates from a I<must>
5146 source and if it is not followed by any I<may> sources.
5148 After finishing with an C<isl_flow>, the user should call
5149 C<isl_flow_free> to free all associated memory.
5151 A higher-level interface to dependence analysis is provided
5152 by the following function.
5154 #include <isl/flow.h>
5156 int isl_union_map_compute_flow(__isl_take isl_union_map *sink,
5157 __isl_take isl_union_map *must_source,
5158 __isl_take isl_union_map *may_source,
5159 __isl_take isl_union_map *schedule,
5160 __isl_give isl_union_map **must_dep,
5161 __isl_give isl_union_map **may_dep,
5162 __isl_give isl_union_map **must_no_source,
5163 __isl_give isl_union_map **may_no_source);
5165 The arrays are identified by the tuple names of the ranges
5166 of the accesses. The iteration domains by the tuple names
5167 of the domains of the accesses and of the schedule.
5168 The relative order of the iteration domains is given by the
5169 schedule. The relations returned through C<must_no_source>
5170 and C<may_no_source> are subsets of C<sink>.
5171 Any of C<must_dep>, C<may_dep>, C<must_no_source>
5172 or C<may_no_source> may be C<NULL>, but a C<NULL> value for
5173 any of the other arguments is treated as an error.
5175 =head3 Interaction with Dependence Analysis
5177 During the dependence analysis, we frequently need to perform
5178 the following operation. Given a relation between sink iterations
5179 and potential source iterations from a particular source domain,
5180 what is the last potential source iteration corresponding to each
5181 sink iteration. It can sometimes be convenient to adjust
5182 the set of potential source iterations before or after each such operation.
5183 The prototypical example is fuzzy array dataflow analysis,
5184 where we need to analyze if, based on data-dependent constraints,
5185 the sink iteration can ever be executed without one or more of
5186 the corresponding potential source iterations being executed.
5187 If so, we can introduce extra parameters and select an unknown
5188 but fixed source iteration from the potential source iterations.
5189 To be able to perform such manipulations, C<isl> provides the following
5192 #include <isl/flow.h>
5194 typedef __isl_give isl_restriction *(*isl_access_restrict)(
5195 __isl_keep isl_map *source_map,
5196 __isl_keep isl_set *sink, void *source_user,
5198 __isl_give isl_access_info *isl_access_info_set_restrict(
5199 __isl_take isl_access_info *acc,
5200 isl_access_restrict fn, void *user);
5202 The function C<isl_access_info_set_restrict> should be called
5203 before calling C<isl_access_info_compute_flow> and registers a callback function
5204 that will be called any time C<isl> is about to compute the last
5205 potential source. The first argument is the (reverse) proto-dependence,
5206 mapping sink iterations to potential source iterations.
5207 The second argument represents the sink iterations for which
5208 we want to compute the last source iteration.
5209 The third argument is the token corresponding to the source
5210 and the final argument is the token passed to C<isl_access_info_set_restrict>.
5211 The callback is expected to return a restriction on either the input or
5212 the output of the operation computing the last potential source.
5213 If the input needs to be restricted then restrictions are needed
5214 for both the source and the sink iterations. The sink iterations
5215 and the potential source iterations will be intersected with these sets.
5216 If the output needs to be restricted then only a restriction on the source
5217 iterations is required.
5218 If any error occurs, the callback should return C<NULL>.
5219 An C<isl_restriction> object can be created, freed and inspected
5220 using the following functions.
5222 #include <isl/flow.h>
5224 __isl_give isl_restriction *isl_restriction_input(
5225 __isl_take isl_set *source_restr,
5226 __isl_take isl_set *sink_restr);
5227 __isl_give isl_restriction *isl_restriction_output(
5228 __isl_take isl_set *source_restr);
5229 __isl_give isl_restriction *isl_restriction_none(
5230 __isl_take isl_map *source_map);
5231 __isl_give isl_restriction *isl_restriction_empty(
5232 __isl_take isl_map *source_map);
5233 void *isl_restriction_free(
5234 __isl_take isl_restriction *restr);
5235 isl_ctx *isl_restriction_get_ctx(
5236 __isl_keep isl_restriction *restr);
5238 C<isl_restriction_none> and C<isl_restriction_empty> are special
5239 cases of C<isl_restriction_input>. C<isl_restriction_none>
5240 is essentially equivalent to
5242 isl_restriction_input(isl_set_universe(
5243 isl_space_range(isl_map_get_space(source_map))),
5245 isl_space_domain(isl_map_get_space(source_map))));
5247 whereas C<isl_restriction_empty> is essentially equivalent to
5249 isl_restriction_input(isl_set_empty(
5250 isl_space_range(isl_map_get_space(source_map))),
5252 isl_space_domain(isl_map_get_space(source_map))));
5256 B<The functionality described in this section is fairly new
5257 and may be subject to change.>
5259 The following function can be used to compute a schedule
5260 for a union of domains.
5261 By default, the algorithm used to construct the schedule is similar
5262 to that of C<Pluto>.
5263 Alternatively, Feautrier's multi-dimensional scheduling algorithm can
5265 The generated schedule respects all C<validity> dependences.
5266 That is, all dependence distances over these dependences in the
5267 scheduled space are lexicographically positive.
5268 The default algorithm tries to minimize the dependence distances over
5269 C<proximity> dependences.
5270 Moreover, it tries to obtain sequences (bands) of schedule dimensions
5271 for groups of domains where the dependence distances have only
5272 non-negative values.
5273 When using Feautrier's algorithm, the C<proximity> dependence
5274 distances are only minimized during the extension to a
5275 full-dimensional schedule.
5277 #include <isl/schedule.h>
5278 __isl_give isl_schedule *isl_union_set_compute_schedule(
5279 __isl_take isl_union_set *domain,
5280 __isl_take isl_union_map *validity,
5281 __isl_take isl_union_map *proximity);
5282 void *isl_schedule_free(__isl_take isl_schedule *sched);
5284 A mapping from the domains to the scheduled space can be obtained
5285 from an C<isl_schedule> using the following function.
5287 __isl_give isl_union_map *isl_schedule_get_map(
5288 __isl_keep isl_schedule *sched);
5290 A representation of the schedule can be printed using
5292 __isl_give isl_printer *isl_printer_print_schedule(
5293 __isl_take isl_printer *p,
5294 __isl_keep isl_schedule *schedule);
5296 A representation of the schedule as a forest of bands can be obtained
5297 using the following function.
5299 __isl_give isl_band_list *isl_schedule_get_band_forest(
5300 __isl_keep isl_schedule *schedule);
5302 The individual bands can be visited in depth-first post-order
5303 using the following function.
5305 #include <isl/schedule.h>
5306 int isl_schedule_foreach_band(
5307 __isl_keep isl_schedule *sched,
5308 int (*fn)(__isl_keep isl_band *band, void *user),
5311 The list can be manipulated as explained in L<"Lists">.
5312 The bands inside the list can be copied and freed using the following
5315 #include <isl/band.h>
5316 __isl_give isl_band *isl_band_copy(
5317 __isl_keep isl_band *band);
5318 void *isl_band_free(__isl_take isl_band *band);
5320 Each band contains zero or more scheduling dimensions.
5321 These are referred to as the members of the band.
5322 The section of the schedule that corresponds to the band is
5323 referred to as the partial schedule of the band.
5324 For those nodes that participate in a band, the outer scheduling
5325 dimensions form the prefix schedule, while the inner scheduling
5326 dimensions form the suffix schedule.
5327 That is, if we take a cut of the band forest, then the union of
5328 the concatenations of the prefix, partial and suffix schedules of
5329 each band in the cut is equal to the entire schedule (modulo
5330 some possible padding at the end with zero scheduling dimensions).
5331 The properties of a band can be inspected using the following functions.
5333 #include <isl/band.h>
5334 isl_ctx *isl_band_get_ctx(__isl_keep isl_band *band);
5336 int isl_band_has_children(__isl_keep isl_band *band);
5337 __isl_give isl_band_list *isl_band_get_children(
5338 __isl_keep isl_band *band);
5340 __isl_give isl_union_map *isl_band_get_prefix_schedule(
5341 __isl_keep isl_band *band);
5342 __isl_give isl_union_map *isl_band_get_partial_schedule(
5343 __isl_keep isl_band *band);
5344 __isl_give isl_union_map *isl_band_get_suffix_schedule(
5345 __isl_keep isl_band *band);
5347 int isl_band_n_member(__isl_keep isl_band *band);
5348 int isl_band_member_is_zero_distance(
5349 __isl_keep isl_band *band, int pos);
5351 int isl_band_list_foreach_band(
5352 __isl_keep isl_band_list *list,
5353 int (*fn)(__isl_keep isl_band *band, void *user),
5356 Note that a scheduling dimension is considered to be ``zero
5357 distance'' if it does not carry any proximity dependences
5359 That is, if the dependence distances of the proximity
5360 dependences are all zero in that direction (for fixed
5361 iterations of outer bands).
5362 Like C<isl_schedule_foreach_band>,
5363 the function C<isl_band_list_foreach_band> calls C<fn> on the bands
5364 in depth-first post-order.
5366 A band can be tiled using the following function.
5368 #include <isl/band.h>
5369 int isl_band_tile(__isl_keep isl_band *band,
5370 __isl_take isl_vec *sizes);
5372 int isl_options_set_tile_scale_tile_loops(isl_ctx *ctx,
5374 int isl_options_get_tile_scale_tile_loops(isl_ctx *ctx);
5375 int isl_options_set_tile_shift_point_loops(isl_ctx *ctx,
5377 int isl_options_get_tile_shift_point_loops(isl_ctx *ctx);
5379 The C<isl_band_tile> function tiles the band using the given tile sizes
5380 inside its schedule.
5381 A new child band is created to represent the point loops and it is
5382 inserted between the modified band and its children.
5383 The C<tile_scale_tile_loops> option specifies whether the tile
5384 loops iterators should be scaled by the tile sizes.
5385 If the C<tile_shift_point_loops> option is set, then the point loops
5386 are shifted to start at zero.
5388 A band can be split into two nested bands using the following function.
5390 int isl_band_split(__isl_keep isl_band *band, int pos);
5392 The resulting outer band contains the first C<pos> dimensions of C<band>
5393 while the inner band contains the remaining dimensions.
5395 A representation of the band can be printed using
5397 #include <isl/band.h>
5398 __isl_give isl_printer *isl_printer_print_band(
5399 __isl_take isl_printer *p,
5400 __isl_keep isl_band *band);
5404 #include <isl/schedule.h>
5405 int isl_options_set_schedule_max_coefficient(
5406 isl_ctx *ctx, int val);
5407 int isl_options_get_schedule_max_coefficient(
5409 int isl_options_set_schedule_max_constant_term(
5410 isl_ctx *ctx, int val);
5411 int isl_options_get_schedule_max_constant_term(
5413 int isl_options_set_schedule_fuse(isl_ctx *ctx, int val);
5414 int isl_options_get_schedule_fuse(isl_ctx *ctx);
5415 int isl_options_set_schedule_maximize_band_depth(
5416 isl_ctx *ctx, int val);
5417 int isl_options_get_schedule_maximize_band_depth(
5419 int isl_options_set_schedule_outer_zero_distance(
5420 isl_ctx *ctx, int val);
5421 int isl_options_get_schedule_outer_zero_distance(
5423 int isl_options_set_schedule_split_scaled(
5424 isl_ctx *ctx, int val);
5425 int isl_options_get_schedule_split_scaled(
5427 int isl_options_set_schedule_algorithm(
5428 isl_ctx *ctx, int val);
5429 int isl_options_get_schedule_algorithm(
5431 int isl_options_set_schedule_separate_components(
5432 isl_ctx *ctx, int val);
5433 int isl_options_get_schedule_separate_components(
5438 =item * schedule_max_coefficient
5440 This option enforces that the coefficients for variable and parameter
5441 dimensions in the calculated schedule are not larger than the specified value.
5442 This option can significantly increase the speed of the scheduling calculation
5443 and may also prevent fusing of unrelated dimensions. A value of -1 means that
5444 this option does not introduce bounds on the variable or parameter
5447 =item * schedule_max_constant_term
5449 This option enforces that the constant coefficients in the calculated schedule
5450 are not larger than the maximal constant term. This option can significantly
5451 increase the speed of the scheduling calculation and may also prevent fusing of
5452 unrelated dimensions. A value of -1 means that this option does not introduce
5453 bounds on the constant coefficients.
5455 =item * schedule_fuse
5457 This option controls the level of fusion.
5458 If this option is set to C<ISL_SCHEDULE_FUSE_MIN>, then loops in the
5459 resulting schedule will be distributed as much as possible.
5460 If this option is set to C<ISL_SCHEDULE_FUSE_MAX>, then C<isl> will
5461 try to fuse loops in the resulting schedule.
5463 =item * schedule_maximize_band_depth
5465 If this option is set, we do not split bands at the point
5466 where we detect splitting is necessary. Instead, we
5467 backtrack and split bands as early as possible. This
5468 reduces the number of splits and maximizes the width of
5469 the bands. Wider bands give more possibilities for tiling.
5470 Note that if the C<schedule_fuse> option is set to C<ISL_SCHEDULE_FUSE_MIN>,
5471 then bands will be split as early as possible, even if there is no need.
5472 The C<schedule_maximize_band_depth> option therefore has no effect in this case.
5474 =item * schedule_outer_zero_distance
5476 If this option is set, then we try to construct schedules
5477 where the outermost scheduling dimension in each band
5478 results in a zero dependence distance over the proximity
5481 =item * schedule_split_scaled
5483 If this option is set, then we try to construct schedules in which the
5484 constant term is split off from the linear part if the linear parts of
5485 the scheduling rows for all nodes in the graphs have a common non-trivial
5487 The constant term is then placed in a separate band and the linear
5490 =item * schedule_algorithm
5492 Selects the scheduling algorithm to be used.
5493 Available scheduling algorithms are C<ISL_SCHEDULE_ALGORITHM_ISL>
5494 and C<ISL_SCHEDULE_ALGORITHM_FEAUTRIER>.
5496 =item * schedule_separate_components
5498 If at any point the dependence graph contains any (weakly connected) components,
5499 then these components are scheduled separately.
5500 If this option is not set, then some iterations of the domains
5501 in these components may be scheduled together.
5502 If this option is set, then the components are given consecutive
5507 =head2 AST Generation
5509 This section describes the C<isl> functionality for generating
5510 ASTs that visit all the elements
5511 in a domain in an order specified by a schedule.
5512 In particular, given a C<isl_union_map>, an AST is generated
5513 that visits all the elements in the domain of the C<isl_union_map>
5514 according to the lexicographic order of the corresponding image
5515 element(s). If the range of the C<isl_union_map> consists of
5516 elements in more than one space, then each of these spaces is handled
5517 separately in an arbitrary order.
5518 It should be noted that the image elements only specify the I<order>
5519 in which the corresponding domain elements should be visited.
5520 No direct relation between the image elements and the loop iterators
5521 in the generated AST should be assumed.
5523 Each AST is generated within a build. The initial build
5524 simply specifies the constraints on the parameters (if any)
5525 and can be created, inspected, copied and freed using the following functions.
5527 #include <isl/ast_build.h>
5528 __isl_give isl_ast_build *isl_ast_build_from_context(
5529 __isl_take isl_set *set);
5530 isl_ctx *isl_ast_build_get_ctx(
5531 __isl_keep isl_ast_build *build);
5532 __isl_give isl_ast_build *isl_ast_build_copy(
5533 __isl_keep isl_ast_build *build);
5534 void *isl_ast_build_free(
5535 __isl_take isl_ast_build *build);
5537 The C<set> argument is usually a parameter set with zero or more parameters.
5538 More C<isl_ast_build> functions are described in L</"Nested AST Generation">
5539 and L</"Fine-grained Control over AST Generation">.
5540 Finally, the AST itself can be constructed using the following
5543 #include <isl/ast_build.h>
5544 __isl_give isl_ast_node *isl_ast_build_ast_from_schedule(
5545 __isl_keep isl_ast_build *build,
5546 __isl_take isl_union_map *schedule);
5548 =head3 Inspecting the AST
5550 The basic properties of an AST node can be obtained as follows.
5552 #include <isl/ast.h>
5553 isl_ctx *isl_ast_node_get_ctx(
5554 __isl_keep isl_ast_node *node);
5555 enum isl_ast_node_type isl_ast_node_get_type(
5556 __isl_keep isl_ast_node *node);
5558 The type of an AST node is one of
5559 C<isl_ast_node_for>,
5561 C<isl_ast_node_block> or
5562 C<isl_ast_node_user>.
5563 An C<isl_ast_node_for> represents a for node.
5564 An C<isl_ast_node_if> represents an if node.
5565 An C<isl_ast_node_block> represents a compound node.
5566 An C<isl_ast_node_user> represents an expression statement.
5567 An expression statement typically corresponds to a domain element, i.e.,
5568 one of the elements that is visited by the AST.
5570 Each type of node has its own additional properties.
5572 #include <isl/ast.h>
5573 __isl_give isl_ast_expr *isl_ast_node_for_get_iterator(
5574 __isl_keep isl_ast_node *node);
5575 __isl_give isl_ast_expr *isl_ast_node_for_get_init(
5576 __isl_keep isl_ast_node *node);
5577 __isl_give isl_ast_expr *isl_ast_node_for_get_cond(
5578 __isl_keep isl_ast_node *node);
5579 __isl_give isl_ast_expr *isl_ast_node_for_get_inc(
5580 __isl_keep isl_ast_node *node);
5581 __isl_give isl_ast_node *isl_ast_node_for_get_body(
5582 __isl_keep isl_ast_node *node);
5583 int isl_ast_node_for_is_degenerate(
5584 __isl_keep isl_ast_node *node);
5586 An C<isl_ast_for> is considered degenerate if it is known to execute
5589 #include <isl/ast.h>
5590 __isl_give isl_ast_expr *isl_ast_node_if_get_cond(
5591 __isl_keep isl_ast_node *node);
5592 __isl_give isl_ast_node *isl_ast_node_if_get_then(
5593 __isl_keep isl_ast_node *node);
5594 int isl_ast_node_if_has_else(
5595 __isl_keep isl_ast_node *node);
5596 __isl_give isl_ast_node *isl_ast_node_if_get_else(
5597 __isl_keep isl_ast_node *node);
5599 __isl_give isl_ast_node_list *
5600 isl_ast_node_block_get_children(
5601 __isl_keep isl_ast_node *node);
5603 __isl_give isl_ast_expr *isl_ast_node_user_get_expr(
5604 __isl_keep isl_ast_node *node);
5606 Each of the returned C<isl_ast_expr>s can in turn be inspected using
5607 the following functions.
5609 #include <isl/ast.h>
5610 isl_ctx *isl_ast_expr_get_ctx(
5611 __isl_keep isl_ast_expr *expr);
5612 enum isl_ast_expr_type isl_ast_expr_get_type(
5613 __isl_keep isl_ast_expr *expr);
5615 The type of an AST expression is one of
5617 C<isl_ast_expr_id> or
5618 C<isl_ast_expr_int>.
5619 An C<isl_ast_expr_op> represents the result of an operation.
5620 An C<isl_ast_expr_id> represents an identifier.
5621 An C<isl_ast_expr_int> represents an integer value.
5623 Each type of expression has its own additional properties.
5625 #include <isl/ast.h>
5626 enum isl_ast_op_type isl_ast_expr_get_op_type(
5627 __isl_keep isl_ast_expr *expr);
5628 int isl_ast_expr_get_op_n_arg(__isl_keep isl_ast_expr *expr);
5629 __isl_give isl_ast_expr *isl_ast_expr_get_op_arg(
5630 __isl_keep isl_ast_expr *expr, int pos);
5631 int isl_ast_node_foreach_ast_op_type(
5632 __isl_keep isl_ast_node *node,
5633 int (*fn)(enum isl_ast_op_type type, void *user),
5636 C<isl_ast_expr_get_op_type> returns the type of the operation
5637 performed. C<isl_ast_expr_get_op_n_arg> returns the number of
5638 arguments. C<isl_ast_expr_get_op_arg> returns the specified
5640 C<isl_ast_node_foreach_ast_op_type> calls C<fn> for each distinct
5641 C<isl_ast_op_type> that appears in C<node>.
5642 The operation type is one of the following.
5646 =item C<isl_ast_op_and>
5648 Logical I<and> of two arguments.
5649 Both arguments can be evaluated.
5651 =item C<isl_ast_op_and_then>
5653 Logical I<and> of two arguments.
5654 The second argument can only be evaluated if the first evaluates to true.
5656 =item C<isl_ast_op_or>
5658 Logical I<or> of two arguments.
5659 Both arguments can be evaluated.
5661 =item C<isl_ast_op_or_else>
5663 Logical I<or> of two arguments.
5664 The second argument can only be evaluated if the first evaluates to false.
5666 =item C<isl_ast_op_max>
5668 Maximum of two or more arguments.
5670 =item C<isl_ast_op_min>
5672 Minimum of two or more arguments.
5674 =item C<isl_ast_op_minus>
5678 =item C<isl_ast_op_add>
5680 Sum of two arguments.
5682 =item C<isl_ast_op_sub>
5684 Difference of two arguments.
5686 =item C<isl_ast_op_mul>
5688 Product of two arguments.
5690 =item C<isl_ast_op_div>
5692 Exact division. That is, the result is known to be an integer.
5694 =item C<isl_ast_op_fdiv_q>
5696 Result of integer division, rounded towards negative
5699 =item C<isl_ast_op_pdiv_q>
5701 Result of integer division, where dividend is known to be non-negative.
5703 =item C<isl_ast_op_pdiv_r>
5705 Remainder of integer division, where dividend is known to be non-negative.
5707 =item C<isl_ast_op_cond>
5709 Conditional operator defined on three arguments.
5710 If the first argument evaluates to true, then the result
5711 is equal to the second argument. Otherwise, the result
5712 is equal to the third argument.
5713 The second and third argument may only be evaluated if
5714 the first argument evaluates to true and false, respectively.
5715 Corresponds to C<a ? b : c> in C.
5717 =item C<isl_ast_op_select>
5719 Conditional operator defined on three arguments.
5720 If the first argument evaluates to true, then the result
5721 is equal to the second argument. Otherwise, the result
5722 is equal to the third argument.
5723 The second and third argument may be evaluated independently
5724 of the value of the first argument.
5725 Corresponds to C<a * b + (1 - a) * c> in C.
5727 =item C<isl_ast_op_eq>
5731 =item C<isl_ast_op_le>
5733 Less than or equal relation.
5735 =item C<isl_ast_op_lt>
5739 =item C<isl_ast_op_ge>
5741 Greater than or equal relation.
5743 =item C<isl_ast_op_gt>
5745 Greater than relation.
5747 =item C<isl_ast_op_call>
5750 The number of arguments of the C<isl_ast_expr> is one more than
5751 the number of arguments in the function call, the first argument
5752 representing the function being called.
5756 #include <isl/ast.h>
5757 __isl_give isl_id *isl_ast_expr_get_id(
5758 __isl_keep isl_ast_expr *expr);
5760 Return the identifier represented by the AST expression.
5762 #include <isl/ast.h>
5763 __isl_give isl_val *isl_ast_expr_get_val(
5764 __isl_keep isl_ast_expr *expr);
5766 Return the integer represented by the AST expression.
5768 =head3 Manipulating and printing the AST
5770 AST nodes can be copied and freed using the following functions.
5772 #include <isl/ast.h>
5773 __isl_give isl_ast_node *isl_ast_node_copy(
5774 __isl_keep isl_ast_node *node);
5775 void *isl_ast_node_free(__isl_take isl_ast_node *node);
5777 AST expressions can be copied and freed using the following functions.
5779 #include <isl/ast.h>
5780 __isl_give isl_ast_expr *isl_ast_expr_copy(
5781 __isl_keep isl_ast_expr *expr);
5782 void *isl_ast_expr_free(__isl_take isl_ast_expr *expr);
5784 New AST expressions can be created either directly or within
5785 the context of an C<isl_ast_build>.
5787 #include <isl/ast.h>
5788 __isl_give isl_ast_expr *isl_ast_expr_from_val(
5789 __isl_take isl_val *v);
5790 __isl_give isl_ast_expr *isl_ast_expr_from_id(
5791 __isl_take isl_id *id);
5792 __isl_give isl_ast_expr *isl_ast_expr_neg(
5793 __isl_take isl_ast_expr *expr);
5794 __isl_give isl_ast_expr *isl_ast_expr_add(
5795 __isl_take isl_ast_expr *expr1,
5796 __isl_take isl_ast_expr *expr2);
5797 __isl_give isl_ast_expr *isl_ast_expr_sub(
5798 __isl_take isl_ast_expr *expr1,
5799 __isl_take isl_ast_expr *expr2);
5800 __isl_give isl_ast_expr *isl_ast_expr_mul(
5801 __isl_take isl_ast_expr *expr1,
5802 __isl_take isl_ast_expr *expr2);
5803 __isl_give isl_ast_expr *isl_ast_expr_div(
5804 __isl_take isl_ast_expr *expr1,
5805 __isl_take isl_ast_expr *expr2);
5806 __isl_give isl_ast_expr *isl_ast_expr_and(
5807 __isl_take isl_ast_expr *expr1,
5808 __isl_take isl_ast_expr *expr2)
5809 __isl_give isl_ast_expr *isl_ast_expr_or(
5810 __isl_take isl_ast_expr *expr1,
5811 __isl_take isl_ast_expr *expr2)
5813 #include <isl/ast_build.h>
5814 __isl_give isl_ast_expr *isl_ast_build_expr_from_pw_aff(
5815 __isl_keep isl_ast_build *build,
5816 __isl_take isl_pw_aff *pa);
5817 __isl_give isl_ast_expr *
5818 isl_ast_build_call_from_pw_multi_aff(
5819 __isl_keep isl_ast_build *build,
5820 __isl_take isl_pw_multi_aff *pma);
5822 The domains of C<pa> and C<pma> should correspond
5823 to the schedule space of C<build>.
5824 The tuple id of C<pma> is used as the function being called.
5826 User specified data can be attached to an C<isl_ast_node> and obtained
5827 from the same C<isl_ast_node> using the following functions.
5829 #include <isl/ast.h>
5830 __isl_give isl_ast_node *isl_ast_node_set_annotation(
5831 __isl_take isl_ast_node *node,
5832 __isl_take isl_id *annotation);
5833 __isl_give isl_id *isl_ast_node_get_annotation(
5834 __isl_keep isl_ast_node *node);
5836 Basic printing can be performed using the following functions.
5838 #include <isl/ast.h>
5839 __isl_give isl_printer *isl_printer_print_ast_expr(
5840 __isl_take isl_printer *p,
5841 __isl_keep isl_ast_expr *expr);
5842 __isl_give isl_printer *isl_printer_print_ast_node(
5843 __isl_take isl_printer *p,
5844 __isl_keep isl_ast_node *node);
5846 More advanced printing can be performed using the following functions.
5848 #include <isl/ast.h>
5849 __isl_give isl_printer *isl_ast_op_type_print_macro(
5850 enum isl_ast_op_type type,
5851 __isl_take isl_printer *p);
5852 __isl_give isl_printer *isl_ast_node_print_macros(
5853 __isl_keep isl_ast_node *node,
5854 __isl_take isl_printer *p);
5855 __isl_give isl_printer *isl_ast_node_print(
5856 __isl_keep isl_ast_node *node,
5857 __isl_take isl_printer *p,
5858 __isl_take isl_ast_print_options *options);
5859 __isl_give isl_printer *isl_ast_node_for_print(
5860 __isl_keep isl_ast_node *node,
5861 __isl_take isl_printer *p,
5862 __isl_take isl_ast_print_options *options);
5863 __isl_give isl_printer *isl_ast_node_if_print(
5864 __isl_keep isl_ast_node *node,
5865 __isl_take isl_printer *p,
5866 __isl_take isl_ast_print_options *options);
5868 While printing an C<isl_ast_node> in C<ISL_FORMAT_C>,
5869 C<isl> may print out an AST that makes use of macros such
5870 as C<floord>, C<min> and C<max>.
5871 C<isl_ast_op_type_print_macro> prints out the macro
5872 corresponding to a specific C<isl_ast_op_type>.
5873 C<isl_ast_node_print_macros> scans the C<isl_ast_node>
5874 for expressions where these macros would be used and prints
5875 out the required macro definitions.
5876 Essentially, C<isl_ast_node_print_macros> calls
5877 C<isl_ast_node_foreach_ast_op_type> with C<isl_ast_op_type_print_macro>
5878 as function argument.
5879 C<isl_ast_node_print>, C<isl_ast_node_for_print> and
5880 C<isl_ast_node_if_print> print an C<isl_ast_node>
5881 in C<ISL_FORMAT_C>, but allow for some extra control
5882 through an C<isl_ast_print_options> object.
5883 This object can be created using the following functions.
5885 #include <isl/ast.h>
5886 __isl_give isl_ast_print_options *
5887 isl_ast_print_options_alloc(isl_ctx *ctx);
5888 __isl_give isl_ast_print_options *
5889 isl_ast_print_options_copy(
5890 __isl_keep isl_ast_print_options *options);
5891 void *isl_ast_print_options_free(
5892 __isl_take isl_ast_print_options *options);
5894 __isl_give isl_ast_print_options *
5895 isl_ast_print_options_set_print_user(
5896 __isl_take isl_ast_print_options *options,
5897 __isl_give isl_printer *(*print_user)(
5898 __isl_take isl_printer *p,
5899 __isl_take isl_ast_print_options *options,
5900 __isl_keep isl_ast_node *node, void *user),
5902 __isl_give isl_ast_print_options *
5903 isl_ast_print_options_set_print_for(
5904 __isl_take isl_ast_print_options *options,
5905 __isl_give isl_printer *(*print_for)(
5906 __isl_take isl_printer *p,
5907 __isl_take isl_ast_print_options *options,
5908 __isl_keep isl_ast_node *node, void *user),
5911 The callback set by C<isl_ast_print_options_set_print_user>
5912 is called whenever a node of type C<isl_ast_node_user> needs to
5914 The callback set by C<isl_ast_print_options_set_print_for>
5915 is called whenever a node of type C<isl_ast_node_for> needs to
5917 Note that C<isl_ast_node_for_print> will I<not> call the
5918 callback set by C<isl_ast_print_options_set_print_for> on the node
5919 on which C<isl_ast_node_for_print> is called, but only on nested
5920 nodes of type C<isl_ast_node_for>. It is therefore safe to
5921 call C<isl_ast_node_for_print> from within the callback set by
5922 C<isl_ast_print_options_set_print_for>.
5924 The following option determines the type to be used for iterators
5925 while printing the AST.
5927 int isl_options_set_ast_iterator_type(
5928 isl_ctx *ctx, const char *val);
5929 const char *isl_options_get_ast_iterator_type(
5934 #include <isl/ast_build.h>
5935 int isl_options_set_ast_build_atomic_upper_bound(
5936 isl_ctx *ctx, int val);
5937 int isl_options_get_ast_build_atomic_upper_bound(
5939 int isl_options_set_ast_build_prefer_pdiv(isl_ctx *ctx,
5941 int isl_options_get_ast_build_prefer_pdiv(isl_ctx *ctx);
5942 int isl_options_set_ast_build_exploit_nested_bounds(
5943 isl_ctx *ctx, int val);
5944 int isl_options_get_ast_build_exploit_nested_bounds(
5946 int isl_options_set_ast_build_group_coscheduled(
5947 isl_ctx *ctx, int val);
5948 int isl_options_get_ast_build_group_coscheduled(
5950 int isl_options_set_ast_build_scale_strides(
5951 isl_ctx *ctx, int val);
5952 int isl_options_get_ast_build_scale_strides(
5954 int isl_options_set_ast_build_allow_else(isl_ctx *ctx,
5956 int isl_options_get_ast_build_allow_else(isl_ctx *ctx);
5957 int isl_options_set_ast_build_allow_or(isl_ctx *ctx,
5959 int isl_options_get_ast_build_allow_or(isl_ctx *ctx);
5963 =item * ast_build_atomic_upper_bound
5965 Generate loop upper bounds that consist of the current loop iterator,
5966 an operator and an expression not involving the iterator.
5967 If this option is not set, then the current loop iterator may appear
5968 several times in the upper bound.
5969 For example, when this option is turned off, AST generation
5972 [n] -> { A[i] -> [i] : 0 <= i <= 100, n }
5976 for (int c0 = 0; c0 <= 100 && n >= c0; c0 += 1)
5979 When the option is turned on, the following AST is generated
5981 for (int c0 = 0; c0 <= min(100, n); c0 += 1)
5984 =item * ast_build_prefer_pdiv
5986 If this option is turned off, then the AST generation will
5987 produce ASTs that may only contain C<isl_ast_op_fdiv_q>
5988 operators, but no C<isl_ast_op_pdiv_q> or
5989 C<isl_ast_op_pdiv_r> operators.
5990 If this options is turned on, then C<isl> will try to convert
5991 some of the C<isl_ast_op_fdiv_q> operators to (expressions containing)
5992 C<isl_ast_op_pdiv_q> or C<isl_ast_op_pdiv_r> operators.
5994 =item * ast_build_exploit_nested_bounds
5996 Simplify conditions based on bounds of nested for loops.
5997 In particular, remove conditions that are implied by the fact
5998 that one or more nested loops have at least one iteration,
5999 meaning that the upper bound is at least as large as the lower bound.
6000 For example, when this option is turned off, AST generation
6003 [N,M] -> { A[i,j] -> [i,j] : 0 <= i <= N and
6009 for (int c0 = 0; c0 <= N; c0 += 1)
6010 for (int c1 = 0; c1 <= M; c1 += 1)
6013 When the option is turned on, the following AST is generated
6015 for (int c0 = 0; c0 <= N; c0 += 1)
6016 for (int c1 = 0; c1 <= M; c1 += 1)
6019 =item * ast_build_group_coscheduled
6021 If two domain elements are assigned the same schedule point, then
6022 they may be executed in any order and they may even appear in different
6023 loops. If this options is set, then the AST generator will make
6024 sure that coscheduled domain elements do not appear in separate parts
6025 of the AST. This is useful in case of nested AST generation
6026 if the outer AST generation is given only part of a schedule
6027 and the inner AST generation should handle the domains that are
6028 coscheduled by this initial part of the schedule together.
6029 For example if an AST is generated for a schedule
6031 { A[i] -> [0]; B[i] -> [0] }
6033 then the C<isl_ast_build_set_create_leaf> callback described
6034 below may get called twice, once for each domain.
6035 Setting this option ensures that the callback is only called once
6036 on both domains together.
6038 =item * ast_build_separation_bounds
6040 This option specifies which bounds to use during separation.
6041 If this option is set to C<ISL_AST_BUILD_SEPARATION_BOUNDS_IMPLICIT>
6042 then all (possibly implicit) bounds on the current dimension will
6043 be used during separation.
6044 If this option is set to C<ISL_AST_BUILD_SEPARATION_BOUNDS_EXPLICIT>
6045 then only those bounds that are explicitly available will
6046 be used during separation.
6048 =item * ast_build_scale_strides
6050 This option specifies whether the AST generator is allowed
6051 to scale down iterators of strided loops.
6053 =item * ast_build_allow_else
6055 This option specifies whether the AST generator is allowed
6056 to construct if statements with else branches.
6058 =item * ast_build_allow_or
6060 This option specifies whether the AST generator is allowed
6061 to construct if conditions with disjunctions.
6065 =head3 Fine-grained Control over AST Generation
6067 Besides specifying the constraints on the parameters,
6068 an C<isl_ast_build> object can be used to control
6069 various aspects of the AST generation process.
6070 The most prominent way of control is through ``options'',
6071 which can be set using the following function.
6073 #include <isl/ast_build.h>
6074 __isl_give isl_ast_build *
6075 isl_ast_build_set_options(
6076 __isl_take isl_ast_build *control,
6077 __isl_take isl_union_map *options);
6079 The options are encoded in an <isl_union_map>.
6080 The domain of this union relation refers to the schedule domain,
6081 i.e., the range of the schedule passed to C<isl_ast_build_ast_from_schedule>.
6082 In the case of nested AST generation (see L</"Nested AST Generation">),
6083 the domain of C<options> should refer to the extra piece of the schedule.
6084 That is, it should be equal to the range of the wrapped relation in the
6085 range of the schedule.
6086 The range of the options can consist of elements in one or more spaces,
6087 the names of which determine the effect of the option.
6088 The values of the range typically also refer to the schedule dimension
6089 to which the option applies. In case of nested AST generation
6090 (see L</"Nested AST Generation">), these values refer to the position
6091 of the schedule dimension within the innermost AST generation.
6092 The constraints on the domain elements of
6093 the option should only refer to this dimension and earlier dimensions.
6094 We consider the following spaces.
6098 =item C<separation_class>
6100 This space is a wrapped relation between two one dimensional spaces.
6101 The input space represents the schedule dimension to which the option
6102 applies and the output space represents the separation class.
6103 While constructing a loop corresponding to the specified schedule
6104 dimension(s), the AST generator will try to generate separate loops
6105 for domain elements that are assigned different classes.
6106 If only some of the elements are assigned a class, then those elements
6107 that are not assigned any class will be treated as belonging to a class
6108 that is separate from the explicitly assigned classes.
6109 The typical use case for this option is to separate full tiles from
6111 The other options, described below, are applied after the separation
6114 As an example, consider the separation into full and partial tiles
6115 of a tiling of a triangular domain.
6116 Take, for example, the domain
6118 { A[i,j] : 0 <= i,j and i + j <= 100 }
6120 and a tiling into tiles of 10 by 10. The input to the AST generator
6121 is then the schedule
6123 { A[i,j] -> [([i/10]),[j/10],i,j] : 0 <= i,j and
6126 Without any options, the following AST is generated
6128 for (int c0 = 0; c0 <= 10; c0 += 1)
6129 for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
6130 for (int c2 = 10 * c0;
6131 c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
6133 for (int c3 = 10 * c1;
6134 c3 <= min(10 * c1 + 9, -c2 + 100);
6138 Separation into full and partial tiles can be obtained by assigning
6139 a class, say C<0>, to the full tiles. The full tiles are represented by those
6140 values of the first and second schedule dimensions for which there are
6141 values of the third and fourth dimensions to cover an entire tile.
6142 That is, we need to specify the following option
6144 { [a,b,c,d] -> separation_class[[0]->[0]] :
6145 exists b': 0 <= 10a,10b' and
6146 10a+9+10b'+9 <= 100;
6147 [a,b,c,d] -> separation_class[[1]->[0]] :
6148 0 <= 10a,10b and 10a+9+10b+9 <= 100 }
6152 { [a, b, c, d] -> separation_class[[1] -> [0]] :
6153 a >= 0 and b >= 0 and b <= 8 - a;
6154 [a, b, c, d] -> separation_class[[0] -> [0]] :
6157 With this option, the generated AST is as follows
6160 for (int c0 = 0; c0 <= 8; c0 += 1) {
6161 for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
6162 for (int c2 = 10 * c0;
6163 c2 <= 10 * c0 + 9; c2 += 1)
6164 for (int c3 = 10 * c1;
6165 c3 <= 10 * c1 + 9; c3 += 1)
6167 for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
6168 for (int c2 = 10 * c0;
6169 c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
6171 for (int c3 = 10 * c1;
6172 c3 <= min(-c2 + 100, 10 * c1 + 9);
6176 for (int c0 = 9; c0 <= 10; c0 += 1)
6177 for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
6178 for (int c2 = 10 * c0;
6179 c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
6181 for (int c3 = 10 * c1;
6182 c3 <= min(10 * c1 + 9, -c2 + 100);
6189 This is a single-dimensional space representing the schedule dimension(s)
6190 to which ``separation'' should be applied. Separation tries to split
6191 a loop into several pieces if this can avoid the generation of guards
6193 See also the C<atomic> option.
6197 This is a single-dimensional space representing the schedule dimension(s)
6198 for which the domains should be considered ``atomic''. That is, the
6199 AST generator will make sure that any given domain space will only appear
6200 in a single loop at the specified level.
6202 Consider the following schedule
6204 { a[i] -> [i] : 0 <= i < 10;
6205 b[i] -> [i+1] : 0 <= i < 10 }
6207 If the following option is specified
6209 { [i] -> separate[x] }
6211 then the following AST will be generated
6215 for (int c0 = 1; c0 <= 9; c0 += 1) {
6222 If, on the other hand, the following option is specified
6224 { [i] -> atomic[x] }
6226 then the following AST will be generated
6228 for (int c0 = 0; c0 <= 10; c0 += 1) {
6235 If neither C<atomic> nor C<separate> is specified, then the AST generator
6236 may produce either of these two results or some intermediate form.
6240 This is a single-dimensional space representing the schedule dimension(s)
6241 that should be I<completely> unrolled.
6242 To obtain a partial unrolling, the user should apply an additional
6243 strip-mining to the schedule and fully unroll the inner loop.
6247 Additional control is available through the following functions.
6249 #include <isl/ast_build.h>
6250 __isl_give isl_ast_build *
6251 isl_ast_build_set_iterators(
6252 __isl_take isl_ast_build *control,
6253 __isl_take isl_id_list *iterators);
6255 The function C<isl_ast_build_set_iterators> allows the user to
6256 specify a list of iterator C<isl_id>s to be used as iterators.
6257 If the input schedule is injective, then
6258 the number of elements in this list should be as large as the dimension
6259 of the schedule space, but no direct correspondence should be assumed
6260 between dimensions and elements.
6261 If the input schedule is not injective, then an additional number
6262 of C<isl_id>s equal to the largest dimension of the input domains
6264 If the number of provided C<isl_id>s is insufficient, then additional
6265 names are automatically generated.
6267 #include <isl/ast_build.h>
6268 __isl_give isl_ast_build *
6269 isl_ast_build_set_create_leaf(
6270 __isl_take isl_ast_build *control,
6271 __isl_give isl_ast_node *(*fn)(
6272 __isl_take isl_ast_build *build,
6273 void *user), void *user);
6276 C<isl_ast_build_set_create_leaf> function allows for the
6277 specification of a callback that should be called whenever the AST
6278 generator arrives at an element of the schedule domain.
6279 The callback should return an AST node that should be inserted
6280 at the corresponding position of the AST. The default action (when
6281 the callback is not set) is to continue generating parts of the AST to scan
6282 all the domain elements associated to the schedule domain element
6283 and to insert user nodes, ``calling'' the domain element, for each of them.
6284 The C<build> argument contains the current state of the C<isl_ast_build>.
6285 To ease nested AST generation (see L</"Nested AST Generation">),
6286 all control information that is
6287 specific to the current AST generation such as the options and
6288 the callbacks has been removed from this C<isl_ast_build>.
6289 The callback would typically return the result of a nested
6291 user defined node created using the following function.
6293 #include <isl/ast.h>
6294 __isl_give isl_ast_node *isl_ast_node_alloc_user(
6295 __isl_take isl_ast_expr *expr);
6297 #include <isl/ast_build.h>
6298 __isl_give isl_ast_build *
6299 isl_ast_build_set_at_each_domain(
6300 __isl_take isl_ast_build *build,
6301 __isl_give isl_ast_node *(*fn)(
6302 __isl_take isl_ast_node *node,
6303 __isl_keep isl_ast_build *build,
6304 void *user), void *user);
6305 __isl_give isl_ast_build *
6306 isl_ast_build_set_before_each_for(
6307 __isl_take isl_ast_build *build,
6308 __isl_give isl_id *(*fn)(
6309 __isl_keep isl_ast_build *build,
6310 void *user), void *user);
6311 __isl_give isl_ast_build *
6312 isl_ast_build_set_after_each_for(
6313 __isl_take isl_ast_build *build,
6314 __isl_give isl_ast_node *(*fn)(
6315 __isl_take isl_ast_node *node,
6316 __isl_keep isl_ast_build *build,
6317 void *user), void *user);
6319 The callback set by C<isl_ast_build_set_at_each_domain> will
6320 be called for each domain AST node.
6321 The callbacks set by C<isl_ast_build_set_before_each_for>
6322 and C<isl_ast_build_set_after_each_for> will be called
6323 for each for AST node. The first will be called in depth-first
6324 pre-order, while the second will be called in depth-first post-order.
6325 Since C<isl_ast_build_set_before_each_for> is called before the for
6326 node is actually constructed, it is only passed an C<isl_ast_build>.
6327 The returned C<isl_id> will be added as an annotation (using
6328 C<isl_ast_node_set_annotation>) to the constructed for node.
6329 In particular, if the user has also specified an C<after_each_for>
6330 callback, then the annotation can be retrieved from the node passed to
6331 that callback using C<isl_ast_node_get_annotation>.
6332 All callbacks should C<NULL> on failure.
6333 The given C<isl_ast_build> can be used to create new
6334 C<isl_ast_expr> objects using C<isl_ast_build_expr_from_pw_aff>
6335 or C<isl_ast_build_call_from_pw_multi_aff>.
6337 =head3 Nested AST Generation
6339 C<isl> allows the user to create an AST within the context
6340 of another AST. These nested ASTs are created using the
6341 same C<isl_ast_build_ast_from_schedule> function that is used to create the
6342 outer AST. The C<build> argument should be an C<isl_ast_build>
6343 passed to a callback set by
6344 C<isl_ast_build_set_create_leaf>.
6345 The space of the range of the C<schedule> argument should refer
6346 to this build. In particular, the space should be a wrapped
6347 relation and the domain of this wrapped relation should be the
6348 same as that of the range of the schedule returned by
6349 C<isl_ast_build_get_schedule> below.
6350 In practice, the new schedule is typically
6351 created by calling C<isl_union_map_range_product> on the old schedule
6352 and some extra piece of the schedule.
6353 The space of the schedule domain is also available from
6354 the C<isl_ast_build>.
6356 #include <isl/ast_build.h>
6357 __isl_give isl_union_map *isl_ast_build_get_schedule(
6358 __isl_keep isl_ast_build *build);
6359 __isl_give isl_space *isl_ast_build_get_schedule_space(
6360 __isl_keep isl_ast_build *build);
6361 __isl_give isl_ast_build *isl_ast_build_restrict(
6362 __isl_take isl_ast_build *build,
6363 __isl_take isl_set *set);
6365 The C<isl_ast_build_get_schedule> function returns a (partial)
6366 schedule for the domains elements for which part of the AST still needs to
6367 be generated in the current build.
6368 In particular, the domain elements are mapped to those iterations of the loops
6369 enclosing the current point of the AST generation inside which
6370 the domain elements are executed.
6371 No direct correspondence between
6372 the input schedule and this schedule should be assumed.
6373 The space obtained from C<isl_ast_build_get_schedule_space> can be used
6374 to create a set for C<isl_ast_build_restrict> to intersect
6375 with the current build. In particular, the set passed to
6376 C<isl_ast_build_restrict> can have additional parameters.
6377 The ids of the set dimensions in the space returned by
6378 C<isl_ast_build_get_schedule_space> correspond to the
6379 iterators of the already generated loops.
6380 The user should not rely on the ids of the output dimensions
6381 of the relations in the union relation returned by
6382 C<isl_ast_build_get_schedule> having any particular value.
6386 Although C<isl> is mainly meant to be used as a library,
6387 it also contains some basic applications that use some
6388 of the functionality of C<isl>.
6389 The input may be specified in either the L<isl format>
6390 or the L<PolyLib format>.
6392 =head2 C<isl_polyhedron_sample>
6394 C<isl_polyhedron_sample> takes a polyhedron as input and prints
6395 an integer element of the polyhedron, if there is any.
6396 The first column in the output is the denominator and is always
6397 equal to 1. If the polyhedron contains no integer points,
6398 then a vector of length zero is printed.
6402 C<isl_pip> takes the same input as the C<example> program
6403 from the C<piplib> distribution, i.e., a set of constraints
6404 on the parameters, a line containing only -1 and finally a set
6405 of constraints on a parametric polyhedron.
6406 The coefficients of the parameters appear in the last columns
6407 (but before the final constant column).
6408 The output is the lexicographic minimum of the parametric polyhedron.
6409 As C<isl> currently does not have its own output format, the output
6410 is just a dump of the internal state.
6412 =head2 C<isl_polyhedron_minimize>
6414 C<isl_polyhedron_minimize> computes the minimum of some linear
6415 or affine objective function over the integer points in a polyhedron.
6416 If an affine objective function
6417 is given, then the constant should appear in the last column.
6419 =head2 C<isl_polytope_scan>
6421 Given a polytope, C<isl_polytope_scan> prints
6422 all integer points in the polytope.
6424 =head2 C<isl_codegen>
6426 Given a schedule, a context set and an options relation,
6427 C<isl_codegen> prints out an AST that scans the domain elements
6428 of the schedule in the order of their image(s) taking into account
6429 the constraints in the context set.