3 C<isl> is a thread-safe C library for manipulating
4 sets and relations of integer points bounded by affine constraints.
5 The descriptions of the sets and relations may involve
6 both parameters and existentially quantified variables.
7 All computations are performed in exact integer arithmetic
8 using C<GMP> or C<imath>.
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 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>.
197 =item * The function C<isl_band_member_is_zero_distance>
198 has been removed. Essentially the same functionality is available
199 through C<isl_band_member_is_coincident>, except that is requires
200 setting up coincidence constraints.
201 The option C<schedule_outer_zero_distance> has accordingly been
202 replaced by the option C<schedule_outer_coincidence>.
204 =item * The function C<isl_vertex_get_expr> has been changed
205 to return an C<isl_multi_aff> instead of a rational C<isl_basic_set>.
206 The function C<isl_vertex_get_domain> has been changed to return
207 a regular basic set, rather than a rational basic set.
211 =head3 Changes since isl-0.14
215 =item * Objects of type C<isl_union_pw_multi_aff> can no longer contain
216 two or more C<isl_pw_multi_aff> objects with the same domain space.
218 =item * The function C<isl_union_pw_multi_aff_add> now consistently
219 computes the sum on the shared definition domain.
220 The function C<isl_union_pw_multi_aff_union_add> has been added
221 to compute the sum on the union of definition domains.
222 The original behavior of C<isl_union_pw_multi_aff_add> was
223 confused and is no longer available.
225 =item * Band forests have been replaced by schedule trees.
227 =item * The function C<isl_union_map_compute_flow> has been
228 replaced by the function C<isl_union_access_info_compute_flow>.
229 Note that the may dependence relation returned by
230 C<isl_union_flow_get_may_dependence> is the union of
231 the two dependence relations returned by
232 C<isl_union_map_compute_flow>. Similarly for the no source relations.
233 The function C<isl_union_map_compute_flow> is still available
234 for backward compatibility, but it will be removed in the future.
236 =item * The function C<isl_basic_set_drop_constraint> has been
243 C<isl> is released under the MIT license.
247 Permission is hereby granted, free of charge, to any person obtaining a copy of
248 this software and associated documentation files (the "Software"), to deal in
249 the Software without restriction, including without limitation the rights to
250 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
251 of the Software, and to permit persons to whom the Software is furnished to do
252 so, subject to the following conditions:
254 The above copyright notice and this permission notice shall be included in all
255 copies or substantial portions of the Software.
257 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
258 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
259 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
260 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
261 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
262 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
267 Note that by default C<isl> requires C<GMP>, which is released
268 under the GNU Lesser General Public License (LGPL). This means
269 that code linked against C<isl> is also linked against LGPL code.
271 When configuring with C<--with-int=imath>, C<isl> will link against C<imath>, a
272 library for exact integer arithmetic released under the MIT license.
276 The source of C<isl> can be obtained either as a tarball
277 or from the git repository. Both are available from
278 L<http://freshmeat.net/projects/isl/>.
279 The installation process depends on how you obtained
282 =head2 Installation from the git repository
286 =item 1 Clone or update the repository
288 The first time the source is obtained, you need to clone
291 git clone git://repo.or.cz/isl.git
293 To obtain updates, you need to pull in the latest changes
297 =item 2 Optionally get C<imath> submodule
299 To build C<isl> with C<imath>, you need to obtain the C<imath>
300 submodule by running in the git source tree of C<isl>
305 This will fetch the required version of C<imath> in a subdirectory of C<isl>.
307 =item 2 Generate C<configure>
313 After performing the above steps, continue
314 with the L<Common installation instructions>.
316 =head2 Common installation instructions
320 =item 1 Obtain C<GMP>
322 By default, building C<isl> requires C<GMP>, including its headers files.
323 Your distribution may not provide these header files by default
324 and you may need to install a package called C<gmp-devel> or something
325 similar. Alternatively, C<GMP> can be built from
326 source, available from L<http://gmplib.org/>.
327 C<GMP> is not needed if you build C<isl> with C<imath>.
331 C<isl> uses the standard C<autoconf> C<configure> script.
336 optionally followed by some configure options.
337 A complete list of options can be obtained by running
341 Below we discuss some of the more common options.
347 Installation prefix for C<isl>
349 =item C<--with-int=[gmp|imath]>
351 Select the integer library to be used by C<isl>, the default is C<gmp>.
352 Note that C<isl> may run significantly slower if you use C<imath>.
354 =item C<--with-gmp-prefix>
356 Installation prefix for C<GMP> (architecture-independent files).
358 =item C<--with-gmp-exec-prefix>
360 Installation prefix for C<GMP> (architecture-dependent files).
368 =item 4 Install (optional)
374 =head1 Integer Set Library
376 =head2 Memory Management
378 Since a high-level operation on isl objects usually involves
379 several substeps and since the user is usually not interested in
380 the intermediate results, most functions that return a new object
381 will also release all the objects passed as arguments.
382 If the user still wants to use one or more of these arguments
383 after the function call, she should pass along a copy of the
384 object rather than the object itself.
385 The user is then responsible for making sure that the original
386 object gets used somewhere else or is explicitly freed.
388 The arguments and return values of all documented functions are
389 annotated to make clear which arguments are released and which
390 arguments are preserved. In particular, the following annotations
397 C<__isl_give> means that a new object is returned.
398 The user should make sure that the returned pointer is
399 used exactly once as a value for an C<__isl_take> argument.
400 In between, it can be used as a value for as many
401 C<__isl_keep> arguments as the user likes.
402 There is one exception, and that is the case where the
403 pointer returned is C<NULL>. Is this case, the user
404 is free to use it as an C<__isl_take> argument or not.
405 When applied to a C<char *>, the returned pointer needs to be
410 C<__isl_null> means that a C<NULL> value is returned.
414 C<__isl_take> means that the object the argument points to
415 is taken over by the function and may no longer be used
416 by the user as an argument to any other function.
417 The pointer value must be one returned by a function
418 returning an C<__isl_give> pointer.
419 If the user passes in a C<NULL> value, then this will
420 be treated as an error in the sense that the function will
421 not perform its usual operation. However, it will still
422 make sure that all the other C<__isl_take> arguments
427 C<__isl_keep> means that the function will only use the object
428 temporarily. After the function has finished, the user
429 can still use it as an argument to other functions.
430 A C<NULL> value will be treated in the same way as
431 a C<NULL> value for an C<__isl_take> argument.
432 This annotation may also be used on return values of
433 type C<const char *>, in which case the returned pointer should
434 not be freed by the user and is only valid until the object
435 from which it was derived is updated or freed.
439 =head2 Initialization
441 All manipulations of integer sets and relations occur within
442 the context of an C<isl_ctx>.
443 A given C<isl_ctx> can only be used within a single thread.
444 All arguments of a function are required to have been allocated
445 within the same context.
446 There are currently no functions available for moving an object
447 from one C<isl_ctx> to another C<isl_ctx>. This means that
448 there is currently no way of safely moving an object from one
449 thread to another, unless the whole C<isl_ctx> is moved.
451 An C<isl_ctx> can be allocated using C<isl_ctx_alloc> and
452 freed using C<isl_ctx_free>.
453 All objects allocated within an C<isl_ctx> should be freed
454 before the C<isl_ctx> itself is freed.
456 isl_ctx *isl_ctx_alloc();
457 void isl_ctx_free(isl_ctx *ctx);
459 The user can impose a bound on the number of low-level I<operations>
460 that can be performed by an C<isl_ctx>. This bound can be set and
461 retrieved using the following functions. A bound of zero means that
462 no bound is imposed. The number of operations performed can be
463 reset using C<isl_ctx_reset_operations>. Note that the number
464 of low-level operations needed to perform a high-level computation
465 may differ significantly across different versions
466 of C<isl>, but it should be the same across different platforms
467 for the same version of C<isl>.
469 Warning: This feature is experimental. C<isl> has good support to abort and
470 bail out during the computation, but this feature may exercise error code paths
471 that are normally not used that much. Consequently, it is not unlikely that
472 hidden bugs will be exposed.
474 void isl_ctx_set_max_operations(isl_ctx *ctx,
475 unsigned long max_operations);
476 unsigned long isl_ctx_get_max_operations(isl_ctx *ctx);
477 void isl_ctx_reset_operations(isl_ctx *ctx);
479 In order to be able to create an object in the same context
480 as another object, most object types (described later in
481 this document) provide a function to obtain the context
482 in which the object was created.
485 isl_ctx *isl_val_get_ctx(__isl_keep isl_val *val);
486 isl_ctx *isl_multi_val_get_ctx(
487 __isl_keep isl_multi_val *mv);
490 isl_ctx *isl_id_get_ctx(__isl_keep isl_id *id);
492 #include <isl/local_space.h>
493 isl_ctx *isl_local_space_get_ctx(
494 __isl_keep isl_local_space *ls);
497 isl_ctx *isl_set_list_get_ctx(
498 __isl_keep isl_set_list *list);
501 isl_ctx *isl_aff_get_ctx(__isl_keep isl_aff *aff);
502 isl_ctx *isl_multi_aff_get_ctx(
503 __isl_keep isl_multi_aff *maff);
504 isl_ctx *isl_pw_aff_get_ctx(__isl_keep isl_pw_aff *pa);
505 isl_ctx *isl_pw_multi_aff_get_ctx(
506 __isl_keep isl_pw_multi_aff *pma);
507 isl_ctx *isl_multi_pw_aff_get_ctx(
508 __isl_keep isl_multi_pw_aff *mpa);
509 isl_ctx *isl_union_pw_aff_get_ctx(
510 __isl_keep isl_union_pw_aff *upa);
511 isl_ctx *isl_union_pw_multi_aff_get_ctx(
512 __isl_keep isl_union_pw_multi_aff *upma);
513 isl_ctx *isl_multi_union_pw_aff_get_ctx(
514 __isl_keep isl_multi_union_pw_aff *mupa);
516 #include <isl/id_to_ast_expr.h>
517 isl_ctx *isl_id_to_ast_expr_get_ctx(
518 __isl_keep isl_id_to_ast_expr *id2expr);
520 #include <isl/point.h>
521 isl_ctx *isl_point_get_ctx(__isl_keep isl_point *pnt);
524 isl_ctx *isl_vec_get_ctx(__isl_keep isl_vec *vec);
527 isl_ctx *isl_mat_get_ctx(__isl_keep isl_mat *mat);
529 #include <isl/vertices.h>
530 isl_ctx *isl_vertices_get_ctx(
531 __isl_keep isl_vertices *vertices);
532 isl_ctx *isl_vertex_get_ctx(__isl_keep isl_vertex *vertex);
533 isl_ctx *isl_cell_get_ctx(__isl_keep isl_cell *cell);
535 #include <isl/flow.h>
536 isl_ctx *isl_restriction_get_ctx(
537 __isl_keep isl_restriction *restr);
539 #include <isl/schedule.h>
540 isl_ctx *isl_schedule_get_ctx(
541 __isl_keep isl_schedule *sched);
542 isl_ctx *isl_schedule_constraints_get_ctx(
543 __isl_keep isl_schedule_constraints *sc);
545 #include <isl/schedule_node.h>
546 isl_ctx *isl_schedule_node_get_ctx(
547 __isl_keep isl_schedule_node *node);
549 #include <isl/band.h>
550 isl_ctx *isl_band_get_ctx(__isl_keep isl_band *band);
552 #include <isl/ast_build.h>
553 isl_ctx *isl_ast_build_get_ctx(
554 __isl_keep isl_ast_build *build);
557 isl_ctx *isl_ast_expr_get_ctx(
558 __isl_keep isl_ast_expr *expr);
559 isl_ctx *isl_ast_node_get_ctx(
560 __isl_keep isl_ast_node *node);
564 An C<isl_val> represents an integer value, a rational value
565 or one of three special values, infinity, negative infinity and NaN.
566 Some predefined values can be created using the following functions.
569 __isl_give isl_val *isl_val_zero(isl_ctx *ctx);
570 __isl_give isl_val *isl_val_one(isl_ctx *ctx);
571 __isl_give isl_val *isl_val_negone(isl_ctx *ctx);
572 __isl_give isl_val *isl_val_nan(isl_ctx *ctx);
573 __isl_give isl_val *isl_val_infty(isl_ctx *ctx);
574 __isl_give isl_val *isl_val_neginfty(isl_ctx *ctx);
576 Specific integer values can be created using the following functions.
579 __isl_give isl_val *isl_val_int_from_si(isl_ctx *ctx,
581 __isl_give isl_val *isl_val_int_from_ui(isl_ctx *ctx,
583 __isl_give isl_val *isl_val_int_from_chunks(isl_ctx *ctx,
584 size_t n, size_t size, const void *chunks);
586 The function C<isl_val_int_from_chunks> constructs an C<isl_val>
587 from the C<n> I<digits>, each consisting of C<size> bytes, stored at C<chunks>.
588 The least significant digit is assumed to be stored first.
590 Value objects can be copied and freed using the following functions.
593 __isl_give isl_val *isl_val_copy(__isl_keep isl_val *v);
594 __isl_null isl_val *isl_val_free(__isl_take isl_val *v);
596 They can be inspected using the following functions.
599 long isl_val_get_num_si(__isl_keep isl_val *v);
600 long isl_val_get_den_si(__isl_keep isl_val *v);
601 double isl_val_get_d(__isl_keep isl_val *v);
602 size_t isl_val_n_abs_num_chunks(__isl_keep isl_val *v,
604 int isl_val_get_abs_num_chunks(__isl_keep isl_val *v,
605 size_t size, void *chunks);
607 C<isl_val_n_abs_num_chunks> returns the number of I<digits>
608 of C<size> bytes needed to store the absolute value of the
610 C<isl_val_get_abs_num_chunks> stores these digits at C<chunks>,
611 which is assumed to have been preallocated by the caller.
612 The least significant digit is stored first.
613 Note that C<isl_val_get_num_si>, C<isl_val_get_den_si>,
614 C<isl_val_get_d>, C<isl_val_n_abs_num_chunks>
615 and C<isl_val_get_abs_num_chunks> can only be applied to rational values.
617 An C<isl_val> can be modified using the following function.
620 __isl_give isl_val *isl_val_set_si(__isl_take isl_val *v,
623 The following unary properties are defined on C<isl_val>s.
626 int isl_val_sgn(__isl_keep isl_val *v);
627 int isl_val_is_zero(__isl_keep isl_val *v);
628 int isl_val_is_one(__isl_keep isl_val *v);
629 int isl_val_is_negone(__isl_keep isl_val *v);
630 int isl_val_is_nonneg(__isl_keep isl_val *v);
631 int isl_val_is_nonpos(__isl_keep isl_val *v);
632 int isl_val_is_pos(__isl_keep isl_val *v);
633 int isl_val_is_neg(__isl_keep isl_val *v);
634 int isl_val_is_int(__isl_keep isl_val *v);
635 int isl_val_is_rat(__isl_keep isl_val *v);
636 int isl_val_is_nan(__isl_keep isl_val *v);
637 int isl_val_is_infty(__isl_keep isl_val *v);
638 int isl_val_is_neginfty(__isl_keep isl_val *v);
640 Note that the sign of NaN is undefined.
642 The following binary properties are defined on pairs of C<isl_val>s.
645 int isl_val_lt(__isl_keep isl_val *v1,
646 __isl_keep isl_val *v2);
647 int isl_val_le(__isl_keep isl_val *v1,
648 __isl_keep isl_val *v2);
649 int isl_val_gt(__isl_keep isl_val *v1,
650 __isl_keep isl_val *v2);
651 int isl_val_ge(__isl_keep isl_val *v1,
652 __isl_keep isl_val *v2);
653 int isl_val_eq(__isl_keep isl_val *v1,
654 __isl_keep isl_val *v2);
655 int isl_val_ne(__isl_keep isl_val *v1,
656 __isl_keep isl_val *v2);
657 int isl_val_abs_eq(__isl_keep isl_val *v1,
658 __isl_keep isl_val *v2);
660 The function C<isl_val_abs_eq> checks whether its two arguments
661 are equal in absolute value.
663 For integer C<isl_val>s we additionally have the following binary property.
666 int isl_val_is_divisible_by(__isl_keep isl_val *v1,
667 __isl_keep isl_val *v2);
669 An C<isl_val> can also be compared to an integer using the following
670 function. The result is undefined for NaN.
673 int isl_val_cmp_si(__isl_keep isl_val *v, long i);
675 The following unary operations are available on C<isl_val>s.
678 __isl_give isl_val *isl_val_abs(__isl_take isl_val *v);
679 __isl_give isl_val *isl_val_neg(__isl_take isl_val *v);
680 __isl_give isl_val *isl_val_floor(__isl_take isl_val *v);
681 __isl_give isl_val *isl_val_ceil(__isl_take isl_val *v);
682 __isl_give isl_val *isl_val_trunc(__isl_take isl_val *v);
683 __isl_give isl_val *isl_val_inv(__isl_take isl_val *v);
684 __isl_give isl_val *isl_val_2exp(__isl_take isl_val *v);
686 The following binary operations are available on C<isl_val>s.
689 __isl_give isl_val *isl_val_min(__isl_take isl_val *v1,
690 __isl_take isl_val *v2);
691 __isl_give isl_val *isl_val_max(__isl_take isl_val *v1,
692 __isl_take isl_val *v2);
693 __isl_give isl_val *isl_val_add(__isl_take isl_val *v1,
694 __isl_take isl_val *v2);
695 __isl_give isl_val *isl_val_add_ui(__isl_take isl_val *v1,
697 __isl_give isl_val *isl_val_sub(__isl_take isl_val *v1,
698 __isl_take isl_val *v2);
699 __isl_give isl_val *isl_val_sub_ui(__isl_take isl_val *v1,
701 __isl_give isl_val *isl_val_mul(__isl_take isl_val *v1,
702 __isl_take isl_val *v2);
703 __isl_give isl_val *isl_val_mul_ui(__isl_take isl_val *v1,
705 __isl_give isl_val *isl_val_div(__isl_take isl_val *v1,
706 __isl_take isl_val *v2);
708 On integer values, we additionally have the following operations.
711 __isl_give isl_val *isl_val_2exp(__isl_take isl_val *v);
712 __isl_give isl_val *isl_val_mod(__isl_take isl_val *v1,
713 __isl_take isl_val *v2);
714 __isl_give isl_val *isl_val_gcd(__isl_take isl_val *v1,
715 __isl_take isl_val *v2);
716 __isl_give isl_val *isl_val_gcdext(__isl_take isl_val *v1,
717 __isl_take isl_val *v2, __isl_give isl_val **x,
718 __isl_give isl_val **y);
720 The function C<isl_val_gcdext> returns the greatest common divisor g
721 of C<v1> and C<v2> as well as two integers C<*x> and C<*y> such
722 that C<*x> * C<v1> + C<*y> * C<v2> = g.
724 =head3 GMP specific functions
726 These functions are only available if C<isl> has been compiled with C<GMP>
729 Specific integer and rational values can be created from C<GMP> values using
730 the following functions.
732 #include <isl/val_gmp.h>
733 __isl_give isl_val *isl_val_int_from_gmp(isl_ctx *ctx,
735 __isl_give isl_val *isl_val_from_gmp(isl_ctx *ctx,
736 const mpz_t n, const mpz_t d);
738 The numerator and denominator of a rational value can be extracted as
739 C<GMP> values using the following functions.
741 #include <isl/val_gmp.h>
742 int isl_val_get_num_gmp(__isl_keep isl_val *v, mpz_t z);
743 int isl_val_get_den_gmp(__isl_keep isl_val *v, mpz_t z);
745 =head2 Sets and Relations
747 C<isl> uses six types of objects for representing sets and relations,
748 C<isl_basic_set>, C<isl_basic_map>, C<isl_set>, C<isl_map>,
749 C<isl_union_set> and C<isl_union_map>.
750 C<isl_basic_set> and C<isl_basic_map> represent sets and relations that
751 can be described as a conjunction of affine constraints, while
752 C<isl_set> and C<isl_map> represent unions of
753 C<isl_basic_set>s and C<isl_basic_map>s, respectively.
754 However, all C<isl_basic_set>s or C<isl_basic_map>s in the union need
755 to live in the same space. C<isl_union_set>s and C<isl_union_map>s
756 represent unions of C<isl_set>s or C<isl_map>s in I<different> spaces,
757 where spaces are considered different if they have a different number
758 of dimensions and/or different names (see L<"Spaces">).
759 The difference between sets and relations (maps) is that sets have
760 one set of variables, while relations have two sets of variables,
761 input variables and output variables.
763 =head2 Error Handling
765 C<isl> supports different ways to react in case a runtime error is triggered.
766 Runtime errors arise, e.g., if a function such as C<isl_map_intersect> is called
767 with two maps that have incompatible spaces. There are three possible ways
768 to react on error: to warn, to continue or to abort.
770 The default behavior is to warn. In this mode, C<isl> prints a warning, stores
771 the last error in the corresponding C<isl_ctx> and the function in which the
772 error was triggered returns C<NULL>. An error does not corrupt internal state,
773 such that isl can continue to be used. C<isl> also provides functions to
774 read the last error and to reset the memory that stores the last error. The
775 last error is only stored for information purposes. Its presence does not
776 change the behavior of C<isl>. Hence, resetting an error is not required to
777 continue to use isl, but only to observe new errors.
780 enum isl_error isl_ctx_last_error(isl_ctx *ctx);
781 void isl_ctx_reset_error(isl_ctx *ctx);
783 Another option is to continue on error. This is similar to warn on error mode,
784 except that C<isl> does not print any warning. This allows a program to
785 implement its own error reporting.
787 The last option is to directly abort the execution of the program from within
788 the isl library. This makes it obviously impossible to recover from an error,
789 but it allows to directly spot the error location. By aborting on error,
790 debuggers break at the location the error occurred and can provide a stack
791 trace. Other tools that automatically provide stack traces on abort or that do
792 not want to continue execution after an error was triggered may also prefer to
795 The on error behavior of isl can be specified by calling
796 C<isl_options_set_on_error> or by setting the command line option
797 C<--isl-on-error>. Valid arguments for the function call are
798 C<ISL_ON_ERROR_WARN>, C<ISL_ON_ERROR_CONTINUE> and C<ISL_ON_ERROR_ABORT>. The
799 choices for the command line option are C<warn>, C<continue> and C<abort>.
800 It is also possible to query the current error mode.
802 #include <isl/options.h>
803 int isl_options_set_on_error(isl_ctx *ctx, int val);
804 int isl_options_get_on_error(isl_ctx *ctx);
808 Identifiers are used to identify both individual dimensions
809 and tuples of dimensions. They consist of an optional name and an optional
810 user pointer. The name and the user pointer cannot both be C<NULL>, however.
811 Identifiers with the same name but different pointer values
812 are considered to be distinct.
813 Similarly, identifiers with different names but the same pointer value
814 are also considered to be distinct.
815 Equal identifiers are represented using the same object.
816 Pairs of identifiers can therefore be tested for equality using the
818 Identifiers can be constructed, copied, freed, inspected and printed
819 using the following functions.
822 __isl_give isl_id *isl_id_alloc(isl_ctx *ctx,
823 __isl_keep const char *name, void *user);
824 __isl_give isl_id *isl_id_set_free_user(
825 __isl_take isl_id *id,
826 __isl_give void (*free_user)(void *user));
827 __isl_give isl_id *isl_id_copy(isl_id *id);
828 __isl_null isl_id *isl_id_free(__isl_take isl_id *id);
830 void *isl_id_get_user(__isl_keep isl_id *id);
831 __isl_keep const char *isl_id_get_name(__isl_keep isl_id *id);
833 __isl_give isl_printer *isl_printer_print_id(
834 __isl_take isl_printer *p, __isl_keep isl_id *id);
836 The callback set by C<isl_id_set_free_user> is called on the user
837 pointer when the last reference to the C<isl_id> is freed.
838 Note that C<isl_id_get_name> returns a pointer to some internal
839 data structure, so the result can only be used while the
840 corresponding C<isl_id> is alive.
844 Whenever a new set, relation or similar object is created from scratch,
845 the space in which it lives needs to be specified using an C<isl_space>.
846 Each space involves zero or more parameters and zero, one or two
847 tuples of set or input/output dimensions. The parameters and dimensions
848 are identified by an C<isl_dim_type> and a position.
849 The type C<isl_dim_param> refers to parameters,
850 the type C<isl_dim_set> refers to set dimensions (for spaces
851 with a single tuple of dimensions) and the types C<isl_dim_in>
852 and C<isl_dim_out> refer to input and output dimensions
853 (for spaces with two tuples of dimensions).
854 Local spaces (see L</"Local Spaces">) also contain dimensions
855 of type C<isl_dim_div>.
856 Note that parameters are only identified by their position within
857 a given object. Across different objects, parameters are (usually)
858 identified by their names or identifiers. Only unnamed parameters
859 are identified by their positions across objects. The use of unnamed
860 parameters is discouraged.
862 #include <isl/space.h>
863 __isl_give isl_space *isl_space_alloc(isl_ctx *ctx,
864 unsigned nparam, unsigned n_in, unsigned n_out);
865 __isl_give isl_space *isl_space_params_alloc(isl_ctx *ctx,
867 __isl_give isl_space *isl_space_set_alloc(isl_ctx *ctx,
868 unsigned nparam, unsigned dim);
869 __isl_give isl_space *isl_space_copy(__isl_keep isl_space *space);
870 __isl_null isl_space *isl_space_free(__isl_take isl_space *space);
872 The space used for creating a parameter domain
873 needs to be created using C<isl_space_params_alloc>.
874 For other sets, the space
875 needs to be created using C<isl_space_set_alloc>, while
876 for a relation, the space
877 needs to be created using C<isl_space_alloc>.
879 To check whether a given space is that of a set or a map
880 or whether it is a parameter space, use these functions:
882 #include <isl/space.h>
883 int isl_space_is_params(__isl_keep isl_space *space);
884 int isl_space_is_set(__isl_keep isl_space *space);
885 int isl_space_is_map(__isl_keep isl_space *space);
887 Spaces can be compared using the following functions:
889 #include <isl/space.h>
890 int isl_space_is_equal(__isl_keep isl_space *space1,
891 __isl_keep isl_space *space2);
892 int isl_space_is_domain(__isl_keep isl_space *space1,
893 __isl_keep isl_space *space2);
894 int isl_space_is_range(__isl_keep isl_space *space1,
895 __isl_keep isl_space *space2);
896 int isl_space_tuple_is_equal(
897 __isl_keep isl_space *space1,
898 enum isl_dim_type type1,
899 __isl_keep isl_space *space2,
900 enum isl_dim_type type2);
902 C<isl_space_is_domain> checks whether the first argument is equal
903 to the domain of the second argument. This requires in particular that
904 the first argument is a set space and that the second argument
905 is a map space. C<isl_space_tuple_is_equal> checks whether the given
906 tuples (C<isl_dim_in>, C<isl_dim_out> or C<isl_dim_set>) of the given
907 spaces are the same. That is, it checks if they have the same
908 identifier (if any), the same dimension and the same internal structure
911 It is often useful to create objects that live in the
912 same space as some other object. This can be accomplished
913 by creating the new objects
914 (see L</"Creating New Sets and Relations"> or
915 L</"Functions">) based on the space
916 of the original object.
919 __isl_give isl_space *isl_basic_set_get_space(
920 __isl_keep isl_basic_set *bset);
921 __isl_give isl_space *isl_set_get_space(__isl_keep isl_set *set);
923 #include <isl/union_set.h>
924 __isl_give isl_space *isl_union_set_get_space(
925 __isl_keep isl_union_set *uset);
928 __isl_give isl_space *isl_basic_map_get_space(
929 __isl_keep isl_basic_map *bmap);
930 __isl_give isl_space *isl_map_get_space(__isl_keep isl_map *map);
932 #include <isl/union_map.h>
933 __isl_give isl_space *isl_union_map_get_space(
934 __isl_keep isl_union_map *umap);
936 #include <isl/constraint.h>
937 __isl_give isl_space *isl_constraint_get_space(
938 __isl_keep isl_constraint *constraint);
940 #include <isl/polynomial.h>
941 __isl_give isl_space *isl_qpolynomial_get_domain_space(
942 __isl_keep isl_qpolynomial *qp);
943 __isl_give isl_space *isl_qpolynomial_get_space(
944 __isl_keep isl_qpolynomial *qp);
945 __isl_give isl_space *isl_qpolynomial_fold_get_space(
946 __isl_keep isl_qpolynomial_fold *fold);
947 __isl_give isl_space *isl_pw_qpolynomial_get_domain_space(
948 __isl_keep isl_pw_qpolynomial *pwqp);
949 __isl_give isl_space *isl_pw_qpolynomial_get_space(
950 __isl_keep isl_pw_qpolynomial *pwqp);
951 __isl_give isl_space *isl_pw_qpolynomial_fold_get_domain_space(
952 __isl_keep isl_pw_qpolynomial_fold *pwf);
953 __isl_give isl_space *isl_pw_qpolynomial_fold_get_space(
954 __isl_keep isl_pw_qpolynomial_fold *pwf);
955 __isl_give isl_space *isl_union_pw_qpolynomial_get_space(
956 __isl_keep isl_union_pw_qpolynomial *upwqp);
957 __isl_give isl_space *isl_union_pw_qpolynomial_fold_get_space(
958 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
961 __isl_give isl_space *isl_multi_val_get_space(
962 __isl_keep isl_multi_val *mv);
965 __isl_give isl_space *isl_aff_get_domain_space(
966 __isl_keep isl_aff *aff);
967 __isl_give isl_space *isl_aff_get_space(
968 __isl_keep isl_aff *aff);
969 __isl_give isl_space *isl_pw_aff_get_domain_space(
970 __isl_keep isl_pw_aff *pwaff);
971 __isl_give isl_space *isl_pw_aff_get_space(
972 __isl_keep isl_pw_aff *pwaff);
973 __isl_give isl_space *isl_multi_aff_get_domain_space(
974 __isl_keep isl_multi_aff *maff);
975 __isl_give isl_space *isl_multi_aff_get_space(
976 __isl_keep isl_multi_aff *maff);
977 __isl_give isl_space *isl_pw_multi_aff_get_domain_space(
978 __isl_keep isl_pw_multi_aff *pma);
979 __isl_give isl_space *isl_pw_multi_aff_get_space(
980 __isl_keep isl_pw_multi_aff *pma);
981 __isl_give isl_space *isl_union_pw_aff_get_space(
982 __isl_keep isl_union_pw_aff *upa);
983 __isl_give isl_space *isl_union_pw_multi_aff_get_space(
984 __isl_keep isl_union_pw_multi_aff *upma);
985 __isl_give isl_space *isl_multi_pw_aff_get_domain_space(
986 __isl_keep isl_multi_pw_aff *mpa);
987 __isl_give isl_space *isl_multi_pw_aff_get_space(
988 __isl_keep isl_multi_pw_aff *mpa);
989 __isl_give isl_space *
990 isl_multi_union_pw_aff_get_domain_space(
991 __isl_keep isl_multi_union_pw_aff *mupa);
992 __isl_give isl_space *
993 isl_multi_union_pw_aff_get_space(
994 __isl_keep isl_multi_union_pw_aff *mupa);
996 #include <isl/point.h>
997 __isl_give isl_space *isl_point_get_space(
998 __isl_keep isl_point *pnt);
1000 The number of dimensions of a given type of space
1001 may be read off from a space or an object that lives
1002 in a space using the following functions.
1003 In case of C<isl_space_dim>, type may be
1004 C<isl_dim_param>, C<isl_dim_in> (only for relations),
1005 C<isl_dim_out> (only for relations), C<isl_dim_set>
1006 (only for sets) or C<isl_dim_all>.
1008 #include <isl/space.h>
1009 unsigned isl_space_dim(__isl_keep isl_space *space,
1010 enum isl_dim_type type);
1012 #include <isl/local_space.h>
1013 int isl_local_space_dim(__isl_keep isl_local_space *ls,
1014 enum isl_dim_type type);
1016 #include <isl/set.h>
1017 unsigned isl_basic_set_dim(__isl_keep isl_basic_set *bset,
1018 enum isl_dim_type type);
1019 unsigned isl_set_dim(__isl_keep isl_set *set,
1020 enum isl_dim_type type);
1022 #include <isl/union_set.h>
1023 unsigned isl_union_set_dim(__isl_keep isl_union_set *uset,
1024 enum isl_dim_type type);
1026 #include <isl/map.h>
1027 unsigned isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
1028 enum isl_dim_type type);
1029 unsigned isl_map_dim(__isl_keep isl_map *map,
1030 enum isl_dim_type type);
1032 #include <isl/union_map.h>
1033 unsigned isl_union_map_dim(__isl_keep isl_union_map *umap,
1034 enum isl_dim_type type);
1036 #include <isl/val.h>
1037 unsigned isl_multi_val_dim(__isl_keep isl_multi_val *mv,
1038 enum isl_dim_type type);
1040 #include <isl/aff.h>
1041 int isl_aff_dim(__isl_keep isl_aff *aff,
1042 enum isl_dim_type type);
1043 unsigned isl_multi_aff_dim(__isl_keep isl_multi_aff *maff,
1044 enum isl_dim_type type);
1045 unsigned isl_pw_aff_dim(__isl_keep isl_pw_aff *pwaff,
1046 enum isl_dim_type type);
1047 unsigned isl_pw_multi_aff_dim(
1048 __isl_keep isl_pw_multi_aff *pma,
1049 enum isl_dim_type type);
1050 unsigned isl_multi_pw_aff_dim(
1051 __isl_keep isl_multi_pw_aff *mpa,
1052 enum isl_dim_type type);
1053 unsigned isl_union_pw_aff_dim(
1054 __isl_keep isl_union_pw_aff *upa,
1055 enum isl_dim_type type);
1056 unsigned isl_union_pw_multi_aff_dim(
1057 __isl_keep isl_union_pw_multi_aff *upma,
1058 enum isl_dim_type type);
1059 unsigned isl_multi_union_pw_aff_dim(
1060 __isl_keep isl_multi_union_pw_aff *mupa,
1061 enum isl_dim_type type);
1063 #include <isl/polynomial.h>
1064 unsigned isl_union_pw_qpolynomial_dim(
1065 __isl_keep isl_union_pw_qpolynomial *upwqp,
1066 enum isl_dim_type type);
1067 unsigned isl_union_pw_qpolynomial_fold_dim(
1068 __isl_keep isl_union_pw_qpolynomial_fold *upwf,
1069 enum isl_dim_type type);
1071 Note that an C<isl_union_set>, an C<isl_union_map>,
1072 an C<isl_union_pw_multi_aff>,
1073 an C<isl_union_pw_qpolynomial> and
1074 an C<isl_union_pw_qpolynomial_fold>
1075 only have parameters.
1077 The identifiers or names of the individual dimensions of spaces
1078 may be set or read off using the following functions on spaces
1079 or objects that live in spaces.
1080 These functions are mostly useful to obtain the identifiers, positions
1081 or names of the parameters. Identifiers of individual dimensions are
1082 essentially only useful for printing. They are ignored by all other
1083 operations and may not be preserved across those operations.
1085 #include <isl/space.h>
1086 __isl_give isl_space *isl_space_set_dim_id(
1087 __isl_take isl_space *space,
1088 enum isl_dim_type type, unsigned pos,
1089 __isl_take isl_id *id);
1090 int isl_space_has_dim_id(__isl_keep isl_space *space,
1091 enum isl_dim_type type, unsigned pos);
1092 __isl_give isl_id *isl_space_get_dim_id(
1093 __isl_keep isl_space *space,
1094 enum isl_dim_type type, unsigned pos);
1095 __isl_give isl_space *isl_space_set_dim_name(
1096 __isl_take isl_space *space,
1097 enum isl_dim_type type, unsigned pos,
1098 __isl_keep const char *name);
1099 int isl_space_has_dim_name(__isl_keep isl_space *space,
1100 enum isl_dim_type type, unsigned pos);
1101 __isl_keep const char *isl_space_get_dim_name(
1102 __isl_keep isl_space *space,
1103 enum isl_dim_type type, unsigned pos);
1105 #include <isl/local_space.h>
1106 __isl_give isl_local_space *isl_local_space_set_dim_id(
1107 __isl_take isl_local_space *ls,
1108 enum isl_dim_type type, unsigned pos,
1109 __isl_take isl_id *id);
1110 int isl_local_space_has_dim_id(
1111 __isl_keep isl_local_space *ls,
1112 enum isl_dim_type type, unsigned pos);
1113 __isl_give isl_id *isl_local_space_get_dim_id(
1114 __isl_keep isl_local_space *ls,
1115 enum isl_dim_type type, unsigned pos);
1116 __isl_give isl_local_space *isl_local_space_set_dim_name(
1117 __isl_take isl_local_space *ls,
1118 enum isl_dim_type type, unsigned pos, const char *s);
1119 int isl_local_space_has_dim_name(
1120 __isl_keep isl_local_space *ls,
1121 enum isl_dim_type type, unsigned pos)
1122 const char *isl_local_space_get_dim_name(
1123 __isl_keep isl_local_space *ls,
1124 enum isl_dim_type type, unsigned pos);
1126 #include <isl/constraint.h>
1127 const char *isl_constraint_get_dim_name(
1128 __isl_keep isl_constraint *constraint,
1129 enum isl_dim_type type, unsigned pos);
1131 #include <isl/set.h>
1132 __isl_give isl_id *isl_basic_set_get_dim_id(
1133 __isl_keep isl_basic_set *bset,
1134 enum isl_dim_type type, unsigned pos);
1135 __isl_give isl_set *isl_set_set_dim_id(
1136 __isl_take isl_set *set, enum isl_dim_type type,
1137 unsigned pos, __isl_take isl_id *id);
1138 int isl_set_has_dim_id(__isl_keep isl_set *set,
1139 enum isl_dim_type type, unsigned pos);
1140 __isl_give isl_id *isl_set_get_dim_id(
1141 __isl_keep isl_set *set, enum isl_dim_type type,
1143 const char *isl_basic_set_get_dim_name(
1144 __isl_keep isl_basic_set *bset,
1145 enum isl_dim_type type, unsigned pos);
1146 int isl_set_has_dim_name(__isl_keep isl_set *set,
1147 enum isl_dim_type type, unsigned pos);
1148 const char *isl_set_get_dim_name(
1149 __isl_keep isl_set *set,
1150 enum isl_dim_type type, unsigned pos);
1152 #include <isl/map.h>
1153 __isl_give isl_map *isl_map_set_dim_id(
1154 __isl_take isl_map *map, enum isl_dim_type type,
1155 unsigned pos, __isl_take isl_id *id);
1156 int isl_basic_map_has_dim_id(
1157 __isl_keep isl_basic_map *bmap,
1158 enum isl_dim_type type, unsigned pos);
1159 int isl_map_has_dim_id(__isl_keep isl_map *map,
1160 enum isl_dim_type type, unsigned pos);
1161 __isl_give isl_id *isl_map_get_dim_id(
1162 __isl_keep isl_map *map, enum isl_dim_type type,
1164 __isl_give isl_id *isl_union_map_get_dim_id(
1165 __isl_keep isl_union_map *umap,
1166 enum isl_dim_type type, unsigned pos);
1167 const char *isl_basic_map_get_dim_name(
1168 __isl_keep isl_basic_map *bmap,
1169 enum isl_dim_type type, unsigned pos);
1170 int isl_map_has_dim_name(__isl_keep isl_map *map,
1171 enum isl_dim_type type, unsigned pos);
1172 const char *isl_map_get_dim_name(
1173 __isl_keep isl_map *map,
1174 enum isl_dim_type type, unsigned pos);
1176 #include <isl/val.h>
1177 __isl_give isl_multi_val *isl_multi_val_set_dim_id(
1178 __isl_take isl_multi_val *mv,
1179 enum isl_dim_type type, unsigned pos,
1180 __isl_take isl_id *id);
1181 __isl_give isl_id *isl_multi_val_get_dim_id(
1182 __isl_keep isl_multi_val *mv,
1183 enum isl_dim_type type, unsigned pos);
1184 __isl_give isl_multi_val *isl_multi_val_set_dim_name(
1185 __isl_take isl_multi_val *mv,
1186 enum isl_dim_type type, unsigned pos, const char *s);
1188 #include <isl/aff.h>
1189 __isl_give isl_aff *isl_aff_set_dim_id(
1190 __isl_take isl_aff *aff, enum isl_dim_type type,
1191 unsigned pos, __isl_take isl_id *id);
1192 __isl_give isl_multi_aff *isl_multi_aff_set_dim_id(
1193 __isl_take isl_multi_aff *maff,
1194 enum isl_dim_type type, unsigned pos,
1195 __isl_take isl_id *id);
1196 __isl_give isl_pw_aff *isl_pw_aff_set_dim_id(
1197 __isl_take isl_pw_aff *pma,
1198 enum isl_dim_type type, unsigned pos,
1199 __isl_take isl_id *id);
1200 __isl_give isl_multi_pw_aff *
1201 isl_multi_pw_aff_set_dim_id(
1202 __isl_take isl_multi_pw_aff *mpa,
1203 enum isl_dim_type type, unsigned pos,
1204 __isl_take isl_id *id);
1205 __isl_give isl_multi_union_pw_aff *
1206 isl_multi_union_pw_aff_set_dim_id(
1207 __isl_take isl_multi_union_pw_aff *mupa,
1208 enum isl_dim_type type, unsigned pos,
1209 __isl_take isl_id *id);
1210 __isl_give isl_id *isl_multi_aff_get_dim_id(
1211 __isl_keep isl_multi_aff *ma,
1212 enum isl_dim_type type, unsigned pos);
1213 int isl_pw_aff_has_dim_id(__isl_keep isl_pw_aff *pa,
1214 enum isl_dim_type type, unsigned pos);
1215 __isl_give isl_id *isl_pw_aff_get_dim_id(
1216 __isl_keep isl_pw_aff *pa,
1217 enum isl_dim_type type, unsigned pos);
1218 __isl_give isl_id *isl_pw_multi_aff_get_dim_id(
1219 __isl_keep isl_pw_multi_aff *pma,
1220 enum isl_dim_type type, unsigned pos);
1221 __isl_give isl_id *isl_multi_pw_aff_get_dim_id(
1222 __isl_keep isl_multi_pw_aff *mpa,
1223 enum isl_dim_type type, unsigned pos);
1224 __isl_give isl_id *isl_multi_union_pw_aff_get_dim_id(
1225 __isl_keep isl_multi_union_pw_aff *mupa,
1226 enum isl_dim_type type, unsigned pos);
1227 __isl_give isl_aff *isl_aff_set_dim_name(
1228 __isl_take isl_aff *aff, enum isl_dim_type type,
1229 unsigned pos, const char *s);
1230 __isl_give isl_multi_aff *isl_multi_aff_set_dim_name(
1231 __isl_take isl_multi_aff *maff,
1232 enum isl_dim_type type, unsigned pos, const char *s);
1233 __isl_give isl_multi_pw_aff *
1234 isl_multi_pw_aff_set_dim_name(
1235 __isl_take isl_multi_pw_aff *mpa,
1236 enum isl_dim_type type, unsigned pos, const char *s);
1237 __isl_give isl_union_pw_aff *
1238 isl_union_pw_aff_set_dim_name(
1239 __isl_take isl_union_pw_aff *upa,
1240 enum isl_dim_type type, unsigned pos,
1242 __isl_give isl_union_pw_multi_aff *
1243 isl_union_pw_multi_aff_set_dim_name(
1244 __isl_take isl_union_pw_multi_aff *upma,
1245 enum isl_dim_type type, unsigned pos,
1247 __isl_give isl_multi_union_pw_aff *
1248 isl_multi_union_pw_aff_set_dim_name(
1249 __isl_take isl_multi_union_pw_aff *mupa,
1250 enum isl_dim_type type, unsigned pos,
1251 const char *isl_aff_get_dim_name(__isl_keep isl_aff *aff,
1252 enum isl_dim_type type, unsigned pos);
1253 const char *isl_pw_aff_get_dim_name(
1254 __isl_keep isl_pw_aff *pa,
1255 enum isl_dim_type type, unsigned pos);
1256 const char *isl_pw_multi_aff_get_dim_name(
1257 __isl_keep isl_pw_multi_aff *pma,
1258 enum isl_dim_type type, unsigned pos);
1260 #include <isl/polynomial.h>
1261 __isl_give isl_qpolynomial *isl_qpolynomial_set_dim_name(
1262 __isl_take isl_qpolynomial *qp,
1263 enum isl_dim_type type, unsigned pos,
1265 __isl_give isl_pw_qpolynomial *
1266 isl_pw_qpolynomial_set_dim_name(
1267 __isl_take isl_pw_qpolynomial *pwqp,
1268 enum isl_dim_type type, unsigned pos,
1270 __isl_give isl_pw_qpolynomial_fold *
1271 isl_pw_qpolynomial_fold_set_dim_name(
1272 __isl_take isl_pw_qpolynomial_fold *pwf,
1273 enum isl_dim_type type, unsigned pos,
1275 __isl_give isl_union_pw_qpolynomial *
1276 isl_union_pw_qpolynomial_set_dim_name(
1277 __isl_take isl_union_pw_qpolynomial *upwqp,
1278 enum isl_dim_type type, unsigned pos,
1280 __isl_give isl_union_pw_qpolynomial_fold *
1281 isl_union_pw_qpolynomial_fold_set_dim_name(
1282 __isl_take isl_union_pw_qpolynomial_fold *upwf,
1283 enum isl_dim_type type, unsigned pos,
1286 Note that C<isl_space_get_name> returns a pointer to some internal
1287 data structure, so the result can only be used while the
1288 corresponding C<isl_space> is alive.
1289 Also note that every function that operates on two sets or relations
1290 requires that both arguments have the same parameters. This also
1291 means that if one of the arguments has named parameters, then the
1292 other needs to have named parameters too and the names need to match.
1293 Pairs of C<isl_set>, C<isl_map>, C<isl_union_set> and/or C<isl_union_map>
1294 arguments may have different parameters (as long as they are named),
1295 in which case the result will have as parameters the union of the parameters of
1298 Given the identifier or name of a dimension (typically a parameter),
1299 its position can be obtained from the following functions.
1301 #include <isl/space.h>
1302 int isl_space_find_dim_by_id(__isl_keep isl_space *space,
1303 enum isl_dim_type type, __isl_keep isl_id *id);
1304 int isl_space_find_dim_by_name(__isl_keep isl_space *space,
1305 enum isl_dim_type type, const char *name);
1307 #include <isl/local_space.h>
1308 int isl_local_space_find_dim_by_name(
1309 __isl_keep isl_local_space *ls,
1310 enum isl_dim_type type, const char *name);
1312 #include <isl/val.h>
1313 int isl_multi_val_find_dim_by_id(
1314 __isl_keep isl_multi_val *mv,
1315 enum isl_dim_type type, __isl_keep isl_id *id);
1316 int isl_multi_val_find_dim_by_name(
1317 __isl_keep isl_multi_val *mv,
1318 enum isl_dim_type type, const char *name);
1320 #include <isl/set.h>
1321 int isl_set_find_dim_by_id(__isl_keep isl_set *set,
1322 enum isl_dim_type type, __isl_keep isl_id *id);
1323 int isl_set_find_dim_by_name(__isl_keep isl_set *set,
1324 enum isl_dim_type type, const char *name);
1326 #include <isl/map.h>
1327 int isl_map_find_dim_by_id(__isl_keep isl_map *map,
1328 enum isl_dim_type type, __isl_keep isl_id *id);
1329 int isl_basic_map_find_dim_by_name(
1330 __isl_keep isl_basic_map *bmap,
1331 enum isl_dim_type type, const char *name);
1332 int isl_map_find_dim_by_name(__isl_keep isl_map *map,
1333 enum isl_dim_type type, const char *name);
1334 int isl_union_map_find_dim_by_name(
1335 __isl_keep isl_union_map *umap,
1336 enum isl_dim_type type, const char *name);
1338 #include <isl/aff.h>
1339 int isl_multi_aff_find_dim_by_id(
1340 __isl_keep isl_multi_aff *ma,
1341 enum isl_dim_type type, __isl_keep isl_id *id);
1342 int isl_multi_pw_aff_find_dim_by_id(
1343 __isl_keep isl_multi_pw_aff *mpa,
1344 enum isl_dim_type type, __isl_keep isl_id *id);
1345 int isl_multi_union_pw_aff_find_dim_by_id(
1346 __isl_keep isl_union_multi_pw_aff *mupa,
1347 enum isl_dim_type type, __isl_keep isl_id *id);
1348 int isl_aff_find_dim_by_name(__isl_keep isl_aff *aff,
1349 enum isl_dim_type type, const char *name);
1350 int isl_multi_aff_find_dim_by_name(
1351 __isl_keep isl_multi_aff *ma,
1352 enum isl_dim_type type, const char *name);
1353 int isl_pw_aff_find_dim_by_name(__isl_keep isl_pw_aff *pa,
1354 enum isl_dim_type type, const char *name);
1355 int isl_multi_pw_aff_find_dim_by_name(
1356 __isl_keep isl_multi_pw_aff *mpa,
1357 enum isl_dim_type type, const char *name);
1358 int isl_pw_multi_aff_find_dim_by_name(
1359 __isl_keep isl_pw_multi_aff *pma,
1360 enum isl_dim_type type, const char *name);
1361 int isl_union_pw_aff_find_dim_by_name(
1362 __isl_keep isl_union_pw_aff *upa,
1363 enum isl_dim_type type, const char *name);
1364 int isl_union_pw_multi_aff_find_dim_by_name(
1365 __isl_keep isl_union_pw_multi_aff *upma,
1366 enum isl_dim_type type, const char *name);
1367 int isl_multi_union_pw_aff_find_dim_by_name(
1368 __isl_keep isl_multi_union_pw_aff *mupa,
1369 enum isl_dim_type type, const char *name);
1371 #include <isl/polynomial.h>
1372 int isl_pw_qpolynomial_find_dim_by_name(
1373 __isl_keep isl_pw_qpolynomial *pwqp,
1374 enum isl_dim_type type, const char *name);
1375 int isl_pw_qpolynomial_fold_find_dim_by_name(
1376 __isl_keep isl_pw_qpolynomial_fold *pwf,
1377 enum isl_dim_type type, const char *name);
1378 int isl_union_pw_qpolynomial_find_dim_by_name(
1379 __isl_keep isl_union_pw_qpolynomial *upwqp,
1380 enum isl_dim_type type, const char *name);
1381 int isl_union_pw_qpolynomial_fold_find_dim_by_name(
1382 __isl_keep isl_union_pw_qpolynomial_fold *upwf,
1383 enum isl_dim_type type, const char *name);
1385 The identifiers or names of entire spaces may be set or read off
1386 using the following functions.
1388 #include <isl/space.h>
1389 __isl_give isl_space *isl_space_set_tuple_id(
1390 __isl_take isl_space *space,
1391 enum isl_dim_type type, __isl_take isl_id *id);
1392 __isl_give isl_space *isl_space_reset_tuple_id(
1393 __isl_take isl_space *space, enum isl_dim_type type);
1394 int isl_space_has_tuple_id(__isl_keep isl_space *space,
1395 enum isl_dim_type type);
1396 __isl_give isl_id *isl_space_get_tuple_id(
1397 __isl_keep isl_space *space, enum isl_dim_type type);
1398 __isl_give isl_space *isl_space_set_tuple_name(
1399 __isl_take isl_space *space,
1400 enum isl_dim_type type, const char *s);
1401 int isl_space_has_tuple_name(__isl_keep isl_space *space,
1402 enum isl_dim_type type);
1403 const char *isl_space_get_tuple_name(__isl_keep isl_space *space,
1404 enum isl_dim_type type);
1406 #include <isl/local_space.h>
1407 __isl_give isl_local_space *isl_local_space_set_tuple_id(
1408 __isl_take isl_local_space *ls,
1409 enum isl_dim_type type, __isl_take isl_id *id);
1411 #include <isl/set.h>
1412 __isl_give isl_basic_set *isl_basic_set_set_tuple_id(
1413 __isl_take isl_basic_set *bset,
1414 __isl_take isl_id *id);
1415 __isl_give isl_set *isl_set_set_tuple_id(
1416 __isl_take isl_set *set, __isl_take isl_id *id);
1417 __isl_give isl_set *isl_set_reset_tuple_id(
1418 __isl_take isl_set *set);
1419 int isl_set_has_tuple_id(__isl_keep isl_set *set);
1420 __isl_give isl_id *isl_set_get_tuple_id(
1421 __isl_keep isl_set *set);
1422 __isl_give isl_basic_set *isl_basic_set_set_tuple_name(
1423 __isl_take isl_basic_set *set, const char *s);
1424 __isl_give isl_set *isl_set_set_tuple_name(
1425 __isl_take isl_set *set, const char *s);
1426 const char *isl_basic_set_get_tuple_name(
1427 __isl_keep isl_basic_set *bset);
1428 int isl_set_has_tuple_name(__isl_keep isl_set *set);
1429 const char *isl_set_get_tuple_name(
1430 __isl_keep isl_set *set);
1432 #include <isl/map.h>
1433 __isl_give isl_basic_map *isl_basic_map_set_tuple_id(
1434 __isl_take isl_basic_map *bmap,
1435 enum isl_dim_type type, __isl_take isl_id *id);
1436 __isl_give isl_map *isl_map_set_tuple_id(
1437 __isl_take isl_map *map, enum isl_dim_type type,
1438 __isl_take isl_id *id);
1439 __isl_give isl_map *isl_map_reset_tuple_id(
1440 __isl_take isl_map *map, enum isl_dim_type type);
1441 int isl_map_has_tuple_id(__isl_keep isl_map *map,
1442 enum isl_dim_type type);
1443 __isl_give isl_id *isl_map_get_tuple_id(
1444 __isl_keep isl_map *map, enum isl_dim_type type);
1445 __isl_give isl_map *isl_map_set_tuple_name(
1446 __isl_take isl_map *map,
1447 enum isl_dim_type type, const char *s);
1448 const char *isl_basic_map_get_tuple_name(
1449 __isl_keep isl_basic_map *bmap,
1450 enum isl_dim_type type);
1451 __isl_give isl_basic_map *isl_basic_map_set_tuple_name(
1452 __isl_take isl_basic_map *bmap,
1453 enum isl_dim_type type, const char *s);
1454 int isl_map_has_tuple_name(__isl_keep isl_map *map,
1455 enum isl_dim_type type);
1456 const char *isl_map_get_tuple_name(
1457 __isl_keep isl_map *map,
1458 enum isl_dim_type type);
1460 #include <isl/val.h>
1461 __isl_give isl_multi_val *isl_multi_val_set_tuple_id(
1462 __isl_take isl_multi_val *mv,
1463 enum isl_dim_type type, __isl_take isl_id *id);
1464 __isl_give isl_multi_val *isl_multi_val_reset_tuple_id(
1465 __isl_take isl_multi_val *mv,
1466 enum isl_dim_type type);
1467 int isl_multi_val_has_tuple_id(__isl_keep isl_multi_val *mv,
1468 enum isl_dim_type type);
1469 __isl_give isl_id *isl_multi_val_get_tuple_id(
1470 __isl_keep isl_multi_val *mv,
1471 enum isl_dim_type type);
1472 __isl_give isl_multi_val *isl_multi_val_set_tuple_name(
1473 __isl_take isl_multi_val *mv,
1474 enum isl_dim_type type, const char *s);
1475 const char *isl_multi_val_get_tuple_name(
1476 __isl_keep isl_multi_val *mv,
1477 enum isl_dim_type type);
1479 #include <isl/aff.h>
1480 __isl_give isl_aff *isl_aff_set_tuple_id(
1481 __isl_take isl_aff *aff,
1482 enum isl_dim_type type, __isl_take isl_id *id);
1483 __isl_give isl_multi_aff *isl_multi_aff_set_tuple_id(
1484 __isl_take isl_multi_aff *maff,
1485 enum isl_dim_type type, __isl_take isl_id *id);
1486 __isl_give isl_pw_aff *isl_pw_aff_set_tuple_id(
1487 __isl_take isl_pw_aff *pwaff,
1488 enum isl_dim_type type, __isl_take isl_id *id);
1489 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_tuple_id(
1490 __isl_take isl_pw_multi_aff *pma,
1491 enum isl_dim_type type, __isl_take isl_id *id);
1492 __isl_give isl_multi_union_pw_aff *
1493 isl_multi_union_pw_aff_set_tuple_id(
1494 __isl_take isl_multi_union_pw_aff *mupa,
1495 enum isl_dim_type type, __isl_take isl_id *id);
1496 __isl_give isl_multi_aff *isl_multi_aff_reset_tuple_id(
1497 __isl_take isl_multi_aff *ma,
1498 enum isl_dim_type type);
1499 __isl_give isl_pw_aff *isl_pw_aff_reset_tuple_id(
1500 __isl_take isl_pw_aff *pa,
1501 enum isl_dim_type type);
1502 __isl_give isl_multi_pw_aff *
1503 isl_multi_pw_aff_reset_tuple_id(
1504 __isl_take isl_multi_pw_aff *mpa,
1505 enum isl_dim_type type);
1506 __isl_give isl_pw_multi_aff *
1507 isl_pw_multi_aff_reset_tuple_id(
1508 __isl_take isl_pw_multi_aff *pma,
1509 enum isl_dim_type type);
1510 __isl_give isl_multi_union_pw_aff *
1511 isl_multi_union_pw_aff_reset_tuple_id(
1512 __isl_take isl_multi_union_pw_aff *mupa,
1513 enum isl_dim_type type);
1514 int isl_multi_aff_has_tuple_id(__isl_keep isl_multi_aff *ma,
1515 enum isl_dim_type type);
1516 __isl_give isl_id *isl_multi_aff_get_tuple_id(
1517 __isl_keep isl_multi_aff *ma,
1518 enum isl_dim_type type);
1519 int isl_pw_aff_has_tuple_id(__isl_keep isl_pw_aff *pa,
1520 enum isl_dim_type type);
1521 __isl_give isl_id *isl_pw_aff_get_tuple_id(
1522 __isl_keep isl_pw_aff *pa,
1523 enum isl_dim_type type);
1524 int isl_pw_multi_aff_has_tuple_id(
1525 __isl_keep isl_pw_multi_aff *pma,
1526 enum isl_dim_type type);
1527 __isl_give isl_id *isl_pw_multi_aff_get_tuple_id(
1528 __isl_keep isl_pw_multi_aff *pma,
1529 enum isl_dim_type type);
1530 int isl_multi_pw_aff_has_tuple_id(
1531 __isl_keep isl_multi_pw_aff *mpa,
1532 enum isl_dim_type type);
1533 __isl_give isl_id *isl_multi_pw_aff_get_tuple_id(
1534 __isl_keep isl_multi_pw_aff *mpa,
1535 enum isl_dim_type type);
1536 int isl_multi_union_pw_aff_has_tuple_id(
1537 __isl_keep isl_multi_union_pw_aff *mupa,
1538 enum isl_dim_type type);
1539 __isl_give isl_id *isl_multi_union_pw_aff_get_tuple_id(
1540 __isl_keep isl_multi_union_pw_aff *mupa,
1541 enum isl_dim_type type);
1542 __isl_give isl_multi_aff *isl_multi_aff_set_tuple_name(
1543 __isl_take isl_multi_aff *maff,
1544 enum isl_dim_type type, const char *s);
1545 __isl_give isl_multi_pw_aff *
1546 isl_multi_pw_aff_set_tuple_name(
1547 __isl_take isl_multi_pw_aff *mpa,
1548 enum isl_dim_type type, const char *s);
1549 __isl_give isl_multi_union_pw_aff *
1550 isl_multi_union_pw_aff_set_tuple_name(
1551 __isl_take isl_multi_union_pw_aff *mupa,
1552 enum isl_dim_type type, const char *s);
1553 const char *isl_multi_aff_get_tuple_name(
1554 __isl_keep isl_multi_aff *multi,
1555 enum isl_dim_type type);
1556 int isl_pw_multi_aff_has_tuple_name(
1557 __isl_keep isl_pw_multi_aff *pma,
1558 enum isl_dim_type type);
1559 const char *isl_pw_multi_aff_get_tuple_name(
1560 __isl_keep isl_pw_multi_aff *pma,
1561 enum isl_dim_type type);
1562 const char *isl_multi_union_pw_aff_get_tuple_name(
1563 __isl_keep isl_multi_union_pw_aff *mupa,
1564 enum isl_dim_type type);
1566 The C<type> argument needs to be one of C<isl_dim_in>, C<isl_dim_out>
1567 or C<isl_dim_set>. As with C<isl_space_get_name>,
1568 the C<isl_space_get_tuple_name> function returns a pointer to some internal
1570 Binary operations require the corresponding spaces of their arguments
1571 to have the same name.
1573 To keep the names of all parameters and tuples, but reset the user pointers
1574 of all the corresponding identifiers, use the following function.
1576 #include <isl/space.h>
1577 __isl_give isl_space *isl_space_reset_user(
1578 __isl_take isl_space *space);
1580 #include <isl/set.h>
1581 __isl_give isl_set *isl_set_reset_user(
1582 __isl_take isl_set *set);
1584 #include <isl/map.h>
1585 __isl_give isl_map *isl_map_reset_user(
1586 __isl_take isl_map *map);
1588 #include <isl/union_set.h>
1589 __isl_give isl_union_set *isl_union_set_reset_user(
1590 __isl_take isl_union_set *uset);
1592 #include <isl/union_map.h>
1593 __isl_give isl_union_map *isl_union_map_reset_user(
1594 __isl_take isl_union_map *umap);
1596 #include <isl/val.h>
1597 __isl_give isl_multi_val *isl_multi_val_reset_user(
1598 __isl_take isl_multi_val *mv);
1600 #include <isl/aff.h>
1601 __isl_give isl_multi_aff *isl_multi_aff_reset_user(
1602 __isl_take isl_multi_aff *ma);
1603 __isl_give isl_pw_aff *isl_pw_aff_reset_user(
1604 __isl_take isl_pw_aff *pa);
1605 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_reset_user(
1606 __isl_take isl_multi_pw_aff *mpa);
1607 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_reset_user(
1608 __isl_take isl_pw_multi_aff *pma);
1609 __isl_give isl_union_pw_aff *isl_union_pw_aff_reset_user(
1610 __isl_take isl_union_pw_aff *upa);
1611 __isl_give isl_multi_union_pw_aff *
1612 isl_multi_union_pw_aff_reset_user(
1613 __isl_take isl_multi_union_pw_aff *mupa);
1614 __isl_give isl_union_pw_multi_aff *
1615 isl_union_pw_multi_aff_reset_user(
1616 __isl_take isl_union_pw_multi_aff *upma);
1618 #include <isl/polynomial.h>
1619 __isl_give isl_pw_qpolynomial *
1620 isl_pw_qpolynomial_reset_user(
1621 __isl_take isl_pw_qpolynomial *pwqp);
1622 __isl_give isl_union_pw_qpolynomial *
1623 isl_union_pw_qpolynomial_reset_user(
1624 __isl_take isl_union_pw_qpolynomial *upwqp);
1625 __isl_give isl_pw_qpolynomial_fold *
1626 isl_pw_qpolynomial_fold_reset_user(
1627 __isl_take isl_pw_qpolynomial_fold *pwf);
1628 __isl_give isl_union_pw_qpolynomial_fold *
1629 isl_union_pw_qpolynomial_fold_reset_user(
1630 __isl_take isl_union_pw_qpolynomial_fold *upwf);
1632 Spaces can be nested. In particular, the domain of a set or
1633 the domain or range of a relation can be a nested relation.
1634 This process is also called I<wrapping>.
1635 The functions for detecting, constructing and deconstructing
1636 such nested spaces can be found in the wrapping properties
1637 of L</"Unary Properties">, the wrapping operations
1638 of L</"Unary Operations"> and the Cartesian product operations
1639 of L</"Basic Operations">.
1641 Spaces can be created from other spaces
1642 using the functions described in L</"Unary Operations">
1643 and L</"Binary Operations">.
1647 A local space is essentially a space with
1648 zero or more existentially quantified variables.
1649 The local space of various objects can be obtained
1650 using the following functions.
1652 #include <isl/constraint.h>
1653 __isl_give isl_local_space *isl_constraint_get_local_space(
1654 __isl_keep isl_constraint *constraint);
1656 #include <isl/set.h>
1657 __isl_give isl_local_space *isl_basic_set_get_local_space(
1658 __isl_keep isl_basic_set *bset);
1660 #include <isl/map.h>
1661 __isl_give isl_local_space *isl_basic_map_get_local_space(
1662 __isl_keep isl_basic_map *bmap);
1664 #include <isl/aff.h>
1665 __isl_give isl_local_space *isl_aff_get_domain_local_space(
1666 __isl_keep isl_aff *aff);
1667 __isl_give isl_local_space *isl_aff_get_local_space(
1668 __isl_keep isl_aff *aff);
1670 A new local space can be created from a space using
1672 #include <isl/local_space.h>
1673 __isl_give isl_local_space *isl_local_space_from_space(
1674 __isl_take isl_space *space);
1676 They can be inspected, modified, copied and freed using the following functions.
1678 #include <isl/local_space.h>
1679 int isl_local_space_is_params(
1680 __isl_keep isl_local_space *ls);
1681 int isl_local_space_is_set(__isl_keep isl_local_space *ls);
1682 __isl_give isl_space *isl_local_space_get_space(
1683 __isl_keep isl_local_space *ls);
1684 __isl_give isl_aff *isl_local_space_get_div(
1685 __isl_keep isl_local_space *ls, int pos);
1686 __isl_give isl_local_space *isl_local_space_copy(
1687 __isl_keep isl_local_space *ls);
1688 __isl_null isl_local_space *isl_local_space_free(
1689 __isl_take isl_local_space *ls);
1691 Note that C<isl_local_space_get_div> can only be used on local spaces
1694 Two local spaces can be compared using
1696 int isl_local_space_is_equal(__isl_keep isl_local_space *ls1,
1697 __isl_keep isl_local_space *ls2);
1699 Local spaces can be created from other local spaces
1700 using the functions described in L</"Unary Operations">
1701 and L</"Binary Operations">.
1703 =head2 Creating New Sets and Relations
1705 C<isl> has functions for creating some standard sets and relations.
1709 =item * Empty sets and relations
1711 __isl_give isl_basic_set *isl_basic_set_empty(
1712 __isl_take isl_space *space);
1713 __isl_give isl_basic_map *isl_basic_map_empty(
1714 __isl_take isl_space *space);
1715 __isl_give isl_set *isl_set_empty(
1716 __isl_take isl_space *space);
1717 __isl_give isl_map *isl_map_empty(
1718 __isl_take isl_space *space);
1719 __isl_give isl_union_set *isl_union_set_empty(
1720 __isl_take isl_space *space);
1721 __isl_give isl_union_map *isl_union_map_empty(
1722 __isl_take isl_space *space);
1724 For C<isl_union_set>s and C<isl_union_map>s, the space
1725 is only used to specify the parameters.
1727 =item * Universe sets and relations
1729 __isl_give isl_basic_set *isl_basic_set_universe(
1730 __isl_take isl_space *space);
1731 __isl_give isl_basic_map *isl_basic_map_universe(
1732 __isl_take isl_space *space);
1733 __isl_give isl_set *isl_set_universe(
1734 __isl_take isl_space *space);
1735 __isl_give isl_map *isl_map_universe(
1736 __isl_take isl_space *space);
1737 __isl_give isl_union_set *isl_union_set_universe(
1738 __isl_take isl_union_set *uset);
1739 __isl_give isl_union_map *isl_union_map_universe(
1740 __isl_take isl_union_map *umap);
1742 The sets and relations constructed by the functions above
1743 contain all integer values, while those constructed by the
1744 functions below only contain non-negative values.
1746 __isl_give isl_basic_set *isl_basic_set_nat_universe(
1747 __isl_take isl_space *space);
1748 __isl_give isl_basic_map *isl_basic_map_nat_universe(
1749 __isl_take isl_space *space);
1750 __isl_give isl_set *isl_set_nat_universe(
1751 __isl_take isl_space *space);
1752 __isl_give isl_map *isl_map_nat_universe(
1753 __isl_take isl_space *space);
1755 =item * Identity relations
1757 __isl_give isl_basic_map *isl_basic_map_identity(
1758 __isl_take isl_space *space);
1759 __isl_give isl_map *isl_map_identity(
1760 __isl_take isl_space *space);
1762 The number of input and output dimensions in C<space> needs
1765 =item * Lexicographic order
1767 __isl_give isl_map *isl_map_lex_lt(
1768 __isl_take isl_space *set_space);
1769 __isl_give isl_map *isl_map_lex_le(
1770 __isl_take isl_space *set_space);
1771 __isl_give isl_map *isl_map_lex_gt(
1772 __isl_take isl_space *set_space);
1773 __isl_give isl_map *isl_map_lex_ge(
1774 __isl_take isl_space *set_space);
1775 __isl_give isl_map *isl_map_lex_lt_first(
1776 __isl_take isl_space *space, unsigned n);
1777 __isl_give isl_map *isl_map_lex_le_first(
1778 __isl_take isl_space *space, unsigned n);
1779 __isl_give isl_map *isl_map_lex_gt_first(
1780 __isl_take isl_space *space, unsigned n);
1781 __isl_give isl_map *isl_map_lex_ge_first(
1782 __isl_take isl_space *space, unsigned n);
1784 The first four functions take a space for a B<set>
1785 and return relations that express that the elements in the domain
1786 are lexicographically less
1787 (C<isl_map_lex_lt>), less or equal (C<isl_map_lex_le>),
1788 greater (C<isl_map_lex_gt>) or greater or equal (C<isl_map_lex_ge>)
1789 than the elements in the range.
1790 The last four functions take a space for a map
1791 and return relations that express that the first C<n> dimensions
1792 in the domain are lexicographically less
1793 (C<isl_map_lex_lt_first>), less or equal (C<isl_map_lex_le_first>),
1794 greater (C<isl_map_lex_gt_first>) or greater or equal (C<isl_map_lex_ge_first>)
1795 than the first C<n> dimensions in the range.
1799 A basic set or relation can be converted to a set or relation
1800 using the following functions.
1802 __isl_give isl_set *isl_set_from_basic_set(
1803 __isl_take isl_basic_set *bset);
1804 __isl_give isl_map *isl_map_from_basic_map(
1805 __isl_take isl_basic_map *bmap);
1807 Sets and relations can be converted to union sets and relations
1808 using the following functions.
1810 __isl_give isl_union_set *isl_union_set_from_basic_set(
1811 __isl_take isl_basic_set *bset);
1812 __isl_give isl_union_map *isl_union_map_from_basic_map(
1813 __isl_take isl_basic_map *bmap);
1814 __isl_give isl_union_set *isl_union_set_from_set(
1815 __isl_take isl_set *set);
1816 __isl_give isl_union_map *isl_union_map_from_map(
1817 __isl_take isl_map *map);
1819 The inverse conversions below can only be used if the input
1820 union set or relation is known to contain elements in exactly one
1823 __isl_give isl_set *isl_set_from_union_set(
1824 __isl_take isl_union_set *uset);
1825 __isl_give isl_map *isl_map_from_union_map(
1826 __isl_take isl_union_map *umap);
1828 Sets and relations can be copied and freed again using the following
1831 __isl_give isl_basic_set *isl_basic_set_copy(
1832 __isl_keep isl_basic_set *bset);
1833 __isl_give isl_set *isl_set_copy(__isl_keep isl_set *set);
1834 __isl_give isl_union_set *isl_union_set_copy(
1835 __isl_keep isl_union_set *uset);
1836 __isl_give isl_basic_map *isl_basic_map_copy(
1837 __isl_keep isl_basic_map *bmap);
1838 __isl_give isl_map *isl_map_copy(__isl_keep isl_map *map);
1839 __isl_give isl_union_map *isl_union_map_copy(
1840 __isl_keep isl_union_map *umap);
1841 __isl_null isl_basic_set *isl_basic_set_free(
1842 __isl_take isl_basic_set *bset);
1843 __isl_null isl_set *isl_set_free(__isl_take isl_set *set);
1844 __isl_null isl_union_set *isl_union_set_free(
1845 __isl_take isl_union_set *uset);
1846 __isl_null isl_basic_map *isl_basic_map_free(
1847 __isl_take isl_basic_map *bmap);
1848 __isl_null isl_map *isl_map_free(__isl_take isl_map *map);
1849 __isl_null isl_union_map *isl_union_map_free(
1850 __isl_take isl_union_map *umap);
1852 Other sets and relations can be constructed by starting
1853 from a universe set or relation, adding equality and/or
1854 inequality constraints and then projecting out the
1855 existentially quantified variables, if any.
1856 Constraints can be constructed, manipulated and
1857 added to (or removed from) (basic) sets and relations
1858 using the following functions.
1860 #include <isl/constraint.h>
1861 __isl_give isl_constraint *isl_equality_alloc(
1862 __isl_take isl_local_space *ls);
1863 __isl_give isl_constraint *isl_inequality_alloc(
1864 __isl_take isl_local_space *ls);
1865 __isl_give isl_constraint *isl_constraint_set_constant_si(
1866 __isl_take isl_constraint *constraint, int v);
1867 __isl_give isl_constraint *isl_constraint_set_constant_val(
1868 __isl_take isl_constraint *constraint,
1869 __isl_take isl_val *v);
1870 __isl_give isl_constraint *isl_constraint_set_coefficient_si(
1871 __isl_take isl_constraint *constraint,
1872 enum isl_dim_type type, int pos, int v);
1873 __isl_give isl_constraint *
1874 isl_constraint_set_coefficient_val(
1875 __isl_take isl_constraint *constraint,
1876 enum isl_dim_type type, int pos,
1877 __isl_take isl_val *v);
1878 __isl_give isl_basic_map *isl_basic_map_add_constraint(
1879 __isl_take isl_basic_map *bmap,
1880 __isl_take isl_constraint *constraint);
1881 __isl_give isl_basic_set *isl_basic_set_add_constraint(
1882 __isl_take isl_basic_set *bset,
1883 __isl_take isl_constraint *constraint);
1884 __isl_give isl_map *isl_map_add_constraint(
1885 __isl_take isl_map *map,
1886 __isl_take isl_constraint *constraint);
1887 __isl_give isl_set *isl_set_add_constraint(
1888 __isl_take isl_set *set,
1889 __isl_take isl_constraint *constraint);
1891 For example, to create a set containing the even integers
1892 between 10 and 42, you would use the following code.
1895 isl_local_space *ls;
1897 isl_basic_set *bset;
1899 space = isl_space_set_alloc(ctx, 0, 2);
1900 bset = isl_basic_set_universe(isl_space_copy(space));
1901 ls = isl_local_space_from_space(space);
1903 c = isl_equality_alloc(isl_local_space_copy(ls));
1904 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
1905 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 2);
1906 bset = isl_basic_set_add_constraint(bset, c);
1908 c = isl_inequality_alloc(isl_local_space_copy(ls));
1909 c = isl_constraint_set_constant_si(c, -10);
1910 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
1911 bset = isl_basic_set_add_constraint(bset, c);
1913 c = isl_inequality_alloc(ls);
1914 c = isl_constraint_set_constant_si(c, 42);
1915 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
1916 bset = isl_basic_set_add_constraint(bset, c);
1918 bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 1);
1922 isl_basic_set *bset;
1923 bset = isl_basic_set_read_from_str(ctx,
1924 "{[i] : exists (a : i = 2a and i >= 10 and i <= 42)}");
1926 A basic set or relation can also be constructed from two matrices
1927 describing the equalities and the inequalities.
1929 __isl_give isl_basic_set *isl_basic_set_from_constraint_matrices(
1930 __isl_take isl_space *space,
1931 __isl_take isl_mat *eq, __isl_take isl_mat *ineq,
1932 enum isl_dim_type c1,
1933 enum isl_dim_type c2, enum isl_dim_type c3,
1934 enum isl_dim_type c4);
1935 __isl_give isl_basic_map *isl_basic_map_from_constraint_matrices(
1936 __isl_take isl_space *space,
1937 __isl_take isl_mat *eq, __isl_take isl_mat *ineq,
1938 enum isl_dim_type c1,
1939 enum isl_dim_type c2, enum isl_dim_type c3,
1940 enum isl_dim_type c4, enum isl_dim_type c5);
1942 The C<isl_dim_type> arguments indicate the order in which
1943 different kinds of variables appear in the input matrices
1944 and should be a permutation of C<isl_dim_cst>, C<isl_dim_param>,
1945 C<isl_dim_set> and C<isl_dim_div> for sets and
1946 of C<isl_dim_cst>, C<isl_dim_param>,
1947 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div> for relations.
1949 A (basic or union) set or relation can also be constructed from a
1950 (union) (piecewise) (multiple) affine expression
1951 or a list of affine expressions
1952 (See L</"Functions">).
1954 __isl_give isl_basic_map *isl_basic_map_from_aff(
1955 __isl_take isl_aff *aff);
1956 __isl_give isl_map *isl_map_from_aff(
1957 __isl_take isl_aff *aff);
1958 __isl_give isl_set *isl_set_from_pw_aff(
1959 __isl_take isl_pw_aff *pwaff);
1960 __isl_give isl_map *isl_map_from_pw_aff(
1961 __isl_take isl_pw_aff *pwaff);
1962 __isl_give isl_basic_map *isl_basic_map_from_aff_list(
1963 __isl_take isl_space *domain_space,
1964 __isl_take isl_aff_list *list);
1965 __isl_give isl_basic_map *isl_basic_map_from_multi_aff(
1966 __isl_take isl_multi_aff *maff)
1967 __isl_give isl_map *isl_map_from_multi_aff(
1968 __isl_take isl_multi_aff *maff)
1969 __isl_give isl_set *isl_set_from_pw_multi_aff(
1970 __isl_take isl_pw_multi_aff *pma);
1971 __isl_give isl_map *isl_map_from_pw_multi_aff(
1972 __isl_take isl_pw_multi_aff *pma);
1973 __isl_give isl_set *isl_set_from_multi_pw_aff(
1974 __isl_take isl_multi_pw_aff *mpa);
1975 __isl_give isl_map *isl_map_from_multi_pw_aff(
1976 __isl_take isl_multi_pw_aff *mpa);
1977 __isl_give isl_union_map *isl_union_map_from_union_pw_aff(
1978 __isl_take isl_union_pw_aff *upa);
1979 __isl_give isl_union_map *
1980 isl_union_map_from_union_pw_multi_aff(
1981 __isl_take isl_union_pw_multi_aff *upma);
1982 __isl_give isl_union_map *
1983 isl_union_map_from_multi_union_pw_aff(
1984 __isl_take isl_multi_union_pw_aff *mupa);
1986 The C<domain_space> argument describes the domain of the resulting
1987 basic relation. It is required because the C<list> may consist
1988 of zero affine expressions.
1989 The C<mupa> passed to C<isl_union_map_from_multi_union_pw_aff>
1990 is not allowed to be zero-dimensional. The domain of the result
1991 is the shared domain of the union piecewise affine elements.
1993 =head2 Inspecting Sets and Relations
1995 Usually, the user should not have to care about the actual constraints
1996 of the sets and maps, but should instead apply the abstract operations
1997 explained in the following sections.
1998 Occasionally, however, it may be required to inspect the individual
1999 coefficients of the constraints. This section explains how to do so.
2000 In these cases, it may also be useful to have C<isl> compute
2001 an explicit representation of the existentially quantified variables.
2003 __isl_give isl_set *isl_set_compute_divs(
2004 __isl_take isl_set *set);
2005 __isl_give isl_map *isl_map_compute_divs(
2006 __isl_take isl_map *map);
2007 __isl_give isl_union_set *isl_union_set_compute_divs(
2008 __isl_take isl_union_set *uset);
2009 __isl_give isl_union_map *isl_union_map_compute_divs(
2010 __isl_take isl_union_map *umap);
2012 This explicit representation defines the existentially quantified
2013 variables as integer divisions of the other variables, possibly
2014 including earlier existentially quantified variables.
2015 An explicitly represented existentially quantified variable therefore
2016 has a unique value when the values of the other variables are known.
2017 If, furthermore, the same existentials, i.e., existentials
2018 with the same explicit representations, should appear in the
2019 same order in each of the disjuncts of a set or map, then the user should call
2020 either of the following functions.
2022 __isl_give isl_set *isl_set_align_divs(
2023 __isl_take isl_set *set);
2024 __isl_give isl_map *isl_map_align_divs(
2025 __isl_take isl_map *map);
2027 Alternatively, the existentially quantified variables can be removed
2028 using the following functions, which compute an overapproximation.
2030 __isl_give isl_basic_set *isl_basic_set_remove_divs(
2031 __isl_take isl_basic_set *bset);
2032 __isl_give isl_basic_map *isl_basic_map_remove_divs(
2033 __isl_take isl_basic_map *bmap);
2034 __isl_give isl_set *isl_set_remove_divs(
2035 __isl_take isl_set *set);
2036 __isl_give isl_map *isl_map_remove_divs(
2037 __isl_take isl_map *map);
2039 It is also possible to only remove those divs that are defined
2040 in terms of a given range of dimensions or only those for which
2041 no explicit representation is known.
2043 __isl_give isl_basic_set *
2044 isl_basic_set_remove_divs_involving_dims(
2045 __isl_take isl_basic_set *bset,
2046 enum isl_dim_type type,
2047 unsigned first, unsigned n);
2048 __isl_give isl_basic_map *
2049 isl_basic_map_remove_divs_involving_dims(
2050 __isl_take isl_basic_map *bmap,
2051 enum isl_dim_type type,
2052 unsigned first, unsigned n);
2053 __isl_give isl_set *isl_set_remove_divs_involving_dims(
2054 __isl_take isl_set *set, enum isl_dim_type type,
2055 unsigned first, unsigned n);
2056 __isl_give isl_map *isl_map_remove_divs_involving_dims(
2057 __isl_take isl_map *map, enum isl_dim_type type,
2058 unsigned first, unsigned n);
2060 __isl_give isl_basic_set *
2061 isl_basic_set_remove_unknown_divs(
2062 __isl_take isl_basic_set *bset);
2063 __isl_give isl_set *isl_set_remove_unknown_divs(
2064 __isl_take isl_set *set);
2065 __isl_give isl_map *isl_map_remove_unknown_divs(
2066 __isl_take isl_map *map);
2068 To iterate over all the sets or maps in a union set or map, use
2070 int isl_union_set_foreach_set(__isl_keep isl_union_set *uset,
2071 int (*fn)(__isl_take isl_set *set, void *user),
2073 int isl_union_map_foreach_map(__isl_keep isl_union_map *umap,
2074 int (*fn)(__isl_take isl_map *map, void *user),
2077 The number of sets or maps in a union set or map can be obtained
2080 int isl_union_set_n_set(__isl_keep isl_union_set *uset);
2081 int isl_union_map_n_map(__isl_keep isl_union_map *umap);
2083 To extract the set or map in a given space from a union, use
2085 __isl_give isl_set *isl_union_set_extract_set(
2086 __isl_keep isl_union_set *uset,
2087 __isl_take isl_space *space);
2088 __isl_give isl_map *isl_union_map_extract_map(
2089 __isl_keep isl_union_map *umap,
2090 __isl_take isl_space *space);
2092 To iterate over all the basic sets or maps in a set or map, use
2094 int isl_set_foreach_basic_set(__isl_keep isl_set *set,
2095 int (*fn)(__isl_take isl_basic_set *bset, void *user),
2097 int isl_map_foreach_basic_map(__isl_keep isl_map *map,
2098 int (*fn)(__isl_take isl_basic_map *bmap, void *user),
2101 The callback function C<fn> should return 0 if successful and
2102 -1 if an error occurs. In the latter case, or if any other error
2103 occurs, the above functions will return -1.
2105 It should be noted that C<isl> does not guarantee that
2106 the basic sets or maps passed to C<fn> are disjoint.
2107 If this is required, then the user should call one of
2108 the following functions first.
2110 __isl_give isl_set *isl_set_make_disjoint(
2111 __isl_take isl_set *set);
2112 __isl_give isl_map *isl_map_make_disjoint(
2113 __isl_take isl_map *map);
2115 The number of basic sets in a set can be obtained
2116 or the number of basic maps in a map can be obtained
2119 #include <isl/set.h>
2120 int isl_set_n_basic_set(__isl_keep isl_set *set);
2122 #include <isl/map.h>
2123 int isl_map_n_basic_map(__isl_keep isl_map *map);
2125 To iterate over the constraints of a basic set or map, use
2127 #include <isl/constraint.h>
2129 int isl_basic_set_n_constraint(
2130 __isl_keep isl_basic_set *bset);
2131 int isl_basic_set_foreach_constraint(
2132 __isl_keep isl_basic_set *bset,
2133 int (*fn)(__isl_take isl_constraint *c, void *user),
2135 int isl_basic_map_n_constraint(
2136 __isl_keep isl_basic_map *bmap);
2137 int isl_basic_map_foreach_constraint(
2138 __isl_keep isl_basic_map *bmap,
2139 int (*fn)(__isl_take isl_constraint *c, void *user),
2141 __isl_null isl_constraint *isl_constraint_free(
2142 __isl_take isl_constraint *c);
2144 Again, the callback function C<fn> should return 0 if successful and
2145 -1 if an error occurs. In the latter case, or if any other error
2146 occurs, the above functions will return -1.
2147 The constraint C<c> represents either an equality or an inequality.
2148 Use the following function to find out whether a constraint
2149 represents an equality. If not, it represents an inequality.
2151 int isl_constraint_is_equality(
2152 __isl_keep isl_constraint *constraint);
2154 It is also possible to obtain a list of constraints from a basic
2157 #include <isl/constraint.h>
2158 __isl_give isl_constraint_list *
2159 isl_basic_map_get_constraint_list(
2160 __isl_keep isl_basic_map *bmap);
2161 __isl_give isl_constraint_list *
2162 isl_basic_set_get_constraint_list(
2163 __isl_keep isl_basic_set *bset);
2165 These functions require that all existentially quantified variables
2166 have an explicit representation.
2167 The returned list can be manipulated using the functions in L<"Lists">.
2169 The coefficients of the constraints can be inspected using
2170 the following functions.
2172 int isl_constraint_is_lower_bound(
2173 __isl_keep isl_constraint *constraint,
2174 enum isl_dim_type type, unsigned pos);
2175 int isl_constraint_is_upper_bound(
2176 __isl_keep isl_constraint *constraint,
2177 enum isl_dim_type type, unsigned pos);
2178 __isl_give isl_val *isl_constraint_get_constant_val(
2179 __isl_keep isl_constraint *constraint);
2180 __isl_give isl_val *isl_constraint_get_coefficient_val(
2181 __isl_keep isl_constraint *constraint,
2182 enum isl_dim_type type, int pos);
2184 The explicit representations of the existentially quantified
2185 variables can be inspected using the following function.
2186 Note that the user is only allowed to use this function
2187 if the inspected set or map is the result of a call
2188 to C<isl_set_compute_divs> or C<isl_map_compute_divs>.
2189 The existentially quantified variable is equal to the floor
2190 of the returned affine expression. The affine expression
2191 itself can be inspected using the functions in
2194 __isl_give isl_aff *isl_constraint_get_div(
2195 __isl_keep isl_constraint *constraint, int pos);
2197 To obtain the constraints of a basic set or map in matrix
2198 form, use the following functions.
2200 __isl_give isl_mat *isl_basic_set_equalities_matrix(
2201 __isl_keep isl_basic_set *bset,
2202 enum isl_dim_type c1, enum isl_dim_type c2,
2203 enum isl_dim_type c3, enum isl_dim_type c4);
2204 __isl_give isl_mat *isl_basic_set_inequalities_matrix(
2205 __isl_keep isl_basic_set *bset,
2206 enum isl_dim_type c1, enum isl_dim_type c2,
2207 enum isl_dim_type c3, enum isl_dim_type c4);
2208 __isl_give isl_mat *isl_basic_map_equalities_matrix(
2209 __isl_keep isl_basic_map *bmap,
2210 enum isl_dim_type c1,
2211 enum isl_dim_type c2, enum isl_dim_type c3,
2212 enum isl_dim_type c4, enum isl_dim_type c5);
2213 __isl_give isl_mat *isl_basic_map_inequalities_matrix(
2214 __isl_keep isl_basic_map *bmap,
2215 enum isl_dim_type c1,
2216 enum isl_dim_type c2, enum isl_dim_type c3,
2217 enum isl_dim_type c4, enum isl_dim_type c5);
2219 The C<isl_dim_type> arguments dictate the order in which
2220 different kinds of variables appear in the resulting matrix.
2221 For set inputs, they should be a permutation of
2222 C<isl_dim_cst>, C<isl_dim_param>, C<isl_dim_set> and C<isl_dim_div>.
2223 For map inputs, they should be a permutation of
2224 C<isl_dim_cst>, C<isl_dim_param>,
2225 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div>.
2229 Points are elements of a set. They can be used to construct
2230 simple sets (boxes) or they can be used to represent the
2231 individual elements of a set.
2232 The zero point (the origin) can be created using
2234 __isl_give isl_point *isl_point_zero(__isl_take isl_space *space);
2236 The coordinates of a point can be inspected, set and changed
2239 __isl_give isl_val *isl_point_get_coordinate_val(
2240 __isl_keep isl_point *pnt,
2241 enum isl_dim_type type, int pos);
2242 __isl_give isl_point *isl_point_set_coordinate_val(
2243 __isl_take isl_point *pnt,
2244 enum isl_dim_type type, int pos,
2245 __isl_take isl_val *v);
2247 __isl_give isl_point *isl_point_add_ui(
2248 __isl_take isl_point *pnt,
2249 enum isl_dim_type type, int pos, unsigned val);
2250 __isl_give isl_point *isl_point_sub_ui(
2251 __isl_take isl_point *pnt,
2252 enum isl_dim_type type, int pos, unsigned val);
2254 Points can be copied or freed using
2256 __isl_give isl_point *isl_point_copy(
2257 __isl_keep isl_point *pnt);
2258 void isl_point_free(__isl_take isl_point *pnt);
2260 A singleton set can be created from a point using
2262 __isl_give isl_basic_set *isl_basic_set_from_point(
2263 __isl_take isl_point *pnt);
2264 __isl_give isl_set *isl_set_from_point(
2265 __isl_take isl_point *pnt);
2267 and a box can be created from two opposite extremal points using
2269 __isl_give isl_basic_set *isl_basic_set_box_from_points(
2270 __isl_take isl_point *pnt1,
2271 __isl_take isl_point *pnt2);
2272 __isl_give isl_set *isl_set_box_from_points(
2273 __isl_take isl_point *pnt1,
2274 __isl_take isl_point *pnt2);
2276 All elements of a B<bounded> (union) set can be enumerated using
2277 the following functions.
2279 int isl_set_foreach_point(__isl_keep isl_set *set,
2280 int (*fn)(__isl_take isl_point *pnt, void *user),
2282 int isl_union_set_foreach_point(__isl_keep isl_union_set *uset,
2283 int (*fn)(__isl_take isl_point *pnt, void *user),
2286 The function C<fn> is called for each integer point in
2287 C<set> with as second argument the last argument of
2288 the C<isl_set_foreach_point> call. The function C<fn>
2289 should return C<0> on success and C<-1> on failure.
2290 In the latter case, C<isl_set_foreach_point> will stop
2291 enumerating and return C<-1> as well.
2292 If the enumeration is performed successfully and to completion,
2293 then C<isl_set_foreach_point> returns C<0>.
2295 To obtain a single point of a (basic) set, use
2297 __isl_give isl_point *isl_basic_set_sample_point(
2298 __isl_take isl_basic_set *bset);
2299 __isl_give isl_point *isl_set_sample_point(
2300 __isl_take isl_set *set);
2302 If C<set> does not contain any (integer) points, then the
2303 resulting point will be ``void'', a property that can be
2306 int isl_point_is_void(__isl_keep isl_point *pnt);
2310 Besides sets and relation, C<isl> also supports various types of functions.
2311 Each of these types is derived from the value type (see L</"Values">)
2312 or from one of two primitive function types
2313 through the application of zero or more type constructors.
2314 We first describe the primitive type and then we describe
2315 the types derived from these primitive types.
2317 =head3 Primitive Functions
2319 C<isl> support two primitive function types, quasi-affine
2320 expressions and quasipolynomials.
2321 A quasi-affine expression is defined either over a parameter
2322 space or over a set and is composed of integer constants,
2323 parameters and set variables, addition, subtraction and
2324 integer division by an integer constant.
2325 For example, the quasi-affine expression
2327 [n] -> { [x] -> [2*floor((4 n + x)/9] }
2329 maps C<x> to C<2*floor((4 n + x)/9>.
2330 A quasipolynomial is a polynomial expression in quasi-affine
2331 expression. That is, it additionally allows for multiplication.
2332 Note, though, that it is not allowed to construct an integer
2333 division of an expression involving multiplications.
2334 Here is an example of a quasipolynomial that is not
2335 quasi-affine expression
2337 [n] -> { [x] -> (n*floor((4 n + x)/9) }
2339 Note that the external representations of quasi-affine expressions
2340 and quasipolynomials are different. Quasi-affine expressions
2341 use a notation with square brackets just like binary relations,
2342 while quasipolynomials do not. This might change at some point.
2344 If a primitive function is defined over a parameter space,
2345 then the space of the function itself is that of a set.
2346 If it is defined over a set, then the space of the function
2347 is that of a relation. In both cases, the set space (or
2348 the output space) is single-dimensional, anonymous and unstructured.
2349 To create functions with multiple dimensions or with other kinds
2350 of set or output spaces, use multiple expressions
2351 (see L</"Multiple Expressions">).
2355 =item * Quasi-affine Expressions
2357 Besides the expressions described above, a quasi-affine
2358 expression can also be set to NaN. Such expressions
2359 typically represent a failure to represent a result
2360 as a quasi-affine expression.
2362 The zero quasi affine expression or the quasi affine expression
2363 that is equal to a given value or
2364 a specified dimension on a given domain can be created using
2366 #include <isl/aff.h>
2367 __isl_give isl_aff *isl_aff_zero_on_domain(
2368 __isl_take isl_local_space *ls);
2369 __isl_give isl_aff *isl_aff_val_on_domain(
2370 __isl_take isl_local_space *ls,
2371 __isl_take isl_val *val);
2372 __isl_give isl_aff *isl_aff_var_on_domain(
2373 __isl_take isl_local_space *ls,
2374 enum isl_dim_type type, unsigned pos);
2375 __isl_give isl_aff *isl_aff_nan_on_domain(
2376 __isl_take isl_local_space *ls);
2378 Quasi affine expressions can be copied and freed using
2380 #include <isl/aff.h>
2381 __isl_give isl_aff *isl_aff_copy(
2382 __isl_keep isl_aff *aff);
2383 __isl_null isl_aff *isl_aff_free(
2384 __isl_take isl_aff *aff);
2386 A (rational) bound on a dimension can be extracted from an C<isl_constraint>
2387 using the following function. The constraint is required to have
2388 a non-zero coefficient for the specified dimension.
2390 #include <isl/constraint.h>
2391 __isl_give isl_aff *isl_constraint_get_bound(
2392 __isl_keep isl_constraint *constraint,
2393 enum isl_dim_type type, int pos);
2395 The entire affine expression of the constraint can also be extracted
2396 using the following function.
2398 #include <isl/constraint.h>
2399 __isl_give isl_aff *isl_constraint_get_aff(
2400 __isl_keep isl_constraint *constraint);
2402 Conversely, an equality constraint equating
2403 the affine expression to zero or an inequality constraint enforcing
2404 the affine expression to be non-negative, can be constructed using
2406 __isl_give isl_constraint *isl_equality_from_aff(
2407 __isl_take isl_aff *aff);
2408 __isl_give isl_constraint *isl_inequality_from_aff(
2409 __isl_take isl_aff *aff);
2411 The coefficients and the integer divisions of an affine expression
2412 can be inspected using the following functions.
2414 #include <isl/aff.h>
2415 __isl_give isl_val *isl_aff_get_constant_val(
2416 __isl_keep isl_aff *aff);
2417 __isl_give isl_val *isl_aff_get_coefficient_val(
2418 __isl_keep isl_aff *aff,
2419 enum isl_dim_type type, int pos);
2420 int isl_aff_coefficient_sgn(__isl_keep isl_aff *aff,
2421 enum isl_dim_type type, int pos);
2422 __isl_give isl_val *isl_aff_get_denominator_val(
2423 __isl_keep isl_aff *aff);
2424 __isl_give isl_aff *isl_aff_get_div(
2425 __isl_keep isl_aff *aff, int pos);
2427 They can be modified using the following functions.
2429 #include <isl/aff.h>
2430 __isl_give isl_aff *isl_aff_set_constant_si(
2431 __isl_take isl_aff *aff, int v);
2432 __isl_give isl_aff *isl_aff_set_constant_val(
2433 __isl_take isl_aff *aff, __isl_take isl_val *v);
2434 __isl_give isl_aff *isl_aff_set_coefficient_si(
2435 __isl_take isl_aff *aff,
2436 enum isl_dim_type type, int pos, int v);
2437 __isl_give isl_aff *isl_aff_set_coefficient_val(
2438 __isl_take isl_aff *aff,
2439 enum isl_dim_type type, int pos,
2440 __isl_take isl_val *v);
2442 __isl_give isl_aff *isl_aff_add_constant_si(
2443 __isl_take isl_aff *aff, int v);
2444 __isl_give isl_aff *isl_aff_add_constant_val(
2445 __isl_take isl_aff *aff, __isl_take isl_val *v);
2446 __isl_give isl_aff *isl_aff_add_constant_num_si(
2447 __isl_take isl_aff *aff, int v);
2448 __isl_give isl_aff *isl_aff_add_coefficient_si(
2449 __isl_take isl_aff *aff,
2450 enum isl_dim_type type, int pos, int v);
2451 __isl_give isl_aff *isl_aff_add_coefficient_val(
2452 __isl_take isl_aff *aff,
2453 enum isl_dim_type type, int pos,
2454 __isl_take isl_val *v);
2456 Note that C<isl_aff_set_constant_si> and C<isl_aff_set_coefficient_si>
2457 set the I<numerator> of the constant or coefficient, while
2458 C<isl_aff_set_constant_val> and C<isl_aff_set_coefficient_val> set
2459 the constant or coefficient as a whole.
2460 The C<add_constant> and C<add_coefficient> functions add an integer
2461 or rational value to
2462 the possibly rational constant or coefficient.
2463 The C<add_constant_num> functions add an integer value to
2466 =item * Quasipolynomials
2468 Some simple quasipolynomials can be created using the following functions.
2470 #include <isl/polynomial.h>
2471 __isl_give isl_qpolynomial *isl_qpolynomial_zero_on_domain(
2472 __isl_take isl_space *domain);
2473 __isl_give isl_qpolynomial *isl_qpolynomial_one_on_domain(
2474 __isl_take isl_space *domain);
2475 __isl_give isl_qpolynomial *isl_qpolynomial_infty_on_domain(
2476 __isl_take isl_space *domain);
2477 __isl_give isl_qpolynomial *isl_qpolynomial_neginfty_on_domain(
2478 __isl_take isl_space *domain);
2479 __isl_give isl_qpolynomial *isl_qpolynomial_nan_on_domain(
2480 __isl_take isl_space *domain);
2481 __isl_give isl_qpolynomial *isl_qpolynomial_val_on_domain(
2482 __isl_take isl_space *domain,
2483 __isl_take isl_val *val);
2484 __isl_give isl_qpolynomial *isl_qpolynomial_var_on_domain(
2485 __isl_take isl_space *domain,
2486 enum isl_dim_type type, unsigned pos);
2487 __isl_give isl_qpolynomial *isl_qpolynomial_from_aff(
2488 __isl_take isl_aff *aff);
2490 Recall that the space in which a quasipolynomial lives is a map space
2491 with a one-dimensional range. The C<domain> argument in some of
2492 the functions above corresponds to the domain of this map space.
2494 Quasipolynomials can be copied and freed again using the following
2497 #include <isl/polynomial.h>
2498 __isl_give isl_qpolynomial *isl_qpolynomial_copy(
2499 __isl_keep isl_qpolynomial *qp);
2500 __isl_null isl_qpolynomial *isl_qpolynomial_free(
2501 __isl_take isl_qpolynomial *qp);
2503 The constant term of a quasipolynomial can be extracted using
2505 __isl_give isl_val *isl_qpolynomial_get_constant_val(
2506 __isl_keep isl_qpolynomial *qp);
2508 To iterate over all terms in a quasipolynomial,
2511 int isl_qpolynomial_foreach_term(
2512 __isl_keep isl_qpolynomial *qp,
2513 int (*fn)(__isl_take isl_term *term,
2514 void *user), void *user);
2516 The terms themselves can be inspected and freed using
2519 unsigned isl_term_dim(__isl_keep isl_term *term,
2520 enum isl_dim_type type);
2521 __isl_give isl_val *isl_term_get_coefficient_val(
2522 __isl_keep isl_term *term);
2523 int isl_term_get_exp(__isl_keep isl_term *term,
2524 enum isl_dim_type type, unsigned pos);
2525 __isl_give isl_aff *isl_term_get_div(
2526 __isl_keep isl_term *term, unsigned pos);
2527 void isl_term_free(__isl_take isl_term *term);
2529 Each term is a product of parameters, set variables and
2530 integer divisions. The function C<isl_term_get_exp>
2531 returns the exponent of a given dimensions in the given term.
2537 A reduction represents a maximum or a minimum of its
2539 The only reduction type defined by C<isl> is
2540 C<isl_qpolynomial_fold>.
2542 There are currently no functions to directly create such
2543 objects, but they do appear in the piecewise quasipolynomial
2544 reductions returned by the C<isl_pw_qpolynomial_bound> function.
2546 L</"Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions">.
2548 Reductions can be copied and freed using
2549 the following functions.
2551 #include <isl/polynomial.h>
2552 __isl_give isl_qpolynomial_fold *
2553 isl_qpolynomial_fold_copy(
2554 __isl_keep isl_qpolynomial_fold *fold);
2555 void isl_qpolynomial_fold_free(
2556 __isl_take isl_qpolynomial_fold *fold);
2558 To iterate over all quasipolynomials in a reduction, use
2560 int isl_qpolynomial_fold_foreach_qpolynomial(
2561 __isl_keep isl_qpolynomial_fold *fold,
2562 int (*fn)(__isl_take isl_qpolynomial *qp,
2563 void *user), void *user);
2565 =head3 Multiple Expressions
2567 A multiple expression represents a sequence of zero or
2568 more base expressions, all defined on the same domain space.
2569 The domain space of the multiple expression is the same
2570 as that of the base expressions, but the range space
2571 can be any space. In case the base expressions have
2572 a set space, the corresponding multiple expression
2573 also has a set space.
2574 Objects of the value type do not have an associated space.
2575 The space of a multiple value is therefore always a set space.
2576 Similarly, the space of a multiple union piecewise
2577 affine expression is always a set space.
2579 The multiple expression types defined by C<isl>
2580 are C<isl_multi_val>, C<isl_multi_aff>, C<isl_multi_pw_aff>,
2581 C<isl_multi_union_pw_aff>.
2583 A multiple expression with the value zero for
2584 each output (or set) dimension can be created
2585 using the following functions.
2587 #include <isl/val.h>
2588 __isl_give isl_multi_val *isl_multi_val_zero(
2589 __isl_take isl_space *space);
2591 #include <isl/aff.h>
2592 __isl_give isl_multi_aff *isl_multi_aff_zero(
2593 __isl_take isl_space *space);
2594 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_zero(
2595 __isl_take isl_space *space);
2596 __isl_give isl_multi_union_pw_aff *
2597 isl_multi_union_pw_aff_zero(
2598 __isl_take isl_space *space);
2600 Since there is no canonical way of representing a zero
2601 value of type C<isl_union_pw_aff>, the space passed
2602 to C<isl_multi_union_pw_aff_zero> needs to be zero-dimensional.
2604 An identity function can be created using the following
2605 functions. The space needs to be that of a relation
2606 with the same number of input and output dimensions.
2608 #include <isl/aff.h>
2609 __isl_give isl_multi_aff *isl_multi_aff_identity(
2610 __isl_take isl_space *space);
2611 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_identity(
2612 __isl_take isl_space *space);
2614 A function that performs a projection on a universe
2615 relation or set can be created using the following functions.
2616 See also the corresponding
2617 projection operations in L</"Unary Operations">.
2619 #include <isl/aff.h>
2620 __isl_give isl_multi_aff *isl_multi_aff_domain_map(
2621 __isl_take isl_space *space);
2622 __isl_give isl_multi_aff *isl_multi_aff_range_map(
2623 __isl_take isl_space *space);
2624 __isl_give isl_multi_aff *isl_multi_aff_project_out_map(
2625 __isl_take isl_space *space,
2626 enum isl_dim_type type,
2627 unsigned first, unsigned n);
2629 A multiple expression can be created from a single
2630 base expression using the following functions.
2631 The space of the created multiple expression is the same
2632 as that of the base expression, except for
2633 C<isl_multi_union_pw_aff_from_union_pw_aff> where the input
2634 lives in a parameter space and the output lives
2635 in a single-dimensional set space.
2637 #include <isl/aff.h>
2638 __isl_give isl_multi_aff *isl_multi_aff_from_aff(
2639 __isl_take isl_aff *aff);
2640 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_pw_aff(
2641 __isl_take isl_pw_aff *pa);
2642 __isl_give isl_multi_union_pw_aff *
2643 isl_multi_union_pw_aff_from_union_pw_aff(
2644 __isl_take isl_union_pw_aff *upa);
2646 A multiple expression can be created from a list
2647 of base expression in a specified space.
2648 The domain of this space needs to be the same
2649 as the domains of the base expressions in the list.
2650 If the base expressions have a set space (or no associated space),
2651 then this space also needs to be a set space.
2653 #include <isl/val.h>
2654 __isl_give isl_multi_val *isl_multi_val_from_val_list(
2655 __isl_take isl_space *space,
2656 __isl_take isl_val_list *list);
2658 #include <isl/aff.h>
2659 __isl_give isl_multi_aff *isl_multi_aff_from_aff_list(
2660 __isl_take isl_space *space,
2661 __isl_take isl_aff_list *list);
2662 __isl_give isl_multi_union_pw_aff *
2663 isl_multi_union_pw_aff_from_union_pw_aff_list(
2664 __isl_take isl_space *space,
2665 __isl_take isl_union_pw_aff_list *list);
2667 As a convenience, a multiple piecewise expression can
2668 also be created from a multiple expression.
2669 Each piecewise expression in the result has a single
2672 #include <isl/aff.h>
2673 __isl_give isl_multi_pw_aff *
2674 isl_multi_pw_aff_from_multi_aff(
2675 __isl_take isl_multi_aff *ma);
2677 Similarly, a multiple union expression can be
2678 created from a multiple expression.
2680 #include <isl/aff.h>
2681 __isl_give isl_multi_union_pw_aff *
2682 isl_multi_union_pw_aff_from_multi_aff(
2683 __isl_take isl_multi_aff *ma);
2684 __isl_give isl_multi_union_pw_aff *
2685 isl_multi_union_pw_aff_from_multi_pw_aff(
2686 __isl_take isl_multi_pw_aff *mpa);
2688 A multiple quasi-affine expression can be created from
2689 a multiple value with a given domain space using the following
2692 #include <isl/aff.h>
2693 __isl_give isl_multi_aff *
2694 isl_multi_aff_multi_val_on_space(
2695 __isl_take isl_space *space,
2696 __isl_take isl_multi_val *mv);
2699 a multiple union piecewise affine expression can be created from
2700 a multiple value with a given domain or
2701 a multiple affine expression with a given domain
2702 using the following functions.
2704 #include <isl/aff.h>
2705 __isl_give isl_multi_union_pw_aff *
2706 isl_multi_union_pw_aff_multi_val_on_domain(
2707 __isl_take isl_union_set *domain,
2708 __isl_take isl_multi_val *mv);
2709 __isl_give isl_multi_union_pw_aff *
2710 isl_multi_union_pw_aff_multi_aff_on_domain(
2711 __isl_take isl_union_set *domain,
2712 __isl_take isl_multi_aff *ma);
2714 Multiple expressions can be copied and freed using
2715 the following functions.
2717 #include <isl/val.h>
2718 __isl_give isl_multi_val *isl_multi_val_copy(
2719 __isl_keep isl_multi_val *mv);
2720 __isl_null isl_multi_val *isl_multi_val_free(
2721 __isl_take isl_multi_val *mv);
2723 #include <isl/aff.h>
2724 __isl_give isl_multi_aff *isl_multi_aff_copy(
2725 __isl_keep isl_multi_aff *maff);
2726 __isl_null isl_multi_aff *isl_multi_aff_free(
2727 __isl_take isl_multi_aff *maff);
2728 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_copy(
2729 __isl_keep isl_multi_pw_aff *mpa);
2730 __isl_null isl_multi_pw_aff *isl_multi_pw_aff_free(
2731 __isl_take isl_multi_pw_aff *mpa);
2732 __isl_give isl_multi_union_pw_aff *
2733 isl_multi_union_pw_aff_copy(
2734 __isl_keep isl_multi_union_pw_aff *mupa);
2735 __isl_null isl_multi_union_pw_aff *
2736 isl_multi_union_pw_aff_free(
2737 __isl_take isl_multi_union_pw_aff *mupa);
2739 The base expression at a given position of a multiple
2740 expression can be extracted using the following functions.
2742 #include <isl/val.h>
2743 __isl_give isl_val *isl_multi_val_get_val(
2744 __isl_keep isl_multi_val *mv, int pos);
2746 #include <isl/aff.h>
2747 __isl_give isl_aff *isl_multi_aff_get_aff(
2748 __isl_keep isl_multi_aff *multi, int pos);
2749 __isl_give isl_pw_aff *isl_multi_pw_aff_get_pw_aff(
2750 __isl_keep isl_multi_pw_aff *mpa, int pos);
2751 __isl_give isl_union_pw_aff *
2752 isl_multi_union_pw_aff_get_union_pw_aff(
2753 __isl_keep isl_multi_union_pw_aff *mupa, int pos);
2755 It can be replaced using the following functions.
2757 #include <isl/val.h>
2758 __isl_give isl_multi_val *isl_multi_val_set_val(
2759 __isl_take isl_multi_val *mv, int pos,
2760 __isl_take isl_val *val);
2762 #include <isl/aff.h>
2763 __isl_give isl_multi_aff *isl_multi_aff_set_aff(
2764 __isl_take isl_multi_aff *multi, int pos,
2765 __isl_take isl_aff *aff);
2766 __isl_give isl_multi_union_pw_aff *
2767 isl_multi_union_pw_aff_set_union_pw_aff(
2768 __isl_take isl_multi_union_pw_aff *mupa, int pos,
2769 __isl_take isl_union_pw_aff *upa);
2771 As a convenience, a sequence of base expressions that have
2772 their domains in a given space can be extracted from a sequence
2773 of union expressions using the following function.
2775 #include <isl/aff.h>
2776 __isl_give isl_multi_pw_aff *
2777 isl_multi_union_pw_aff_extract_multi_pw_aff(
2778 __isl_keep isl_multi_union_pw_aff *mupa,
2779 __isl_take isl_space *space);
2781 Note that there is a difference between C<isl_multi_union_pw_aff>
2782 and C<isl_union_pw_multi_aff> objects. The first is a sequence
2783 of unions of piecewise expressions, while the second is a union
2784 of piecewise sequences. In particular, multiple affine expressions
2785 in an C<isl_union_pw_multi_aff> may live in different spaces,
2786 while there is only a single multiple expression in
2787 an C<isl_multi_union_pw_aff>, which can therefore only live
2788 in a single space. This means that not every
2789 C<isl_union_pw_multi_aff> can be converted to
2790 an C<isl_multi_union_pw_aff>. Conversely, a zero-dimensional
2791 C<isl_multi_union_pw_aff> carries no information
2792 about any possible domain and therefore cannot be converted
2793 to an C<isl_union_pw_multi_aff>. Moreover, the elements
2794 of an C<isl_multi_union_pw_aff> may be defined over different domains,
2795 while each multiple expression inside an C<isl_union_pw_multi_aff>
2796 has a single domain. The conversion of an C<isl_union_pw_multi_aff>
2797 of dimension greater than one may therefore not be exact.
2798 The following functions can
2799 be used to perform these conversions when they are possible.
2801 #include <isl/aff.h>
2802 __isl_give isl_multi_union_pw_aff *
2803 isl_multi_union_pw_aff_from_union_pw_multi_aff(
2804 __isl_take isl_union_pw_multi_aff *upma);
2805 __isl_give isl_union_pw_multi_aff *
2806 isl_union_pw_multi_aff_from_multi_union_pw_aff(
2807 __isl_take isl_multi_union_pw_aff *mupa);
2809 =head3 Piecewise Expressions
2811 A piecewise expression is an expression that is described
2812 using zero or more base expression defined over the same
2813 number of cells in the domain space of the base expressions.
2814 All base expressions are defined over the same
2815 domain space and the cells are disjoint.
2816 The space of a piecewise expression is the same as
2817 that of the base expressions.
2818 If the union of the cells is a strict subset of the domain
2819 space, then the value of the piecewise expression outside
2820 this union is different for types derived from quasi-affine
2821 expressions and those derived from quasipolynomials.
2822 Piecewise expressions derived from quasi-affine expressions
2823 are considered to be undefined outside the union of their cells.
2824 Piecewise expressions derived from quasipolynomials
2825 are considered to be zero outside the union of their cells.
2827 Piecewise quasipolynomials are mainly used by the C<barvinok>
2828 library for representing the number of elements in a parametric set or map.
2829 For example, the piecewise quasipolynomial
2831 [n] -> { [x] -> ((1 + n) - x) : x <= n and x >= 0 }
2833 represents the number of points in the map
2835 [n] -> { [x] -> [y] : x,y >= 0 and 0 <= x + y <= n }
2837 The piecewise expression types defined by C<isl>
2838 are C<isl_pw_aff>, C<isl_pw_multi_aff>,
2839 C<isl_pw_qpolynomial> and C<isl_pw_qpolynomial_fold>.
2841 A piecewise expression with no cells can be created using
2842 the following functions.
2844 #include <isl/aff.h>
2845 __isl_give isl_pw_aff *isl_pw_aff_empty(
2846 __isl_take isl_space *space);
2847 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_empty(
2848 __isl_take isl_space *space);
2850 A piecewise expression with a single universe cell can be
2851 created using the following functions.
2853 #include <isl/aff.h>
2854 __isl_give isl_pw_aff *isl_pw_aff_from_aff(
2855 __isl_take isl_aff *aff);
2856 __isl_give isl_pw_multi_aff *
2857 isl_pw_multi_aff_from_multi_aff(
2858 __isl_take isl_multi_aff *ma);
2860 #include <isl/polynomial.h>
2861 __isl_give isl_pw_qpolynomial *
2862 isl_pw_qpolynomial_from_qpolynomial(
2863 __isl_take isl_qpolynomial *qp);
2865 A piecewise expression with a single specified cell can be
2866 created using the following functions.
2868 #include <isl/aff.h>
2869 __isl_give isl_pw_aff *isl_pw_aff_alloc(
2870 __isl_take isl_set *set, __isl_take isl_aff *aff);
2871 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_alloc(
2872 __isl_take isl_set *set,
2873 __isl_take isl_multi_aff *maff);
2875 #include <isl/polynomial.h>
2876 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_alloc(
2877 __isl_take isl_set *set,
2878 __isl_take isl_qpolynomial *qp);
2880 The following convenience functions first create a base expression and
2881 then create a piecewise expression over a universe domain.
2883 #include <isl/aff.h>
2884 __isl_give isl_pw_aff *isl_pw_aff_zero_on_domain(
2885 __isl_take isl_local_space *ls);
2886 __isl_give isl_pw_aff *isl_pw_aff_var_on_domain(
2887 __isl_take isl_local_space *ls,
2888 enum isl_dim_type type, unsigned pos);
2889 __isl_give isl_pw_aff *isl_pw_aff_nan_on_domain(
2890 __isl_take isl_local_space *ls);
2891 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_zero(
2892 __isl_take isl_space *space);
2893 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_identity(
2894 __isl_take isl_space *space);
2895 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_map(
2896 __isl_take isl_space *space);
2897 __isl_give isl_pw_multi_aff *
2898 isl_pw_multi_aff_project_out_map(
2899 __isl_take isl_space *space,
2900 enum isl_dim_type type,
2901 unsigned first, unsigned n);
2903 #include <isl/polynomial.h>
2904 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_zero(
2905 __isl_take isl_space *space);
2907 The following convenience functions first create a base expression and
2908 then create a piecewise expression over a given domain.
2910 #include <isl/aff.h>
2911 __isl_give isl_pw_aff *isl_pw_aff_val_on_domain(
2912 __isl_take isl_set *domain,
2913 __isl_take isl_val *v);
2914 __isl_give isl_pw_multi_aff *
2915 isl_pw_multi_aff_multi_val_on_domain(
2916 __isl_take isl_set *domain,
2917 __isl_take isl_multi_val *mv);
2919 As a convenience, a piecewise multiple expression can
2920 also be created from a piecewise expression.
2921 Each multiple expression in the result is derived
2922 from the corresponding base expression.
2924 #include <isl/aff.h>
2925 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_pw_aff(
2926 __isl_take isl_pw_aff *pa);
2928 Similarly, a piecewise quasipolynomial can be
2929 created from a piecewise quasi-affine expression using
2930 the following function.
2932 #include <isl/polynomial.h>
2933 __isl_give isl_pw_qpolynomial *
2934 isl_pw_qpolynomial_from_pw_aff(
2935 __isl_take isl_pw_aff *pwaff);
2937 Piecewise expressions can be copied and freed using the following functions.
2939 #include <isl/aff.h>
2940 __isl_give isl_pw_aff *isl_pw_aff_copy(
2941 __isl_keep isl_pw_aff *pwaff);
2942 __isl_null isl_pw_aff *isl_pw_aff_free(
2943 __isl_take isl_pw_aff *pwaff);
2944 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_copy(
2945 __isl_keep isl_pw_multi_aff *pma);
2946 __isl_null isl_pw_multi_aff *isl_pw_multi_aff_free(
2947 __isl_take isl_pw_multi_aff *pma);
2949 #include <isl/polynomial.h>
2950 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_copy(
2951 __isl_keep isl_pw_qpolynomial *pwqp);
2952 __isl_null isl_pw_qpolynomial *isl_pw_qpolynomial_free(
2953 __isl_take isl_pw_qpolynomial *pwqp);
2954 __isl_give isl_pw_qpolynomial_fold *
2955 isl_pw_qpolynomial_fold_copy(
2956 __isl_keep isl_pw_qpolynomial_fold *pwf);
2957 __isl_null isl_pw_qpolynomial_fold *
2958 isl_pw_qpolynomial_fold_free(
2959 __isl_take isl_pw_qpolynomial_fold *pwf);
2961 To iterate over the different cells of a piecewise expression,
2962 use the following functions.
2964 #include <isl/aff.h>
2965 int isl_pw_aff_is_empty(__isl_keep isl_pw_aff *pwaff);
2966 int isl_pw_aff_n_piece(__isl_keep isl_pw_aff *pwaff);
2967 int isl_pw_aff_foreach_piece(__isl_keep isl_pw_aff *pwaff,
2968 int (*fn)(__isl_take isl_set *set,
2969 __isl_take isl_aff *aff,
2970 void *user), void *user);
2971 int isl_pw_multi_aff_foreach_piece(
2972 __isl_keep isl_pw_multi_aff *pma,
2973 int (*fn)(__isl_take isl_set *set,
2974 __isl_take isl_multi_aff *maff,
2975 void *user), void *user);
2977 #include <isl/polynomial.h>
2978 int isl_pw_qpolynomial_foreach_piece(
2979 __isl_keep isl_pw_qpolynomial *pwqp,
2980 int (*fn)(__isl_take isl_set *set,
2981 __isl_take isl_qpolynomial *qp,
2982 void *user), void *user);
2983 int isl_pw_qpolynomial_foreach_lifted_piece(
2984 __isl_keep isl_pw_qpolynomial *pwqp,
2985 int (*fn)(__isl_take isl_set *set,
2986 __isl_take isl_qpolynomial *qp,
2987 void *user), void *user);
2988 int isl_pw_qpolynomial_fold_foreach_piece(
2989 __isl_keep isl_pw_qpolynomial_fold *pwf,
2990 int (*fn)(__isl_take isl_set *set,
2991 __isl_take isl_qpolynomial_fold *fold,
2992 void *user), void *user);
2993 int isl_pw_qpolynomial_fold_foreach_lifted_piece(
2994 __isl_keep isl_pw_qpolynomial_fold *pwf,
2995 int (*fn)(__isl_take isl_set *set,
2996 __isl_take isl_qpolynomial_fold *fold,
2997 void *user), void *user);
2999 As usual, the function C<fn> should return C<0> on success
3000 and C<-1> on failure. The difference between
3001 C<isl_pw_qpolynomial_foreach_piece> and
3002 C<isl_pw_qpolynomial_foreach_lifted_piece> is that
3003 C<isl_pw_qpolynomial_foreach_lifted_piece> will first
3004 compute unique representations for all existentially quantified
3005 variables and then turn these existentially quantified variables
3006 into extra set variables, adapting the associated quasipolynomial
3007 accordingly. This means that the C<set> passed to C<fn>
3008 will not have any existentially quantified variables, but that
3009 the dimensions of the sets may be different for different
3010 invocations of C<fn>.
3011 Similarly for C<isl_pw_qpolynomial_fold_foreach_piece>
3012 and C<isl_pw_qpolynomial_fold_foreach_lifted_piece>.
3014 A piecewise expression consisting of the expressions at a given
3015 position of a piecewise multiple expression can be extracted
3016 using the following function.
3018 #include <isl/aff.h>
3019 __isl_give isl_pw_aff *isl_pw_multi_aff_get_pw_aff(
3020 __isl_keep isl_pw_multi_aff *pma, int pos);
3022 These expressions can be replaced using the following function.
3024 #include <isl/aff.h>
3025 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_pw_aff(
3026 __isl_take isl_pw_multi_aff *pma, unsigned pos,
3027 __isl_take isl_pw_aff *pa);
3029 Note that there is a difference between C<isl_multi_pw_aff> and
3030 C<isl_pw_multi_aff> objects. The first is a sequence of piecewise
3031 affine expressions, while the second is a piecewise sequence
3032 of affine expressions. In particular, each of the piecewise
3033 affine expressions in an C<isl_multi_pw_aff> may have a different
3034 domain, while all multiple expressions associated to a cell
3035 in an C<isl_pw_multi_aff> have the same domain.
3036 It is possible to convert between the two, but when converting
3037 an C<isl_multi_pw_aff> to an C<isl_pw_multi_aff>, the domain
3038 of the result is the intersection of the domains of the input.
3039 The reverse conversion is exact.
3041 #include <isl/aff.h>
3042 __isl_give isl_pw_multi_aff *
3043 isl_pw_multi_aff_from_multi_pw_aff(
3044 __isl_take isl_multi_pw_aff *mpa);
3045 __isl_give isl_multi_pw_aff *
3046 isl_multi_pw_aff_from_pw_multi_aff(
3047 __isl_take isl_pw_multi_aff *pma);
3049 =head3 Union Expressions
3051 A union expression collects base expressions defined
3052 over different domains. The space of a union expression
3053 is that of the shared parameter space.
3055 The union expression types defined by C<isl>
3056 are C<isl_union_pw_aff>, C<isl_union_pw_multi_aff>,
3057 C<isl_union_pw_qpolynomial> and C<isl_union_pw_qpolynomial_fold>.
3059 An empty union expression can be created using the following functions.
3061 #include <isl/aff.h>
3062 __isl_give isl_union_pw_aff *isl_union_pw_aff_empty(
3063 __isl_take isl_space *space);
3064 __isl_give isl_union_pw_multi_aff *
3065 isl_union_pw_multi_aff_empty(
3066 __isl_take isl_space *space);
3068 #include <isl/polynomial.h>
3069 __isl_give isl_union_pw_qpolynomial *
3070 isl_union_pw_qpolynomial_zero(
3071 __isl_take isl_space *space);
3073 A union expression containing a single base expression
3074 can be created using the following functions.
3076 #include <isl/aff.h>
3077 __isl_give isl_union_pw_aff *
3078 isl_union_pw_aff_from_pw_aff(
3079 __isl_take isl_pw_aff *pa);
3080 __isl_give isl_union_pw_multi_aff *
3081 isl_union_pw_multi_aff_from_aff(
3082 __isl_take isl_aff *aff);
3083 __isl_give isl_union_pw_multi_aff *
3084 isl_union_pw_multi_aff_from_pw_multi_aff(
3085 __isl_take isl_pw_multi_aff *pma);
3087 #include <isl/polynomial.h>
3088 __isl_give isl_union_pw_qpolynomial *
3089 isl_union_pw_qpolynomial_from_pw_qpolynomial(
3090 __isl_take isl_pw_qpolynomial *pwqp);
3092 The following functions create a base expression on each
3093 of the sets in the union set and collect the results.
3095 #include <isl/aff.h>
3096 __isl_give isl_union_pw_multi_aff *
3097 isl_union_pw_multi_aff_from_union_pw_aff(
3098 __isl_take isl_union_pw_aff *upa);
3099 __isl_give isl_union_pw_aff *
3100 isl_union_pw_multi_aff_get_union_pw_aff(
3101 __isl_keep isl_union_pw_multi_aff *upma, int pos);
3102 __isl_give isl_union_pw_aff *
3103 isl_union_pw_aff_val_on_domain(
3104 __isl_take isl_union_set *domain,
3105 __isl_take isl_val *v);
3106 __isl_give isl_union_pw_multi_aff *
3107 isl_union_pw_multi_aff_multi_val_on_domain(
3108 __isl_take isl_union_set *domain,
3109 __isl_take isl_multi_val *mv);
3111 An C<isl_union_pw_aff> that is equal to a (parametric) affine
3112 expression on a given domain can be created using the following
3115 #include <isl/aff.h>
3116 __isl_give isl_union_pw_aff *
3117 isl_union_pw_aff_aff_on_domain(
3118 __isl_take isl_union_set *domain,
3119 __isl_take isl_aff *aff);
3121 A base expression can be added to a union expression using
3122 the following functions.
3124 #include <isl/aff.h>
3125 __isl_give isl_union_pw_aff *
3126 isl_union_pw_aff_add_pw_aff(
3127 __isl_take isl_union_pw_aff *upa,
3128 __isl_take isl_pw_aff *pa);
3129 __isl_give isl_union_pw_multi_aff *
3130 isl_union_pw_multi_aff_add_pw_multi_aff(
3131 __isl_take isl_union_pw_multi_aff *upma,
3132 __isl_take isl_pw_multi_aff *pma);
3134 #include <isl/polynomial.h>
3135 __isl_give isl_union_pw_qpolynomial *
3136 isl_union_pw_qpolynomial_add_pw_qpolynomial(
3137 __isl_take isl_union_pw_qpolynomial *upwqp,
3138 __isl_take isl_pw_qpolynomial *pwqp);
3140 Union expressions can be copied and freed using
3141 the following functions.
3143 #include <isl/aff.h>
3144 __isl_give isl_union_pw_aff *isl_union_pw_aff_copy(
3145 __isl_keep isl_union_pw_aff *upa);
3146 __isl_null isl_union_pw_aff *isl_union_pw_aff_free(
3147 __isl_take isl_union_pw_aff *upa);
3148 __isl_give isl_union_pw_multi_aff *
3149 isl_union_pw_multi_aff_copy(
3150 __isl_keep isl_union_pw_multi_aff *upma);
3151 __isl_null isl_union_pw_multi_aff *
3152 isl_union_pw_multi_aff_free(
3153 __isl_take isl_union_pw_multi_aff *upma);
3155 #include <isl/polynomial.h>
3156 __isl_give isl_union_pw_qpolynomial *
3157 isl_union_pw_qpolynomial_copy(
3158 __isl_keep isl_union_pw_qpolynomial *upwqp);
3159 __isl_null isl_union_pw_qpolynomial *
3160 isl_union_pw_qpolynomial_free(
3161 __isl_take isl_union_pw_qpolynomial *upwqp);
3162 __isl_give isl_union_pw_qpolynomial_fold *
3163 isl_union_pw_qpolynomial_fold_copy(
3164 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
3165 __isl_null isl_union_pw_qpolynomial_fold *
3166 isl_union_pw_qpolynomial_fold_free(
3167 __isl_take isl_union_pw_qpolynomial_fold *upwf);
3169 To iterate over the base expressions in a union expression,
3170 use the following functions.
3172 #include <isl/aff.h>
3173 int isl_union_pw_aff_n_pw_aff(
3174 __isl_keep isl_union_pw_aff *upa);
3175 int isl_union_pw_aff_foreach_pw_aff(
3176 __isl_keep isl_union_pw_aff *upa,
3177 int (*fn)(__isl_take isl_pw_aff *ma, void *user),
3179 int isl_union_pw_multi_aff_n_pw_multi_aff(
3180 __isl_keep isl_union_pw_multi_aff *upma);
3181 int isl_union_pw_multi_aff_foreach_pw_multi_aff(
3182 __isl_keep isl_union_pw_multi_aff *upma,
3183 int (*fn)(__isl_take isl_pw_multi_aff *pma,
3184 void *user), void *user);
3186 #include <isl/polynomial.h>
3187 int isl_union_pw_qpolynomial_n_pw_qpolynomial(
3188 __isl_keep isl_union_pw_qpolynomial *upwqp);
3189 int isl_union_pw_qpolynomial_foreach_pw_qpolynomial(
3190 __isl_keep isl_union_pw_qpolynomial *upwqp,
3191 int (*fn)(__isl_take isl_pw_qpolynomial *pwqp,
3192 void *user), void *user);
3193 int isl_union_pw_qpolynomial_fold_n_pw_qpolynomial_fold(
3194 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
3195 int isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(
3196 __isl_keep isl_union_pw_qpolynomial_fold *upwf,
3197 int (*fn)(__isl_take isl_pw_qpolynomial_fold *pwf,
3198 void *user), void *user);
3200 To extract the base expression in a given space from a union, use
3201 the following functions.
3203 #include <isl/aff.h>
3204 __isl_give isl_pw_aff *isl_union_pw_aff_extract_pw_aff(
3205 __isl_keep isl_union_pw_aff *upa,
3206 __isl_take isl_space *space);
3207 __isl_give isl_pw_multi_aff *
3208 isl_union_pw_multi_aff_extract_pw_multi_aff(
3209 __isl_keep isl_union_pw_multi_aff *upma,
3210 __isl_take isl_space *space);
3212 #include <isl/polynomial.h>
3213 __isl_give isl_pw_qpolynomial *
3214 isl_union_pw_qpolynomial_extract_pw_qpolynomial(
3215 __isl_keep isl_union_pw_qpolynomial *upwqp,
3216 __isl_take isl_space *space);
3218 =head2 Input and Output
3220 For set and relation,
3221 C<isl> supports its own input/output format, which is similar
3222 to the C<Omega> format, but also supports the C<PolyLib> format
3224 For other object types, typically only an C<isl> format is supported.
3226 =head3 C<isl> format
3228 The C<isl> format is similar to that of C<Omega>, but has a different
3229 syntax for describing the parameters and allows for the definition
3230 of an existentially quantified variable as the integer division
3231 of an affine expression.
3232 For example, the set of integers C<i> between C<0> and C<n>
3233 such that C<i % 10 <= 6> can be described as
3235 [n] -> { [i] : exists (a = [i/10] : 0 <= i and i <= n and
3238 A set or relation can have several disjuncts, separated
3239 by the keyword C<or>. Each disjunct is either a conjunction
3240 of constraints or a projection (C<exists>) of a conjunction
3241 of constraints. The constraints are separated by the keyword
3244 =head3 C<PolyLib> format
3246 If the represented set is a union, then the first line
3247 contains a single number representing the number of disjuncts.
3248 Otherwise, a line containing the number C<1> is optional.
3250 Each disjunct is represented by a matrix of constraints.
3251 The first line contains two numbers representing
3252 the number of rows and columns,
3253 where the number of rows is equal to the number of constraints
3254 and the number of columns is equal to two plus the number of variables.
3255 The following lines contain the actual rows of the constraint matrix.
3256 In each row, the first column indicates whether the constraint
3257 is an equality (C<0>) or inequality (C<1>). The final column
3258 corresponds to the constant term.
3260 If the set is parametric, then the coefficients of the parameters
3261 appear in the last columns before the constant column.
3262 The coefficients of any existentially quantified variables appear
3263 between those of the set variables and those of the parameters.
3265 =head3 Extended C<PolyLib> format
3267 The extended C<PolyLib> format is nearly identical to the
3268 C<PolyLib> format. The only difference is that the line
3269 containing the number of rows and columns of a constraint matrix
3270 also contains four additional numbers:
3271 the number of output dimensions, the number of input dimensions,
3272 the number of local dimensions (i.e., the number of existentially
3273 quantified variables) and the number of parameters.
3274 For sets, the number of ``output'' dimensions is equal
3275 to the number of set dimensions, while the number of ``input''
3280 Objects can be read from input using the following functions.
3282 #include <isl/val.h>
3283 __isl_give isl_val *isl_val_read_from_str(isl_ctx *ctx,
3285 __isl_give isl_multi_val *isl_multi_val_read_from_str(
3286 isl_ctx *ctx, const char *str);
3288 #include <isl/set.h>
3289 __isl_give isl_basic_set *isl_basic_set_read_from_file(
3290 isl_ctx *ctx, FILE *input);
3291 __isl_give isl_basic_set *isl_basic_set_read_from_str(
3292 isl_ctx *ctx, const char *str);
3293 __isl_give isl_set *isl_set_read_from_file(isl_ctx *ctx,
3295 __isl_give isl_set *isl_set_read_from_str(isl_ctx *ctx,
3298 #include <isl/map.h>
3299 __isl_give isl_basic_map *isl_basic_map_read_from_file(
3300 isl_ctx *ctx, FILE *input);
3301 __isl_give isl_basic_map *isl_basic_map_read_from_str(
3302 isl_ctx *ctx, const char *str);
3303 __isl_give isl_map *isl_map_read_from_file(
3304 isl_ctx *ctx, FILE *input);
3305 __isl_give isl_map *isl_map_read_from_str(isl_ctx *ctx,
3308 #include <isl/union_set.h>
3309 __isl_give isl_union_set *isl_union_set_read_from_file(
3310 isl_ctx *ctx, FILE *input);
3311 __isl_give isl_union_set *isl_union_set_read_from_str(
3312 isl_ctx *ctx, const char *str);
3314 #include <isl/union_map.h>
3315 __isl_give isl_union_map *isl_union_map_read_from_file(
3316 isl_ctx *ctx, FILE *input);
3317 __isl_give isl_union_map *isl_union_map_read_from_str(
3318 isl_ctx *ctx, const char *str);
3320 #include <isl/aff.h>
3321 __isl_give isl_aff *isl_aff_read_from_str(
3322 isl_ctx *ctx, const char *str);
3323 __isl_give isl_multi_aff *isl_multi_aff_read_from_str(
3324 isl_ctx *ctx, const char *str);
3325 __isl_give isl_pw_aff *isl_pw_aff_read_from_str(
3326 isl_ctx *ctx, const char *str);
3327 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_read_from_str(
3328 isl_ctx *ctx, const char *str);
3329 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_read_from_str(
3330 isl_ctx *ctx, const char *str);
3331 __isl_give isl_union_pw_multi_aff *
3332 isl_union_pw_multi_aff_read_from_str(
3333 isl_ctx *ctx, const char *str);
3334 __isl_give isl_multi_union_pw_aff *
3335 isl_multi_union_pw_aff_read_from_str(
3336 isl_ctx *ctx, const char *str);
3338 #include <isl/polynomial.h>
3339 __isl_give isl_union_pw_qpolynomial *
3340 isl_union_pw_qpolynomial_read_from_str(
3341 isl_ctx *ctx, const char *str);
3343 For sets and relations,
3344 the input format is autodetected and may be either the C<PolyLib> format
3345 or the C<isl> format.
3349 Before anything can be printed, an C<isl_printer> needs to
3352 __isl_give isl_printer *isl_printer_to_file(isl_ctx *ctx,
3354 __isl_give isl_printer *isl_printer_to_str(isl_ctx *ctx);
3355 __isl_null isl_printer *isl_printer_free(
3356 __isl_take isl_printer *printer);
3357 __isl_give char *isl_printer_get_str(
3358 __isl_keep isl_printer *printer);
3360 The printer can be inspected using the following functions.
3362 FILE *isl_printer_get_file(
3363 __isl_keep isl_printer *printer);
3364 int isl_printer_get_output_format(
3365 __isl_keep isl_printer *p);
3366 int isl_printer_get_yaml_style(__isl_keep isl_printer *p);
3368 The behavior of the printer can be modified in various ways
3370 __isl_give isl_printer *isl_printer_set_output_format(
3371 __isl_take isl_printer *p, int output_format);
3372 __isl_give isl_printer *isl_printer_set_indent(
3373 __isl_take isl_printer *p, int indent);
3374 __isl_give isl_printer *isl_printer_set_indent_prefix(
3375 __isl_take isl_printer *p, const char *prefix);
3376 __isl_give isl_printer *isl_printer_indent(
3377 __isl_take isl_printer *p, int indent);
3378 __isl_give isl_printer *isl_printer_set_prefix(
3379 __isl_take isl_printer *p, const char *prefix);
3380 __isl_give isl_printer *isl_printer_set_suffix(
3381 __isl_take isl_printer *p, const char *suffix);
3382 __isl_give isl_printer *isl_printer_set_yaml_style(
3383 __isl_take isl_printer *p, int yaml_style);
3385 The C<output_format> may be either C<ISL_FORMAT_ISL>, C<ISL_FORMAT_OMEGA>,
3386 C<ISL_FORMAT_POLYLIB>, C<ISL_FORMAT_EXT_POLYLIB> or C<ISL_FORMAT_LATEX>
3387 and defaults to C<ISL_FORMAT_ISL>.
3388 Each line in the output is prefixed by C<indent_prefix>,
3389 indented by C<indent> (set by C<isl_printer_set_indent>) spaces
3390 (default: 0), prefixed by C<prefix> and suffixed by C<suffix>.
3391 In the C<PolyLib> format output,
3392 the coefficients of the existentially quantified variables
3393 appear between those of the set variables and those
3395 The function C<isl_printer_indent> increases the indentation
3396 by the specified amount (which may be negative).
3397 The YAML style may be either C<ISL_YAML_STYLE_BLOCK> or
3398 C<ISL_YAML_STYLE_FLOW> and when we are printing something
3401 To actually print something, use
3403 #include <isl/printer.h>
3404 __isl_give isl_printer *isl_printer_print_double(
3405 __isl_take isl_printer *p, double d);
3407 #include <isl/val.h>
3408 __isl_give isl_printer *isl_printer_print_val(
3409 __isl_take isl_printer *p, __isl_keep isl_val *v);
3411 #include <isl/set.h>
3412 __isl_give isl_printer *isl_printer_print_basic_set(
3413 __isl_take isl_printer *printer,
3414 __isl_keep isl_basic_set *bset);
3415 __isl_give isl_printer *isl_printer_print_set(
3416 __isl_take isl_printer *printer,
3417 __isl_keep isl_set *set);
3419 #include <isl/map.h>
3420 __isl_give isl_printer *isl_printer_print_basic_map(
3421 __isl_take isl_printer *printer,
3422 __isl_keep isl_basic_map *bmap);
3423 __isl_give isl_printer *isl_printer_print_map(
3424 __isl_take isl_printer *printer,
3425 __isl_keep isl_map *map);
3427 #include <isl/union_set.h>
3428 __isl_give isl_printer *isl_printer_print_union_set(
3429 __isl_take isl_printer *p,
3430 __isl_keep isl_union_set *uset);
3432 #include <isl/union_map.h>
3433 __isl_give isl_printer *isl_printer_print_union_map(
3434 __isl_take isl_printer *p,
3435 __isl_keep isl_union_map *umap);
3437 #include <isl/val.h>
3438 __isl_give isl_printer *isl_printer_print_multi_val(
3439 __isl_take isl_printer *p,
3440 __isl_keep isl_multi_val *mv);
3442 #include <isl/aff.h>
3443 __isl_give isl_printer *isl_printer_print_aff(
3444 __isl_take isl_printer *p, __isl_keep isl_aff *aff);
3445 __isl_give isl_printer *isl_printer_print_multi_aff(
3446 __isl_take isl_printer *p,
3447 __isl_keep isl_multi_aff *maff);
3448 __isl_give isl_printer *isl_printer_print_pw_aff(
3449 __isl_take isl_printer *p,
3450 __isl_keep isl_pw_aff *pwaff);
3451 __isl_give isl_printer *isl_printer_print_pw_multi_aff(
3452 __isl_take isl_printer *p,
3453 __isl_keep isl_pw_multi_aff *pma);
3454 __isl_give isl_printer *isl_printer_print_multi_pw_aff(
3455 __isl_take isl_printer *p,
3456 __isl_keep isl_multi_pw_aff *mpa);
3457 __isl_give isl_printer *isl_printer_print_union_pw_aff(
3458 __isl_take isl_printer *p,
3459 __isl_keep isl_union_pw_aff *upa);
3460 __isl_give isl_printer *isl_printer_print_union_pw_multi_aff(
3461 __isl_take isl_printer *p,
3462 __isl_keep isl_union_pw_multi_aff *upma);
3463 __isl_give isl_printer *
3464 isl_printer_print_multi_union_pw_aff(
3465 __isl_take isl_printer *p,
3466 __isl_keep isl_multi_union_pw_aff *mupa);
3468 #include <isl/polynomial.h>
3469 __isl_give isl_printer *isl_printer_print_qpolynomial(
3470 __isl_take isl_printer *p,
3471 __isl_keep isl_qpolynomial *qp);
3472 __isl_give isl_printer *isl_printer_print_pw_qpolynomial(
3473 __isl_take isl_printer *p,
3474 __isl_keep isl_pw_qpolynomial *pwqp);
3475 __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial(
3476 __isl_take isl_printer *p,
3477 __isl_keep isl_union_pw_qpolynomial *upwqp);
3479 __isl_give isl_printer *
3480 isl_printer_print_pw_qpolynomial_fold(
3481 __isl_take isl_printer *p,
3482 __isl_keep isl_pw_qpolynomial_fold *pwf);
3483 __isl_give isl_printer *
3484 isl_printer_print_union_pw_qpolynomial_fold(
3485 __isl_take isl_printer *p,
3486 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
3488 For C<isl_printer_print_qpolynomial>,
3489 C<isl_printer_print_pw_qpolynomial> and
3490 C<isl_printer_print_pw_qpolynomial_fold>,
3491 the output format of the printer
3492 needs to be set to either C<ISL_FORMAT_ISL> or C<ISL_FORMAT_C>.
3493 For C<isl_printer_print_union_pw_qpolynomial> and
3494 C<isl_printer_print_union_pw_qpolynomial_fold>, only C<ISL_FORMAT_ISL>
3496 In case of printing in C<ISL_FORMAT_C>, the user may want
3497 to set the names of all dimensions first.
3499 C<isl> also provides limited support for printing YAML documents,
3500 just enough for the internal use for printing such documents.
3502 #include <isl/printer.h>
3503 __isl_give isl_printer *isl_printer_yaml_start_mapping(
3504 __isl_take isl_printer *p);
3505 __isl_give isl_printer *isl_printer_yaml_end_mapping(
3506 __isl_take isl_printer *p);
3507 __isl_give isl_printer *isl_printer_yaml_start_sequence(
3508 __isl_take isl_printer *p);
3509 __isl_give isl_printer *isl_printer_yaml_end_sequence(
3510 __isl_take isl_printer *p);
3511 __isl_give isl_printer *isl_printer_yaml_next(
3512 __isl_take isl_printer *p);
3514 A document is started by a call to either
3515 C<isl_printer_yaml_start_mapping> or C<isl_printer_yaml_start_sequence>.
3516 Anything printed to the printer after such a call belong to the
3517 first key of the mapping or the first element in the sequence.
3518 The function C<isl_printer_yaml_next> moves to the value if
3519 we are currently printing a mapping key, the next key if we
3520 are printing a value or the next element if we are printing
3521 an element in a sequence.
3522 Nested mappings and sequences are initiated by the same
3523 C<isl_printer_yaml_start_mapping> or C<isl_printer_yaml_start_sequence>.
3524 Each call to these functions needs to have a corresponding call to
3525 C<isl_printer_yaml_end_mapping> or C<isl_printer_yaml_end_sequence>.
3527 When called on a file printer, the following function flushes
3528 the file. When called on a string printer, the buffer is cleared.
3530 __isl_give isl_printer *isl_printer_flush(
3531 __isl_take isl_printer *p);
3533 Alternatively, a string representation can be obtained
3534 directly using the following functions, which always print
3537 #include <isl/space.h>
3538 __isl_give char *isl_space_to_str(
3539 __isl_keep isl_space *space);
3541 #include <isl/val.h>
3542 __isl_give char *isl_val_to_str(__isl_keep isl_val *v);
3543 __isl_give char *isl_multi_val_to_str(
3544 __isl_keep isl_multi_val *mv);
3546 #include <isl/set.h>
3547 __isl_give char *isl_set_to_str(
3548 __isl_keep isl_set *set);
3550 #include <isl/union_set.h>
3551 __isl_give char *isl_union_set_to_str(
3552 __isl_keep isl_union_set *uset);
3554 #include <isl/map.h>
3555 __isl_give char *isl_map_to_str(
3556 __isl_keep isl_map *map);
3558 #include <isl/union_map.h>
3559 __isl_give char *isl_union_map_to_str(
3560 __isl_keep isl_union_map *umap);
3562 #include <isl/aff.h>
3563 __isl_give char *isl_multi_aff_to_str(
3564 __isl_keep isl_multi_aff *aff);
3565 __isl_give char *isl_union_pw_aff_to_str(
3566 __isl_keep isl_union_pw_aff *upa);
3567 __isl_give char *isl_union_pw_multi_aff_to_str(
3568 __isl_keep isl_union_pw_multi_aff *upma);
3569 __isl_give char *isl_multi_union_pw_aff_to_str(
3570 __isl_keep isl_multi_union_pw_aff *mupa);
3574 =head3 Unary Properties
3580 The following functions test whether the given set or relation
3581 contains any integer points. The ``plain'' variants do not perform
3582 any computations, but simply check if the given set or relation
3583 is already known to be empty.
3585 int isl_basic_set_plain_is_empty(__isl_keep isl_basic_set *bset);
3586 int isl_basic_set_is_empty(__isl_keep isl_basic_set *bset);
3587 int isl_set_plain_is_empty(__isl_keep isl_set *set);
3588 int isl_set_is_empty(__isl_keep isl_set *set);
3589 int isl_union_set_is_empty(__isl_keep isl_union_set *uset);
3590 int isl_basic_map_plain_is_empty(__isl_keep isl_basic_map *bmap);
3591 int isl_basic_map_is_empty(__isl_keep isl_basic_map *bmap);
3592 int isl_map_plain_is_empty(__isl_keep isl_map *map);
3593 int isl_map_is_empty(__isl_keep isl_map *map);
3594 int isl_union_map_is_empty(__isl_keep isl_union_map *umap);
3596 =item * Universality
3598 int isl_basic_set_is_universe(__isl_keep isl_basic_set *bset);
3599 int isl_basic_map_is_universe(__isl_keep isl_basic_map *bmap);
3600 int isl_set_plain_is_universe(__isl_keep isl_set *set);
3602 =item * Single-valuedness
3604 #include <isl/set.h>
3605 int isl_set_is_singleton(__isl_keep isl_set *set);
3607 #include <isl/map.h>
3608 int isl_basic_map_is_single_valued(
3609 __isl_keep isl_basic_map *bmap);
3610 int isl_map_plain_is_single_valued(
3611 __isl_keep isl_map *map);
3612 int isl_map_is_single_valued(__isl_keep isl_map *map);
3614 #include <isl/union_map.h>
3615 int isl_union_map_is_single_valued(__isl_keep isl_union_map *umap);
3619 int isl_map_plain_is_injective(__isl_keep isl_map *map);
3620 int isl_map_is_injective(__isl_keep isl_map *map);
3621 int isl_union_map_plain_is_injective(
3622 __isl_keep isl_union_map *umap);
3623 int isl_union_map_is_injective(
3624 __isl_keep isl_union_map *umap);
3628 int isl_map_is_bijective(__isl_keep isl_map *map);
3629 int isl_union_map_is_bijective(__isl_keep isl_union_map *umap);
3633 __isl_give isl_val *
3634 isl_basic_map_plain_get_val_if_fixed(
3635 __isl_keep isl_basic_map *bmap,
3636 enum isl_dim_type type, unsigned pos);
3637 __isl_give isl_val *isl_set_plain_get_val_if_fixed(
3638 __isl_keep isl_set *set,
3639 enum isl_dim_type type, unsigned pos);
3640 __isl_give isl_val *isl_map_plain_get_val_if_fixed(
3641 __isl_keep isl_map *map,
3642 enum isl_dim_type type, unsigned pos);
3644 If the set or relation obviously lies on a hyperplane where the given dimension
3645 has a fixed value, then return that value.
3646 Otherwise return NaN.
3650 int isl_set_dim_residue_class_val(
3651 __isl_keep isl_set *set,
3652 int pos, __isl_give isl_val **modulo,
3653 __isl_give isl_val **residue);
3655 Check if the values of the given set dimension are equal to a fixed
3656 value modulo some integer value. If so, assign the modulo to C<*modulo>
3657 and the fixed value to C<*residue>. If the given dimension attains only
3658 a single value, then assign C<0> to C<*modulo> and the fixed value to
3660 If the dimension does not attain only a single value and if no modulo
3661 can be found then assign C<1> to C<*modulo> and C<1> to C<*residue>.
3665 To check whether the description of a set, relation or function depends
3666 on one or more given dimensions,
3667 the following functions can be used.
3669 #include <isl/constraint.h>
3670 int isl_constraint_involves_dims(
3671 __isl_keep isl_constraint *constraint,
3672 enum isl_dim_type type, unsigned first, unsigned n);
3674 #include <isl/set.h>
3675 int isl_basic_set_involves_dims(
3676 __isl_keep isl_basic_set *bset,
3677 enum isl_dim_type type, unsigned first, unsigned n);
3678 int isl_set_involves_dims(__isl_keep isl_set *set,
3679 enum isl_dim_type type, unsigned first, unsigned n);
3681 #include <isl/map.h>
3682 int isl_basic_map_involves_dims(
3683 __isl_keep isl_basic_map *bmap,
3684 enum isl_dim_type type, unsigned first, unsigned n);
3685 int isl_map_involves_dims(__isl_keep isl_map *map,
3686 enum isl_dim_type type, unsigned first, unsigned n);
3688 #include <isl/union_map.h>
3689 int isl_union_map_involves_dims(
3690 __isl_keep isl_union_map *umap,
3691 enum isl_dim_type type, unsigned first, unsigned n);
3693 #include <isl/aff.h>
3694 int isl_aff_involves_dims(__isl_keep isl_aff *aff,
3695 enum isl_dim_type type, unsigned first, unsigned n);
3696 int isl_pw_aff_involves_dims(__isl_keep isl_pw_aff *pwaff,
3697 enum isl_dim_type type, unsigned first, unsigned n);
3698 int isl_multi_aff_involves_dims(
3699 __isl_keep isl_multi_aff *ma,
3700 enum isl_dim_type type, unsigned first, unsigned n);
3701 int isl_multi_pw_aff_involves_dims(
3702 __isl_keep isl_multi_pw_aff *mpa,
3703 enum isl_dim_type type, unsigned first, unsigned n);
3705 Similarly, the following functions can be used to check whether
3706 a given dimension is involved in any lower or upper bound.
3708 #include <isl/set.h>
3709 int isl_set_dim_has_any_lower_bound(__isl_keep isl_set *set,
3710 enum isl_dim_type type, unsigned pos);
3711 int isl_set_dim_has_any_upper_bound(__isl_keep isl_set *set,
3712 enum isl_dim_type type, unsigned pos);
3714 Note that these functions return true even if there is a bound on
3715 the dimension on only some of the basic sets of C<set>.
3716 To check if they have a bound for all of the basic sets in C<set>,
3717 use the following functions instead.
3719 #include <isl/set.h>
3720 int isl_set_dim_has_lower_bound(__isl_keep isl_set *set,
3721 enum isl_dim_type type, unsigned pos);
3722 int isl_set_dim_has_upper_bound(__isl_keep isl_set *set,
3723 enum isl_dim_type type, unsigned pos);
3727 To check whether a set is a parameter domain, use this function:
3729 int isl_set_is_params(__isl_keep isl_set *set);
3730 int isl_union_set_is_params(
3731 __isl_keep isl_union_set *uset);
3735 The following functions check whether the space of the given
3736 (basic) set or relation range is a wrapped relation.
3738 #include <isl/space.h>
3739 int isl_space_is_wrapping(
3740 __isl_keep isl_space *space);
3741 int isl_space_domain_is_wrapping(
3742 __isl_keep isl_space *space);
3743 int isl_space_range_is_wrapping(
3744 __isl_keep isl_space *space);
3746 #include <isl/set.h>
3747 int isl_basic_set_is_wrapping(
3748 __isl_keep isl_basic_set *bset);
3749 int isl_set_is_wrapping(__isl_keep isl_set *set);
3751 #include <isl/map.h>
3752 int isl_map_domain_is_wrapping(
3753 __isl_keep isl_map *map);
3754 int isl_map_range_is_wrapping(
3755 __isl_keep isl_map *map);
3757 #include <isl/val.h>
3758 int isl_multi_val_range_is_wrapping(
3759 __isl_keep isl_multi_val *mv);
3761 #include <isl/aff.h>
3762 int isl_multi_aff_range_is_wrapping(
3763 __isl_keep isl_multi_aff *ma);
3764 int isl_multi_pw_aff_range_is_wrapping(
3765 __isl_keep isl_multi_pw_aff *mpa);
3766 int isl_multi_union_pw_aff_range_is_wrapping(
3767 __isl_keep isl_multi_union_pw_aff *mupa);
3769 The input to C<isl_space_is_wrapping> should
3770 be the space of a set, while that of
3771 C<isl_space_domain_is_wrapping> and
3772 C<isl_space_range_is_wrapping> should be the space of a relation.
3774 =item * Internal Product
3776 int isl_basic_map_can_zip(
3777 __isl_keep isl_basic_map *bmap);
3778 int isl_map_can_zip(__isl_keep isl_map *map);
3780 Check whether the product of domain and range of the given relation
3782 i.e., whether both domain and range are nested relations.
3786 int isl_basic_map_can_curry(
3787 __isl_keep isl_basic_map *bmap);
3788 int isl_map_can_curry(__isl_keep isl_map *map);
3790 Check whether the domain of the (basic) relation is a wrapped relation.
3792 int isl_basic_map_can_uncurry(
3793 __isl_keep isl_basic_map *bmap);
3794 int isl_map_can_uncurry(__isl_keep isl_map *map);
3796 Check whether the range of the (basic) relation is a wrapped relation.
3798 =item * Special Values
3800 #include <isl/aff.h>
3801 int isl_aff_is_cst(__isl_keep isl_aff *aff);
3802 int isl_pw_aff_is_cst(__isl_keep isl_pw_aff *pwaff);
3804 Check whether the given expression is a constant.
3806 #include <isl/aff.h>
3807 int isl_aff_is_nan(__isl_keep isl_aff *aff);
3808 int isl_pw_aff_involves_nan(__isl_keep isl_pw_aff *pa);
3810 Check whether the given expression is equal to or involves NaN.
3812 #include <isl/aff.h>
3813 int isl_aff_plain_is_zero(__isl_keep isl_aff *aff);
3815 Check whether the affine expression is obviously zero.
3819 =head3 Binary Properties
3825 The following functions check whether two objects
3826 represent the same set, relation or function.
3827 The C<plain> variants only return true if the objects
3828 are obviously the same. That is, they may return false
3829 even if the objects are the same, but they will never
3830 return true if the objects are not the same.
3832 #include <isl/set.h>
3833 int isl_basic_set_plain_is_equal(
3834 __isl_keep isl_basic_set *bset1,
3835 __isl_keep isl_basic_set *bset2);
3836 int isl_set_plain_is_equal(__isl_keep isl_set *set1,
3837 __isl_keep isl_set *set2);
3838 int isl_set_is_equal(__isl_keep isl_set *set1,
3839 __isl_keep isl_set *set2);
3841 #include <isl/map.h>
3842 int isl_basic_map_is_equal(
3843 __isl_keep isl_basic_map *bmap1,
3844 __isl_keep isl_basic_map *bmap2);
3845 int isl_map_is_equal(__isl_keep isl_map *map1,
3846 __isl_keep isl_map *map2);
3847 int isl_map_plain_is_equal(__isl_keep isl_map *map1,
3848 __isl_keep isl_map *map2);
3850 #include <isl/union_set.h>
3851 int isl_union_set_is_equal(
3852 __isl_keep isl_union_set *uset1,
3853 __isl_keep isl_union_set *uset2);
3855 #include <isl/union_map.h>
3856 int isl_union_map_is_equal(
3857 __isl_keep isl_union_map *umap1,
3858 __isl_keep isl_union_map *umap2);
3860 #include <isl/aff.h>
3861 int isl_aff_plain_is_equal(__isl_keep isl_aff *aff1,
3862 __isl_keep isl_aff *aff2);
3863 int isl_multi_aff_plain_is_equal(
3864 __isl_keep isl_multi_aff *maff1,
3865 __isl_keep isl_multi_aff *maff2);
3866 int isl_pw_aff_plain_is_equal(
3867 __isl_keep isl_pw_aff *pwaff1,
3868 __isl_keep isl_pw_aff *pwaff2);
3869 int isl_pw_multi_aff_plain_is_equal(
3870 __isl_keep isl_pw_multi_aff *pma1,
3871 __isl_keep isl_pw_multi_aff *pma2);
3872 int isl_multi_pw_aff_plain_is_equal(
3873 __isl_keep isl_multi_pw_aff *mpa1,
3874 __isl_keep isl_multi_pw_aff *mpa2);
3875 int isl_multi_pw_aff_is_equal(
3876 __isl_keep isl_multi_pw_aff *mpa1,
3877 __isl_keep isl_multi_pw_aff *mpa2);
3878 int isl_union_pw_aff_plain_is_equal(
3879 __isl_keep isl_union_pw_aff *upa1,
3880 __isl_keep isl_union_pw_aff *upa2);
3881 int isl_union_pw_multi_aff_plain_is_equal(
3882 __isl_keep isl_union_pw_multi_aff *upma1,
3883 __isl_keep isl_union_pw_multi_aff *upma2);
3884 int isl_multi_union_pw_aff_plain_is_equal(
3885 __isl_keep isl_multi_union_pw_aff *mupa1,
3886 __isl_keep isl_multi_union_pw_aff *mupa2);
3888 #include <isl/polynomial.h>
3889 int isl_union_pw_qpolynomial_plain_is_equal(
3890 __isl_keep isl_union_pw_qpolynomial *upwqp1,
3891 __isl_keep isl_union_pw_qpolynomial *upwqp2);
3892 int isl_union_pw_qpolynomial_fold_plain_is_equal(
3893 __isl_keep isl_union_pw_qpolynomial_fold *upwf1,
3894 __isl_keep isl_union_pw_qpolynomial_fold *upwf2);
3896 =item * Disjointness
3898 #include <isl/set.h>
3899 int isl_basic_set_is_disjoint(
3900 __isl_keep isl_basic_set *bset1,
3901 __isl_keep isl_basic_set *bset2);
3902 int isl_set_plain_is_disjoint(__isl_keep isl_set *set1,
3903 __isl_keep isl_set *set2);
3904 int isl_set_is_disjoint(__isl_keep isl_set *set1,
3905 __isl_keep isl_set *set2);
3907 #include <isl/map.h>
3908 int isl_basic_map_is_disjoint(
3909 __isl_keep isl_basic_map *bmap1,
3910 __isl_keep isl_basic_map *bmap2);
3911 int isl_map_is_disjoint(__isl_keep isl_map *map1,
3912 __isl_keep isl_map *map2);
3914 #include <isl/union_set.h>
3915 int isl_union_set_is_disjoint(
3916 __isl_keep isl_union_set *uset1,
3917 __isl_keep isl_union_set *uset2);
3919 #include <isl/union_map.h>
3920 int isl_union_map_is_disjoint(
3921 __isl_keep isl_union_map *umap1,
3922 __isl_keep isl_union_map *umap2);
3926 int isl_basic_set_is_subset(
3927 __isl_keep isl_basic_set *bset1,
3928 __isl_keep isl_basic_set *bset2);
3929 int isl_set_is_subset(__isl_keep isl_set *set1,
3930 __isl_keep isl_set *set2);
3931 int isl_set_is_strict_subset(
3932 __isl_keep isl_set *set1,
3933 __isl_keep isl_set *set2);
3934 int isl_union_set_is_subset(
3935 __isl_keep isl_union_set *uset1,
3936 __isl_keep isl_union_set *uset2);
3937 int isl_union_set_is_strict_subset(
3938 __isl_keep isl_union_set *uset1,
3939 __isl_keep isl_union_set *uset2);
3940 int isl_basic_map_is_subset(
3941 __isl_keep isl_basic_map *bmap1,
3942 __isl_keep isl_basic_map *bmap2);
3943 int isl_basic_map_is_strict_subset(
3944 __isl_keep isl_basic_map *bmap1,
3945 __isl_keep isl_basic_map *bmap2);
3946 int isl_map_is_subset(
3947 __isl_keep isl_map *map1,
3948 __isl_keep isl_map *map2);
3949 int isl_map_is_strict_subset(
3950 __isl_keep isl_map *map1,
3951 __isl_keep isl_map *map2);
3952 int isl_union_map_is_subset(
3953 __isl_keep isl_union_map *umap1,
3954 __isl_keep isl_union_map *umap2);
3955 int isl_union_map_is_strict_subset(
3956 __isl_keep isl_union_map *umap1,
3957 __isl_keep isl_union_map *umap2);
3959 Check whether the first argument is a (strict) subset of the
3964 Every comparison function returns a negative value if the first
3965 argument is considered smaller than the second, a positive value
3966 if the first argument is considered greater and zero if the two
3967 constraints are considered the same by the comparison criterion.
3969 #include <isl/constraint.h>
3970 int isl_constraint_plain_cmp(
3971 __isl_keep isl_constraint *c1,
3972 __isl_keep isl_constraint *c2);
3974 This function is useful for sorting C<isl_constraint>s.
3975 The order depends on the internal representation of the inputs.
3976 The order is fixed over different calls to the function (assuming
3977 the internal representation of the inputs has not changed), but may
3978 change over different versions of C<isl>.
3980 #include <isl/constraint.h>
3981 int isl_constraint_cmp_last_non_zero(
3982 __isl_keep isl_constraint *c1,
3983 __isl_keep isl_constraint *c2);
3985 This function can be used to sort constraints that live in the same
3986 local space. Constraints that involve ``earlier'' dimensions or
3987 that have a smaller coefficient for the shared latest dimension
3988 are considered smaller than other constraints.
3989 This function only defines a B<partial> order.
3991 #include <isl/set.h>
3992 int isl_set_plain_cmp(__isl_keep isl_set *set1,
3993 __isl_keep isl_set *set2);
3995 This function is useful for sorting C<isl_set>s.
3996 The order depends on the internal representation of the inputs.
3997 The order is fixed over different calls to the function (assuming
3998 the internal representation of the inputs has not changed), but may
3999 change over different versions of C<isl>.
4001 #include <isl/aff.h>
4002 int isl_pw_aff_plain_cmp(__isl_keep isl_pw_aff *pa1,
4003 __isl_keep isl_pw_aff *pa2);
4005 The function C<isl_pw_aff_plain_cmp> can be used to sort
4006 C<isl_pw_aff>s. The order is not strictly defined.
4007 The current order sorts expressions that only involve
4008 earlier dimensions before those that involve later dimensions.
4012 =head2 Unary Operations
4018 __isl_give isl_set *isl_set_complement(
4019 __isl_take isl_set *set);
4020 __isl_give isl_map *isl_map_complement(
4021 __isl_take isl_map *map);
4025 #include <isl/space.h>
4026 __isl_give isl_space *isl_space_reverse(
4027 __isl_take isl_space *space);
4029 #include <isl/map.h>
4030 __isl_give isl_basic_map *isl_basic_map_reverse(
4031 __isl_take isl_basic_map *bmap);
4032 __isl_give isl_map *isl_map_reverse(
4033 __isl_take isl_map *map);
4035 #include <isl/union_map.h>
4036 __isl_give isl_union_map *isl_union_map_reverse(
4037 __isl_take isl_union_map *umap);
4041 #include <isl/space.h>
4042 __isl_give isl_space *isl_space_domain(
4043 __isl_take isl_space *space);
4044 __isl_give isl_space *isl_space_range(
4045 __isl_take isl_space *space);
4046 __isl_give isl_space *isl_space_params(
4047 __isl_take isl_space *space);
4049 #include <isl/local_space.h>
4050 __isl_give isl_local_space *isl_local_space_domain(
4051 __isl_take isl_local_space *ls);
4052 __isl_give isl_local_space *isl_local_space_range(
4053 __isl_take isl_local_space *ls);
4055 #include <isl/set.h>
4056 __isl_give isl_basic_set *isl_basic_set_project_out(
4057 __isl_take isl_basic_set *bset,
4058 enum isl_dim_type type, unsigned first, unsigned n);
4059 __isl_give isl_set *isl_set_project_out(__isl_take isl_set *set,
4060 enum isl_dim_type type, unsigned first, unsigned n);
4061 __isl_give isl_basic_set *isl_basic_set_params(
4062 __isl_take isl_basic_set *bset);
4063 __isl_give isl_set *isl_set_params(__isl_take isl_set *set);
4065 #include <isl/map.h>
4066 __isl_give isl_basic_map *isl_basic_map_project_out(
4067 __isl_take isl_basic_map *bmap,
4068 enum isl_dim_type type, unsigned first, unsigned n);
4069 __isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
4070 enum isl_dim_type type, unsigned first, unsigned n);
4071 __isl_give isl_basic_set *isl_basic_map_domain(
4072 __isl_take isl_basic_map *bmap);
4073 __isl_give isl_basic_set *isl_basic_map_range(
4074 __isl_take isl_basic_map *bmap);
4075 __isl_give isl_set *isl_map_params(__isl_take isl_map *map);
4076 __isl_give isl_set *isl_map_domain(
4077 __isl_take isl_map *bmap);
4078 __isl_give isl_set *isl_map_range(
4079 __isl_take isl_map *map);
4081 #include <isl/union_set.h>
4082 __isl_give isl_union_set *isl_union_set_project_out(
4083 __isl_take isl_union_set *uset,
4084 enum isl_dim_type type,
4085 unsigned first, unsigned n);
4086 __isl_give isl_set *isl_union_set_params(
4087 __isl_take isl_union_set *uset);
4089 The function C<isl_union_set_project_out> can only project out
4092 #include <isl/union_map.h>
4093 __isl_give isl_union_map *isl_union_map_project_out(
4094 __isl_take isl_union_map *umap,
4095 enum isl_dim_type type, unsigned first, unsigned n);
4096 __isl_give isl_set *isl_union_map_params(
4097 __isl_take isl_union_map *umap);
4098 __isl_give isl_union_set *isl_union_map_domain(
4099 __isl_take isl_union_map *umap);
4100 __isl_give isl_union_set *isl_union_map_range(
4101 __isl_take isl_union_map *umap);
4103 The function C<isl_union_map_project_out> can only project out
4106 #include <isl/aff.h>
4107 __isl_give isl_aff *isl_aff_project_domain_on_params(
4108 __isl_take isl_aff *aff);
4109 __isl_give isl_pw_multi_aff *
4110 isl_pw_multi_aff_project_domain_on_params(
4111 __isl_take isl_pw_multi_aff *pma);
4112 __isl_give isl_set *isl_pw_aff_domain(
4113 __isl_take isl_pw_aff *pwaff);
4114 __isl_give isl_set *isl_pw_multi_aff_domain(
4115 __isl_take isl_pw_multi_aff *pma);
4116 __isl_give isl_set *isl_multi_pw_aff_domain(
4117 __isl_take isl_multi_pw_aff *mpa);
4118 __isl_give isl_union_set *isl_union_pw_aff_domain(
4119 __isl_take isl_union_pw_aff *upa);
4120 __isl_give isl_union_set *isl_union_pw_multi_aff_domain(
4121 __isl_take isl_union_pw_multi_aff *upma);
4122 __isl_give isl_union_set *
4123 isl_multi_union_pw_aff_domain(
4124 __isl_take isl_multi_union_pw_aff *mupa);
4125 __isl_give isl_set *isl_pw_aff_params(
4126 __isl_take isl_pw_aff *pwa);
4128 The function C<isl_multi_union_pw_aff_domain> requires its
4129 input to have at least one set dimension.
4131 #include <isl/polynomial.h>
4132 __isl_give isl_qpolynomial *
4133 isl_qpolynomial_project_domain_on_params(
4134 __isl_take isl_qpolynomial *qp);
4135 __isl_give isl_pw_qpolynomial *
4136 isl_pw_qpolynomial_project_domain_on_params(
4137 __isl_take isl_pw_qpolynomial *pwqp);
4138 __isl_give isl_pw_qpolynomial_fold *
4139 isl_pw_qpolynomial_fold_project_domain_on_params(
4140 __isl_take isl_pw_qpolynomial_fold *pwf);
4141 __isl_give isl_set *isl_pw_qpolynomial_domain(
4142 __isl_take isl_pw_qpolynomial *pwqp);
4143 __isl_give isl_union_set *isl_union_pw_qpolynomial_fold_domain(
4144 __isl_take isl_union_pw_qpolynomial_fold *upwf);
4145 __isl_give isl_union_set *isl_union_pw_qpolynomial_domain(
4146 __isl_take isl_union_pw_qpolynomial *upwqp);
4148 #include <isl/space.h>
4149 __isl_give isl_space *isl_space_domain_map(
4150 __isl_take isl_space *space);
4151 __isl_give isl_space *isl_space_range_map(
4152 __isl_take isl_space *space);
4154 #include <isl/map.h>
4155 __isl_give isl_map *isl_set_wrapped_domain_map(
4156 __isl_take isl_set *set);
4157 __isl_give isl_basic_map *isl_basic_map_domain_map(
4158 __isl_take isl_basic_map *bmap);
4159 __isl_give isl_basic_map *isl_basic_map_range_map(
4160 __isl_take isl_basic_map *bmap);
4161 __isl_give isl_map *isl_map_domain_map(__isl_take isl_map *map);
4162 __isl_give isl_map *isl_map_range_map(__isl_take isl_map *map);
4164 #include <isl/union_map.h>
4165 __isl_give isl_union_map *isl_union_map_domain_map(
4166 __isl_take isl_union_map *umap);
4167 __isl_give isl_union_pw_multi_aff *
4168 isl_union_map_domain_map_union_pw_multi_aff(
4169 __isl_take isl_union_map *umap);
4170 __isl_give isl_union_map *isl_union_map_range_map(
4171 __isl_take isl_union_map *umap);
4172 __isl_give isl_union_map *
4173 isl_union_set_wrapped_domain_map(
4174 __isl_take isl_union_set *uset);
4176 The functions above construct a (basic, regular or union) relation
4177 that maps (a wrapped version of) the input relation to its domain or range.
4178 C<isl_set_wrapped_domain_map> maps the input set to the domain
4179 of its wrapped relation.
4183 __isl_give isl_basic_set *isl_basic_set_eliminate(
4184 __isl_take isl_basic_set *bset,
4185 enum isl_dim_type type,
4186 unsigned first, unsigned n);
4187 __isl_give isl_set *isl_set_eliminate(
4188 __isl_take isl_set *set, enum isl_dim_type type,
4189 unsigned first, unsigned n);
4190 __isl_give isl_basic_map *isl_basic_map_eliminate(
4191 __isl_take isl_basic_map *bmap,
4192 enum isl_dim_type type,
4193 unsigned first, unsigned n);
4194 __isl_give isl_map *isl_map_eliminate(
4195 __isl_take isl_map *map, enum isl_dim_type type,
4196 unsigned first, unsigned n);
4198 Eliminate the coefficients for the given dimensions from the constraints,
4199 without removing the dimensions.
4201 =item * Constructing a set from a parameter domain
4203 A zero-dimensional space or (basic) set can be constructed
4204 on a given parameter domain using the following functions.
4206 #include <isl/space.h>
4207 __isl_give isl_space *isl_space_set_from_params(
4208 __isl_take isl_space *space);
4210 #include <isl/set.h>
4211 __isl_give isl_basic_set *isl_basic_set_from_params(
4212 __isl_take isl_basic_set *bset);
4213 __isl_give isl_set *isl_set_from_params(
4214 __isl_take isl_set *set);
4216 =item * Constructing a relation from a set
4218 Create a relation with the given set as domain or range.
4219 The range or domain of the created relation is a zero-dimensional
4220 flat anonymous space.
4222 #include <isl/space.h>
4223 __isl_give isl_space *isl_space_from_domain(
4224 __isl_take isl_space *space);
4225 __isl_give isl_space *isl_space_from_range(
4226 __isl_take isl_space *space);
4227 __isl_give isl_space *isl_space_map_from_set(
4228 __isl_take isl_space *space);
4229 __isl_give isl_space *isl_space_map_from_domain_and_range(
4230 __isl_take isl_space *domain,
4231 __isl_take isl_space *range);
4233 #include <isl/local_space.h>
4234 __isl_give isl_local_space *isl_local_space_from_domain(
4235 __isl_take isl_local_space *ls);
4237 #include <isl/map.h>
4238 __isl_give isl_map *isl_map_from_domain(
4239 __isl_take isl_set *set);
4240 __isl_give isl_map *isl_map_from_range(
4241 __isl_take isl_set *set);
4243 #include <isl/val.h>
4244 __isl_give isl_multi_val *isl_multi_val_from_range(
4245 __isl_take isl_multi_val *mv);
4247 #include <isl/aff.h>
4248 __isl_give isl_multi_aff *isl_multi_aff_from_range(
4249 __isl_take isl_multi_aff *ma);
4250 __isl_give isl_pw_aff *isl_pw_aff_from_range(
4251 __isl_take isl_pw_aff *pwa);
4252 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_range(
4253 __isl_take isl_multi_pw_aff *mpa);
4254 __isl_give isl_multi_union_pw_aff *
4255 isl_multi_union_pw_aff_from_range(
4256 __isl_take isl_multi_union_pw_aff *mupa);
4257 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_domain(
4258 __isl_take isl_set *set);
4259 __isl_give isl_union_pw_multi_aff *
4260 isl_union_pw_multi_aff_from_domain(
4261 __isl_take isl_union_set *uset);
4265 #include <isl/set.h>
4266 __isl_give isl_basic_set *isl_basic_set_fix_si(
4267 __isl_take isl_basic_set *bset,
4268 enum isl_dim_type type, unsigned pos, int value);
4269 __isl_give isl_basic_set *isl_basic_set_fix_val(
4270 __isl_take isl_basic_set *bset,
4271 enum isl_dim_type type, unsigned pos,
4272 __isl_take isl_val *v);
4273 __isl_give isl_set *isl_set_fix_si(__isl_take isl_set *set,
4274 enum isl_dim_type type, unsigned pos, int value);
4275 __isl_give isl_set *isl_set_fix_val(
4276 __isl_take isl_set *set,
4277 enum isl_dim_type type, unsigned pos,
4278 __isl_take isl_val *v);
4280 #include <isl/map.h>
4281 __isl_give isl_basic_map *isl_basic_map_fix_si(
4282 __isl_take isl_basic_map *bmap,
4283 enum isl_dim_type type, unsigned pos, int value);
4284 __isl_give isl_basic_map *isl_basic_map_fix_val(
4285 __isl_take isl_basic_map *bmap,
4286 enum isl_dim_type type, unsigned pos,
4287 __isl_take isl_val *v);
4288 __isl_give isl_map *isl_map_fix_si(__isl_take isl_map *map,
4289 enum isl_dim_type type, unsigned pos, int value);
4290 __isl_give isl_map *isl_map_fix_val(
4291 __isl_take isl_map *map,
4292 enum isl_dim_type type, unsigned pos,
4293 __isl_take isl_val *v);
4295 #include <isl/aff.h>
4296 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_fix_si(
4297 __isl_take isl_pw_multi_aff *pma,
4298 enum isl_dim_type type, unsigned pos, int value);
4300 #include <isl/polynomial.h>
4301 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_fix_val(
4302 __isl_take isl_pw_qpolynomial *pwqp,
4303 enum isl_dim_type type, unsigned n,
4304 __isl_take isl_val *v);
4306 Intersect the set, relation or function domain
4307 with the hyperplane where the given
4308 dimension has the fixed given value.
4310 __isl_give isl_basic_map *isl_basic_map_lower_bound_si(
4311 __isl_take isl_basic_map *bmap,
4312 enum isl_dim_type type, unsigned pos, int value);
4313 __isl_give isl_basic_map *isl_basic_map_upper_bound_si(
4314 __isl_take isl_basic_map *bmap,
4315 enum isl_dim_type type, unsigned pos, int value);
4316 __isl_give isl_set *isl_set_lower_bound_si(
4317 __isl_take isl_set *set,
4318 enum isl_dim_type type, unsigned pos, int value);
4319 __isl_give isl_set *isl_set_lower_bound_val(
4320 __isl_take isl_set *set,
4321 enum isl_dim_type type, unsigned pos,
4322 __isl_take isl_val *value);
4323 __isl_give isl_map *isl_map_lower_bound_si(
4324 __isl_take isl_map *map,
4325 enum isl_dim_type type, unsigned pos, int value);
4326 __isl_give isl_set *isl_set_upper_bound_si(
4327 __isl_take isl_set *set,
4328 enum isl_dim_type type, unsigned pos, int value);
4329 __isl_give isl_set *isl_set_upper_bound_val(
4330 __isl_take isl_set *set,
4331 enum isl_dim_type type, unsigned pos,
4332 __isl_take isl_val *value);
4333 __isl_give isl_map *isl_map_upper_bound_si(
4334 __isl_take isl_map *map,
4335 enum isl_dim_type type, unsigned pos, int value);
4337 Intersect the set or relation with the half-space where the given
4338 dimension has a value bounded by the fixed given integer value.
4340 __isl_give isl_set *isl_set_equate(__isl_take isl_set *set,
4341 enum isl_dim_type type1, int pos1,
4342 enum isl_dim_type type2, int pos2);
4343 __isl_give isl_basic_map *isl_basic_map_equate(
4344 __isl_take isl_basic_map *bmap,
4345 enum isl_dim_type type1, int pos1,
4346 enum isl_dim_type type2, int pos2);
4347 __isl_give isl_map *isl_map_equate(__isl_take isl_map *map,
4348 enum isl_dim_type type1, int pos1,
4349 enum isl_dim_type type2, int pos2);
4351 Intersect the set or relation with the hyperplane where the given
4352 dimensions are equal to each other.
4354 __isl_give isl_map *isl_map_oppose(__isl_take isl_map *map,
4355 enum isl_dim_type type1, int pos1,
4356 enum isl_dim_type type2, int pos2);
4358 Intersect the relation with the hyperplane where the given
4359 dimensions have opposite values.
4361 __isl_give isl_map *isl_map_order_le(
4362 __isl_take isl_map *map,
4363 enum isl_dim_type type1, int pos1,
4364 enum isl_dim_type type2, int pos2);
4365 __isl_give isl_basic_map *isl_basic_map_order_ge(
4366 __isl_take isl_basic_map *bmap,
4367 enum isl_dim_type type1, int pos1,
4368 enum isl_dim_type type2, int pos2);
4369 __isl_give isl_map *isl_map_order_ge(
4370 __isl_take isl_map *map,
4371 enum isl_dim_type type1, int pos1,
4372 enum isl_dim_type type2, int pos2);
4373 __isl_give isl_map *isl_map_order_lt(__isl_take isl_map *map,
4374 enum isl_dim_type type1, int pos1,
4375 enum isl_dim_type type2, int pos2);
4376 __isl_give isl_basic_map *isl_basic_map_order_gt(
4377 __isl_take isl_basic_map *bmap,
4378 enum isl_dim_type type1, int pos1,
4379 enum isl_dim_type type2, int pos2);
4380 __isl_give isl_map *isl_map_order_gt(__isl_take isl_map *map,
4381 enum isl_dim_type type1, int pos1,
4382 enum isl_dim_type type2, int pos2);
4384 Intersect the relation with the half-space where the given
4385 dimensions satisfy the given ordering.
4389 #include <isl/aff.h>
4390 __isl_give isl_basic_set *isl_aff_zero_basic_set(
4391 __isl_take isl_aff *aff);
4392 __isl_give isl_basic_set *isl_aff_neg_basic_set(
4393 __isl_take isl_aff *aff);
4394 __isl_give isl_set *isl_pw_aff_pos_set(
4395 __isl_take isl_pw_aff *pa);
4396 __isl_give isl_set *isl_pw_aff_nonneg_set(
4397 __isl_take isl_pw_aff *pwaff);
4398 __isl_give isl_set *isl_pw_aff_zero_set(
4399 __isl_take isl_pw_aff *pwaff);
4400 __isl_give isl_set *isl_pw_aff_non_zero_set(
4401 __isl_take isl_pw_aff *pwaff);
4402 __isl_give isl_union_set *
4403 isl_union_pw_aff_zero_union_set(
4404 __isl_take isl_union_pw_aff *upa);
4405 __isl_give isl_union_set *
4406 isl_multi_union_pw_aff_zero_union_set(
4407 __isl_take isl_multi_union_pw_aff *mupa);
4409 The function C<isl_aff_neg_basic_set> returns a basic set
4410 containing those elements in the domain space
4411 of C<aff> where C<aff> is negative.
4412 The function C<isl_pw_aff_nonneg_set> returns a set
4413 containing those elements in the domain
4414 of C<pwaff> where C<pwaff> is non-negative.
4415 The function C<isl_multi_union_pw_aff_zero_union_set>
4416 returns a union set containing those elements
4417 in the domains of its elements where they are all zero.
4421 __isl_give isl_map *isl_set_identity(
4422 __isl_take isl_set *set);
4423 __isl_give isl_union_map *isl_union_set_identity(
4424 __isl_take isl_union_set *uset);
4425 __isl_give isl_union_pw_multi_aff *
4426 isl_union_set_identity_union_pw_multi_aff(
4427 __isl_take isl_union_set *uset);
4429 Construct an identity relation on the given (union) set.
4431 =item * Function Extraction
4433 A piecewise quasi affine expression that is equal to 1 on a set
4434 and 0 outside the set can be created using the following function.
4436 #include <isl/aff.h>
4437 __isl_give isl_pw_aff *isl_set_indicator_function(
4438 __isl_take isl_set *set);
4440 A piecewise multiple quasi affine expression can be extracted
4441 from an C<isl_set> or C<isl_map>, provided the C<isl_set> is a singleton
4442 and the C<isl_map> is single-valued.
4443 In case of a conversion from an C<isl_union_map>
4444 to an C<isl_union_pw_multi_aff>, these properties need to hold
4445 in each domain space.
4446 A conversion to a C<isl_multi_union_pw_aff> additionally
4447 requires that the input is non-empty and involves only a single
4450 #include <isl/aff.h>
4451 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_set(
4452 __isl_take isl_set *set);
4453 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_map(
4454 __isl_take isl_map *map);
4456 __isl_give isl_union_pw_multi_aff *
4457 isl_union_pw_multi_aff_from_union_set(
4458 __isl_take isl_union_set *uset);
4459 __isl_give isl_union_pw_multi_aff *
4460 isl_union_pw_multi_aff_from_union_map(
4461 __isl_take isl_union_map *umap);
4463 __isl_give isl_multi_union_pw_aff *
4464 isl_multi_union_pw_aff_from_union_map(
4465 __isl_take isl_union_map *umap);
4469 __isl_give isl_basic_set *isl_basic_map_deltas(
4470 __isl_take isl_basic_map *bmap);
4471 __isl_give isl_set *isl_map_deltas(__isl_take isl_map *map);
4472 __isl_give isl_union_set *isl_union_map_deltas(
4473 __isl_take isl_union_map *umap);
4475 These functions return a (basic) set containing the differences
4476 between image elements and corresponding domain elements in the input.
4478 __isl_give isl_basic_map *isl_basic_map_deltas_map(
4479 __isl_take isl_basic_map *bmap);
4480 __isl_give isl_map *isl_map_deltas_map(
4481 __isl_take isl_map *map);
4482 __isl_give isl_union_map *isl_union_map_deltas_map(
4483 __isl_take isl_union_map *umap);
4485 The functions above construct a (basic, regular or union) relation
4486 that maps (a wrapped version of) the input relation to its delta set.
4490 Simplify the representation of a set, relation or functions by trying
4491 to combine pairs of basic sets or relations into a single
4492 basic set or relation.
4494 #include <isl/set.h>
4495 __isl_give isl_set *isl_set_coalesce(__isl_take isl_set *set);
4497 #include <isl/map.h>
4498 __isl_give isl_map *isl_map_coalesce(__isl_take isl_map *map);
4500 #include <isl/union_set.h>
4501 __isl_give isl_union_set *isl_union_set_coalesce(
4502 __isl_take isl_union_set *uset);
4504 #include <isl/union_map.h>
4505 __isl_give isl_union_map *isl_union_map_coalesce(
4506 __isl_take isl_union_map *umap);
4508 #include <isl/aff.h>
4509 __isl_give isl_pw_aff *isl_pw_aff_coalesce(
4510 __isl_take isl_pw_aff *pwqp);
4511 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_coalesce(
4512 __isl_take isl_pw_multi_aff *pma);
4513 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_coalesce(
4514 __isl_take isl_multi_pw_aff *mpa);
4515 __isl_give isl_union_pw_aff *isl_union_pw_aff_coalesce(
4516 __isl_take isl_union_pw_aff *upa);
4517 __isl_give isl_union_pw_multi_aff *
4518 isl_union_pw_multi_aff_coalesce(
4519 __isl_take isl_union_pw_multi_aff *upma);
4521 #include <isl/polynomial.h>
4522 __isl_give isl_pw_qpolynomial_fold *
4523 isl_pw_qpolynomial_fold_coalesce(
4524 __isl_take isl_pw_qpolynomial_fold *pwf);
4525 __isl_give isl_union_pw_qpolynomial *
4526 isl_union_pw_qpolynomial_coalesce(
4527 __isl_take isl_union_pw_qpolynomial *upwqp);
4528 __isl_give isl_union_pw_qpolynomial_fold *
4529 isl_union_pw_qpolynomial_fold_coalesce(
4530 __isl_take isl_union_pw_qpolynomial_fold *upwf);
4532 One of the methods for combining pairs of basic sets or relations
4533 can result in coefficients that are much larger than those that appear
4534 in the constraints of the input. By default, the coefficients are
4535 not allowed to grow larger, but this can be changed by unsetting
4536 the following option.
4538 int isl_options_set_coalesce_bounded_wrapping(
4539 isl_ctx *ctx, int val);
4540 int isl_options_get_coalesce_bounded_wrapping(
4543 =item * Detecting equalities
4545 __isl_give isl_basic_set *isl_basic_set_detect_equalities(
4546 __isl_take isl_basic_set *bset);
4547 __isl_give isl_basic_map *isl_basic_map_detect_equalities(
4548 __isl_take isl_basic_map *bmap);
4549 __isl_give isl_set *isl_set_detect_equalities(
4550 __isl_take isl_set *set);
4551 __isl_give isl_map *isl_map_detect_equalities(
4552 __isl_take isl_map *map);
4553 __isl_give isl_union_set *isl_union_set_detect_equalities(
4554 __isl_take isl_union_set *uset);
4555 __isl_give isl_union_map *isl_union_map_detect_equalities(
4556 __isl_take isl_union_map *umap);
4558 Simplify the representation of a set or relation by detecting implicit
4561 =item * Removing redundant constraints
4563 #include <isl/set.h>
4564 __isl_give isl_basic_set *isl_basic_set_remove_redundancies(
4565 __isl_take isl_basic_set *bset);
4566 __isl_give isl_set *isl_set_remove_redundancies(
4567 __isl_take isl_set *set);
4569 #include <isl/union_set.h>
4570 __isl_give isl_union_set *
4571 isl_union_set_remove_redundancies(
4572 __isl_take isl_union_set *uset);
4574 #include <isl/map.h>
4575 __isl_give isl_basic_map *isl_basic_map_remove_redundancies(
4576 __isl_take isl_basic_map *bmap);
4577 __isl_give isl_map *isl_map_remove_redundancies(
4578 __isl_take isl_map *map);
4580 #include <isl/union_map.h>
4581 __isl_give isl_union_map *
4582 isl_union_map_remove_redundancies(
4583 __isl_take isl_union_map *umap);
4587 __isl_give isl_basic_set *isl_set_convex_hull(
4588 __isl_take isl_set *set);
4589 __isl_give isl_basic_map *isl_map_convex_hull(
4590 __isl_take isl_map *map);
4592 If the input set or relation has any existentially quantified
4593 variables, then the result of these operations is currently undefined.
4597 #include <isl/set.h>
4598 __isl_give isl_basic_set *
4599 isl_set_unshifted_simple_hull(
4600 __isl_take isl_set *set);
4601 __isl_give isl_basic_set *isl_set_simple_hull(
4602 __isl_take isl_set *set);
4603 __isl_give isl_basic_set *
4604 isl_set_unshifted_simple_hull_from_set_list(
4605 __isl_take isl_set *set,
4606 __isl_take isl_set_list *list);
4608 #include <isl/map.h>
4609 __isl_give isl_basic_map *
4610 isl_map_unshifted_simple_hull(
4611 __isl_take isl_map *map);
4612 __isl_give isl_basic_map *isl_map_simple_hull(
4613 __isl_take isl_map *map);
4614 __isl_give isl_basic_map *
4615 isl_map_unshifted_simple_hull_from_map_list(
4616 __isl_take isl_map *map,
4617 __isl_take isl_map_list *list);
4619 #include <isl/union_map.h>
4620 __isl_give isl_union_map *isl_union_map_simple_hull(
4621 __isl_take isl_union_map *umap);
4623 These functions compute a single basic set or relation
4624 that contains the whole input set or relation.
4625 In particular, the output is described by translates
4626 of the constraints describing the basic sets or relations in the input.
4627 In case of C<isl_set_unshifted_simple_hull>, only the original
4628 constraints are used, without any translation.
4629 In case of C<isl_set_unshifted_simple_hull_from_set_list> and
4630 C<isl_map_unshifted_simple_hull_from_map_list>, the
4631 constraints are taken from the elements of the second argument.
4635 (See \autoref{s:simple hull}.)
4641 __isl_give isl_basic_set *isl_basic_set_affine_hull(
4642 __isl_take isl_basic_set *bset);
4643 __isl_give isl_basic_set *isl_set_affine_hull(
4644 __isl_take isl_set *set);
4645 __isl_give isl_union_set *isl_union_set_affine_hull(
4646 __isl_take isl_union_set *uset);
4647 __isl_give isl_basic_map *isl_basic_map_affine_hull(
4648 __isl_take isl_basic_map *bmap);
4649 __isl_give isl_basic_map *isl_map_affine_hull(
4650 __isl_take isl_map *map);
4651 __isl_give isl_union_map *isl_union_map_affine_hull(
4652 __isl_take isl_union_map *umap);
4654 In case of union sets and relations, the affine hull is computed
4657 =item * Polyhedral hull
4659 __isl_give isl_basic_set *isl_set_polyhedral_hull(
4660 __isl_take isl_set *set);
4661 __isl_give isl_basic_map *isl_map_polyhedral_hull(
4662 __isl_take isl_map *map);
4663 __isl_give isl_union_set *isl_union_set_polyhedral_hull(
4664 __isl_take isl_union_set *uset);
4665 __isl_give isl_union_map *isl_union_map_polyhedral_hull(
4666 __isl_take isl_union_map *umap);
4668 These functions compute a single basic set or relation
4669 not involving any existentially quantified variables
4670 that contains the whole input set or relation.
4671 In case of union sets and relations, the polyhedral hull is computed
4674 =item * Other approximations
4676 #include <isl/set.h>
4677 __isl_give isl_basic_set *
4678 isl_basic_set_drop_constraints_involving_dims(
4679 __isl_take isl_basic_set *bset,
4680 enum isl_dim_type type,
4681 unsigned first, unsigned n);
4682 __isl_give isl_basic_set *
4683 isl_basic_set_drop_constraints_not_involving_dims(
4684 __isl_take isl_basic_set *bset,
4685 enum isl_dim_type type,
4686 unsigned first, unsigned n);
4687 __isl_give isl_set *
4688 isl_set_drop_constraints_involving_dims(
4689 __isl_take isl_set *set,
4690 enum isl_dim_type type,
4691 unsigned first, unsigned n);
4693 #include <isl/map.h>
4694 __isl_give isl_basic_map *
4695 isl_basic_map_drop_constraints_involving_dims(
4696 __isl_take isl_basic_map *bmap,
4697 enum isl_dim_type type,
4698 unsigned first, unsigned n);
4699 __isl_give isl_map *
4700 isl_map_drop_constraints_involving_dims(
4701 __isl_take isl_map *map,
4702 enum isl_dim_type type,
4703 unsigned first, unsigned n);
4705 These functions drop any constraints (not) involving the specified dimensions.
4706 Note that the result depends on the representation of the input.
4708 #include <isl/polynomial.h>
4709 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_to_polynomial(
4710 __isl_take isl_pw_qpolynomial *pwqp, int sign);
4711 __isl_give isl_union_pw_qpolynomial *
4712 isl_union_pw_qpolynomial_to_polynomial(
4713 __isl_take isl_union_pw_qpolynomial *upwqp, int sign);
4715 Approximate each quasipolynomial by a polynomial. If C<sign> is positive,
4716 the polynomial will be an overapproximation. If C<sign> is negative,
4717 it will be an underapproximation. If C<sign> is zero, the approximation
4718 will lie somewhere in between.
4722 __isl_give isl_basic_set *isl_basic_set_sample(
4723 __isl_take isl_basic_set *bset);
4724 __isl_give isl_basic_set *isl_set_sample(
4725 __isl_take isl_set *set);
4726 __isl_give isl_basic_map *isl_basic_map_sample(
4727 __isl_take isl_basic_map *bmap);
4728 __isl_give isl_basic_map *isl_map_sample(
4729 __isl_take isl_map *map);
4731 If the input (basic) set or relation is non-empty, then return
4732 a singleton subset of the input. Otherwise, return an empty set.
4734 =item * Optimization
4736 #include <isl/ilp.h>
4737 __isl_give isl_val *isl_basic_set_max_val(
4738 __isl_keep isl_basic_set *bset,
4739 __isl_keep isl_aff *obj);
4740 __isl_give isl_val *isl_set_min_val(
4741 __isl_keep isl_set *set,
4742 __isl_keep isl_aff *obj);
4743 __isl_give isl_val *isl_set_max_val(
4744 __isl_keep isl_set *set,
4745 __isl_keep isl_aff *obj);
4747 Compute the minimum or maximum of the integer affine expression C<obj>
4748 over the points in C<set>, returning the result in C<opt>.
4749 The result is C<NULL> in case of an error, the optimal value in case
4750 there is one, negative infinity or infinity if the problem is unbounded and
4751 NaN if the problem is empty.
4753 =item * Parametric optimization
4755 __isl_give isl_pw_aff *isl_set_dim_min(
4756 __isl_take isl_set *set, int pos);
4757 __isl_give isl_pw_aff *isl_set_dim_max(
4758 __isl_take isl_set *set, int pos);
4759 __isl_give isl_pw_aff *isl_map_dim_max(
4760 __isl_take isl_map *map, int pos);
4762 Compute the minimum or maximum of the given set or output dimension
4763 as a function of the parameters (and input dimensions), but independently
4764 of the other set or output dimensions.
4765 For lexicographic optimization, see L<"Lexicographic Optimization">.
4769 The following functions compute either the set of (rational) coefficient
4770 values of valid constraints for the given set or the set of (rational)
4771 values satisfying the constraints with coefficients from the given set.
4772 Internally, these two sets of functions perform essentially the
4773 same operations, except that the set of coefficients is assumed to
4774 be a cone, while the set of values may be any polyhedron.
4775 The current implementation is based on the Farkas lemma and
4776 Fourier-Motzkin elimination, but this may change or be made optional
4777 in future. In particular, future implementations may use different
4778 dualization algorithms or skip the elimination step.
4780 __isl_give isl_basic_set *isl_basic_set_coefficients(
4781 __isl_take isl_basic_set *bset);
4782 __isl_give isl_basic_set *isl_set_coefficients(
4783 __isl_take isl_set *set);
4784 __isl_give isl_union_set *isl_union_set_coefficients(
4785 __isl_take isl_union_set *bset);
4786 __isl_give isl_basic_set *isl_basic_set_solutions(
4787 __isl_take isl_basic_set *bset);
4788 __isl_give isl_basic_set *isl_set_solutions(
4789 __isl_take isl_set *set);
4790 __isl_give isl_union_set *isl_union_set_solutions(
4791 __isl_take isl_union_set *bset);
4795 __isl_give isl_map *isl_map_fixed_power_val(
4796 __isl_take isl_map *map,
4797 __isl_take isl_val *exp);
4798 __isl_give isl_union_map *
4799 isl_union_map_fixed_power_val(
4800 __isl_take isl_union_map *umap,
4801 __isl_take isl_val *exp);
4803 Compute the given power of C<map>, where C<exp> is assumed to be non-zero.
4804 If the exponent C<exp> is negative, then the -C<exp> th power of the inverse
4805 of C<map> is computed.
4807 __isl_give isl_map *isl_map_power(__isl_take isl_map *map,
4809 __isl_give isl_union_map *isl_union_map_power(
4810 __isl_take isl_union_map *umap, int *exact);
4812 Compute a parametric representation for all positive powers I<k> of C<map>.
4813 The result maps I<k> to a nested relation corresponding to the
4814 I<k>th power of C<map>.
4815 The result may be an overapproximation. If the result is known to be exact,
4816 then C<*exact> is set to C<1>.
4818 =item * Transitive closure
4820 __isl_give isl_map *isl_map_transitive_closure(
4821 __isl_take isl_map *map, int *exact);
4822 __isl_give isl_union_map *isl_union_map_transitive_closure(
4823 __isl_take isl_union_map *umap, int *exact);
4825 Compute the transitive closure of C<map>.
4826 The result may be an overapproximation. If the result is known to be exact,
4827 then C<*exact> is set to C<1>.
4829 =item * Reaching path lengths
4831 __isl_give isl_map *isl_map_reaching_path_lengths(
4832 __isl_take isl_map *map, int *exact);
4834 Compute a relation that maps each element in the range of C<map>
4835 to the lengths of all paths composed of edges in C<map> that
4836 end up in the given element.
4837 The result may be an overapproximation. If the result is known to be exact,
4838 then C<*exact> is set to C<1>.
4839 To compute the I<maximal> path length, the resulting relation
4840 should be postprocessed by C<isl_map_lexmax>.
4841 In particular, if the input relation is a dependence relation
4842 (mapping sources to sinks), then the maximal path length corresponds
4843 to the free schedule.
4844 Note, however, that C<isl_map_lexmax> expects the maximum to be
4845 finite, so if the path lengths are unbounded (possibly due to
4846 the overapproximation), then you will get an error message.
4850 #include <isl/space.h>
4851 __isl_give isl_space *isl_space_wrap(
4852 __isl_take isl_space *space);
4853 __isl_give isl_space *isl_space_unwrap(
4854 __isl_take isl_space *space);
4856 #include <isl/local_space.h>
4857 __isl_give isl_local_space *isl_local_space_wrap(
4858 __isl_take isl_local_space *ls);
4860 #include <isl/set.h>
4861 __isl_give isl_basic_map *isl_basic_set_unwrap(
4862 __isl_take isl_basic_set *bset);
4863 __isl_give isl_map *isl_set_unwrap(
4864 __isl_take isl_set *set);
4866 #include <isl/map.h>
4867 __isl_give isl_basic_set *isl_basic_map_wrap(
4868 __isl_take isl_basic_map *bmap);
4869 __isl_give isl_set *isl_map_wrap(
4870 __isl_take isl_map *map);
4872 #include <isl/union_set.h>
4873 __isl_give isl_union_map *isl_union_set_unwrap(
4874 __isl_take isl_union_set *uset);
4876 #include <isl/union_map.h>
4877 __isl_give isl_union_set *isl_union_map_wrap(
4878 __isl_take isl_union_map *umap);
4880 The input to C<isl_space_unwrap> should
4881 be the space of a set, while that of
4882 C<isl_space_wrap> should be the space of a relation.
4883 Conversely, the output of C<isl_space_unwrap> is the space
4884 of a relation, while that of C<isl_space_wrap> is the space of a set.
4888 Remove any internal structure of domain (and range) of the given
4889 set or relation. If there is any such internal structure in the input,
4890 then the name of the space is also removed.
4892 #include <isl/local_space.h>
4893 __isl_give isl_local_space *
4894 isl_local_space_flatten_domain(
4895 __isl_take isl_local_space *ls);
4896 __isl_give isl_local_space *
4897 isl_local_space_flatten_range(
4898 __isl_take isl_local_space *ls);
4900 #include <isl/set.h>
4901 __isl_give isl_basic_set *isl_basic_set_flatten(
4902 __isl_take isl_basic_set *bset);
4903 __isl_give isl_set *isl_set_flatten(
4904 __isl_take isl_set *set);
4906 #include <isl/map.h>
4907 __isl_give isl_basic_map *isl_basic_map_flatten_domain(
4908 __isl_take isl_basic_map *bmap);
4909 __isl_give isl_basic_map *isl_basic_map_flatten_range(
4910 __isl_take isl_basic_map *bmap);
4911 __isl_give isl_map *isl_map_flatten_range(
4912 __isl_take isl_map *map);
4913 __isl_give isl_map *isl_map_flatten_domain(
4914 __isl_take isl_map *map);
4915 __isl_give isl_basic_map *isl_basic_map_flatten(
4916 __isl_take isl_basic_map *bmap);
4917 __isl_give isl_map *isl_map_flatten(
4918 __isl_take isl_map *map);
4920 #include <isl/val.h>
4921 __isl_give isl_multi_val *isl_multi_val_flatten_range(
4922 __isl_take isl_multi_val *mv);
4924 #include <isl/aff.h>
4925 __isl_give isl_multi_aff *isl_multi_aff_flatten_domain(
4926 __isl_take isl_multi_aff *ma);
4927 __isl_give isl_multi_aff *isl_multi_aff_flatten_range(
4928 __isl_take isl_multi_aff *ma);
4929 __isl_give isl_multi_pw_aff *
4930 isl_multi_pw_aff_flatten_range(
4931 __isl_take isl_multi_pw_aff *mpa);
4932 __isl_give isl_multi_union_pw_aff *
4933 isl_multi_union_pw_aff_flatten_range(
4934 __isl_take isl_multi_union_pw_aff *mupa);
4936 #include <isl/map.h>
4937 __isl_give isl_map *isl_set_flatten_map(
4938 __isl_take isl_set *set);
4940 The function above constructs a relation
4941 that maps the input set to a flattened version of the set.
4945 Lift the input set to a space with extra dimensions corresponding
4946 to the existentially quantified variables in the input.
4947 In particular, the result lives in a wrapped map where the domain
4948 is the original space and the range corresponds to the original
4949 existentially quantified variables.
4951 #include <isl/set.h>
4952 __isl_give isl_basic_set *isl_basic_set_lift(
4953 __isl_take isl_basic_set *bset);
4954 __isl_give isl_set *isl_set_lift(
4955 __isl_take isl_set *set);
4956 __isl_give isl_union_set *isl_union_set_lift(
4957 __isl_take isl_union_set *uset);
4959 Given a local space that contains the existentially quantified
4960 variables of a set, a basic relation that, when applied to
4961 a basic set, has essentially the same effect as C<isl_basic_set_lift>,
4962 can be constructed using the following function.
4964 #include <isl/local_space.h>
4965 __isl_give isl_basic_map *isl_local_space_lifting(
4966 __isl_take isl_local_space *ls);
4968 #include <isl/aff.h>
4969 __isl_give isl_multi_aff *isl_multi_aff_lift(
4970 __isl_take isl_multi_aff *maff,
4971 __isl_give isl_local_space **ls);
4973 If the C<ls> argument of C<isl_multi_aff_lift> is not C<NULL>,
4974 then it is assigned the local space that lies at the basis of
4975 the lifting applied.
4977 =item * Internal Product
4979 #include <isl/space.h>
4980 __isl_give isl_space *isl_space_zip(
4981 __isl_take isl_space *space);
4983 #include <isl/map.h>
4984 __isl_give isl_basic_map *isl_basic_map_zip(
4985 __isl_take isl_basic_map *bmap);
4986 __isl_give isl_map *isl_map_zip(
4987 __isl_take isl_map *map);
4989 #include <isl/union_map.h>
4990 __isl_give isl_union_map *isl_union_map_zip(
4991 __isl_take isl_union_map *umap);
4993 Given a relation with nested relations for domain and range,
4994 interchange the range of the domain with the domain of the range.
4998 #include <isl/space.h>
4999 __isl_give isl_space *isl_space_curry(
5000 __isl_take isl_space *space);
5001 __isl_give isl_space *isl_space_uncurry(
5002 __isl_take isl_space *space);
5004 #include <isl/map.h>
5005 __isl_give isl_basic_map *isl_basic_map_curry(
5006 __isl_take isl_basic_map *bmap);
5007 __isl_give isl_basic_map *isl_basic_map_uncurry(
5008 __isl_take isl_basic_map *bmap);
5009 __isl_give isl_map *isl_map_curry(
5010 __isl_take isl_map *map);
5011 __isl_give isl_map *isl_map_uncurry(
5012 __isl_take isl_map *map);
5014 #include <isl/union_map.h>
5015 __isl_give isl_union_map *isl_union_map_curry(
5016 __isl_take isl_union_map *umap);
5017 __isl_give isl_union_map *isl_union_map_uncurry(
5018 __isl_take isl_union_map *umap);
5020 Given a relation with a nested relation for domain,
5021 the C<curry> functions
5022 move the range of the nested relation out of the domain
5023 and use it as the domain of a nested relation in the range,
5024 with the original range as range of this nested relation.
5025 The C<uncurry> functions perform the inverse operation.
5027 =item * Aligning parameters
5029 Change the order of the parameters of the given set, relation
5031 such that the first parameters match those of C<model>.
5032 This may involve the introduction of extra parameters.
5033 All parameters need to be named.
5035 #include <isl/space.h>
5036 __isl_give isl_space *isl_space_align_params(
5037 __isl_take isl_space *space1,
5038 __isl_take isl_space *space2)
5040 #include <isl/set.h>
5041 __isl_give isl_basic_set *isl_basic_set_align_params(
5042 __isl_take isl_basic_set *bset,
5043 __isl_take isl_space *model);
5044 __isl_give isl_set *isl_set_align_params(
5045 __isl_take isl_set *set,
5046 __isl_take isl_space *model);
5048 #include <isl/map.h>
5049 __isl_give isl_basic_map *isl_basic_map_align_params(
5050 __isl_take isl_basic_map *bmap,
5051 __isl_take isl_space *model);
5052 __isl_give isl_map *isl_map_align_params(
5053 __isl_take isl_map *map,
5054 __isl_take isl_space *model);
5056 #include <isl/val.h>
5057 __isl_give isl_multi_val *isl_multi_val_align_params(
5058 __isl_take isl_multi_val *mv,
5059 __isl_take isl_space *model);
5061 #include <isl/aff.h>
5062 __isl_give isl_aff *isl_aff_align_params(
5063 __isl_take isl_aff *aff,
5064 __isl_take isl_space *model);
5065 __isl_give isl_multi_aff *isl_multi_aff_align_params(
5066 __isl_take isl_multi_aff *multi,
5067 __isl_take isl_space *model);
5068 __isl_give isl_pw_aff *isl_pw_aff_align_params(
5069 __isl_take isl_pw_aff *pwaff,
5070 __isl_take isl_space *model);
5071 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_align_params(
5072 __isl_take isl_pw_multi_aff *pma,
5073 __isl_take isl_space *model);
5074 __isl_give isl_union_pw_aff *
5075 isl_union_pw_aff_align_params(
5076 __isl_take isl_union_pw_aff *upa,
5077 __isl_take isl_space *model);
5078 __isl_give isl_union_pw_multi_aff *
5079 isl_union_pw_multi_aff_align_params(
5080 __isl_take isl_union_pw_multi_aff *upma,
5081 __isl_take isl_space *model);
5082 __isl_give isl_multi_union_pw_aff *
5083 isl_multi_union_pw_aff_align_params(
5084 __isl_take isl_multi_union_pw_aff *mupa,
5085 __isl_take isl_space *model);
5087 #include <isl/polynomial.h>
5088 __isl_give isl_qpolynomial *isl_qpolynomial_align_params(
5089 __isl_take isl_qpolynomial *qp,
5090 __isl_take isl_space *model);
5092 =item * Unary Arithmethic Operations
5094 #include <isl/val.h>
5095 __isl_give isl_multi_val *isl_multi_val_neg(
5096 __isl_take isl_multi_val *mv);
5098 #include <isl/aff.h>
5099 __isl_give isl_aff *isl_aff_neg(
5100 __isl_take isl_aff *aff);
5101 __isl_give isl_multi_aff *isl_multi_aff_neg(
5102 __isl_take isl_multi_aff *ma);
5103 __isl_give isl_pw_aff *isl_pw_aff_neg(
5104 __isl_take isl_pw_aff *pwaff);
5105 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_neg(
5106 __isl_take isl_pw_multi_aff *pma);
5107 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_neg(
5108 __isl_take isl_multi_pw_aff *mpa);
5109 __isl_give isl_union_pw_aff *isl_union_pw_aff_neg(
5110 __isl_take isl_union_pw_aff *upa);
5111 __isl_give isl_union_pw_multi_aff *
5112 isl_union_pw_multi_aff_neg(
5113 __isl_take isl_union_pw_multi_aff *upma);
5114 __isl_give isl_multi_union_pw_aff *
5115 isl_multi_union_pw_aff_neg(
5116 __isl_take isl_multi_union_pw_aff *mupa);
5117 __isl_give isl_aff *isl_aff_ceil(
5118 __isl_take isl_aff *aff);
5119 __isl_give isl_pw_aff *isl_pw_aff_ceil(
5120 __isl_take isl_pw_aff *pwaff);
5121 __isl_give isl_aff *isl_aff_floor(
5122 __isl_take isl_aff *aff);
5123 __isl_give isl_multi_aff *isl_multi_aff_floor(
5124 __isl_take isl_multi_aff *ma);
5125 __isl_give isl_pw_aff *isl_pw_aff_floor(
5126 __isl_take isl_pw_aff *pwaff);
5127 __isl_give isl_union_pw_aff *isl_union_pw_aff_floor(
5128 __isl_take isl_union_pw_aff *upa);
5129 __isl_give isl_multi_union_pw_aff *
5130 isl_multi_union_pw_aff_floor(
5131 __isl_take isl_multi_union_pw_aff *mupa);
5133 #include <isl/aff.h>
5134 __isl_give isl_pw_aff *isl_pw_aff_list_min(
5135 __isl_take isl_pw_aff_list *list);
5136 __isl_give isl_pw_aff *isl_pw_aff_list_max(
5137 __isl_take isl_pw_aff_list *list);
5139 #include <isl/polynomial.h>
5140 __isl_give isl_qpolynomial *isl_qpolynomial_neg(
5141 __isl_take isl_qpolynomial *qp);
5142 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_neg(
5143 __isl_take isl_pw_qpolynomial *pwqp);
5144 __isl_give isl_union_pw_qpolynomial *
5145 isl_union_pw_qpolynomial_neg(
5146 __isl_take isl_union_pw_qpolynomial *upwqp);
5147 __isl_give isl_qpolynomial *isl_qpolynomial_pow(
5148 __isl_take isl_qpolynomial *qp,
5150 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_pow(
5151 __isl_take isl_pw_qpolynomial *pwqp,
5156 The following functions evaluate a function in a point.
5158 #include <isl/polynomial.h>
5159 __isl_give isl_val *isl_pw_qpolynomial_eval(
5160 __isl_take isl_pw_qpolynomial *pwqp,
5161 __isl_take isl_point *pnt);
5162 __isl_give isl_val *isl_pw_qpolynomial_fold_eval(
5163 __isl_take isl_pw_qpolynomial_fold *pwf,
5164 __isl_take isl_point *pnt);
5165 __isl_give isl_val *isl_union_pw_qpolynomial_eval(
5166 __isl_take isl_union_pw_qpolynomial *upwqp,
5167 __isl_take isl_point *pnt);
5168 __isl_give isl_val *isl_union_pw_qpolynomial_fold_eval(
5169 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5170 __isl_take isl_point *pnt);
5172 =item * Dimension manipulation
5174 It is usually not advisable to directly change the (input or output)
5175 space of a set or a relation as this removes the name and the internal
5176 structure of the space. However, the functions below can be useful
5177 to add new parameters, assuming
5178 C<isl_set_align_params> and C<isl_map_align_params>
5181 #include <isl/space.h>
5182 __isl_give isl_space *isl_space_add_dims(
5183 __isl_take isl_space *space,
5184 enum isl_dim_type type, unsigned n);
5185 __isl_give isl_space *isl_space_insert_dims(
5186 __isl_take isl_space *space,
5187 enum isl_dim_type type, unsigned pos, unsigned n);
5188 __isl_give isl_space *isl_space_drop_dims(
5189 __isl_take isl_space *space,
5190 enum isl_dim_type type, unsigned first, unsigned n);
5191 __isl_give isl_space *isl_space_move_dims(
5192 __isl_take isl_space *space,
5193 enum isl_dim_type dst_type, unsigned dst_pos,
5194 enum isl_dim_type src_type, unsigned src_pos,
5197 #include <isl/local_space.h>
5198 __isl_give isl_local_space *isl_local_space_add_dims(
5199 __isl_take isl_local_space *ls,
5200 enum isl_dim_type type, unsigned n);
5201 __isl_give isl_local_space *isl_local_space_insert_dims(
5202 __isl_take isl_local_space *ls,
5203 enum isl_dim_type type, unsigned first, unsigned n);
5204 __isl_give isl_local_space *isl_local_space_drop_dims(
5205 __isl_take isl_local_space *ls,
5206 enum isl_dim_type type, unsigned first, unsigned n);
5208 #include <isl/set.h>
5209 __isl_give isl_basic_set *isl_basic_set_add_dims(
5210 __isl_take isl_basic_set *bset,
5211 enum isl_dim_type type, unsigned n);
5212 __isl_give isl_set *isl_set_add_dims(
5213 __isl_take isl_set *set,
5214 enum isl_dim_type type, unsigned n);
5215 __isl_give isl_basic_set *isl_basic_set_insert_dims(
5216 __isl_take isl_basic_set *bset,
5217 enum isl_dim_type type, unsigned pos,
5219 __isl_give isl_set *isl_set_insert_dims(
5220 __isl_take isl_set *set,
5221 enum isl_dim_type type, unsigned pos, unsigned n);
5222 __isl_give isl_basic_set *isl_basic_set_move_dims(
5223 __isl_take isl_basic_set *bset,
5224 enum isl_dim_type dst_type, unsigned dst_pos,
5225 enum isl_dim_type src_type, unsigned src_pos,
5227 __isl_give isl_set *isl_set_move_dims(
5228 __isl_take isl_set *set,
5229 enum isl_dim_type dst_type, unsigned dst_pos,
5230 enum isl_dim_type src_type, unsigned src_pos,
5233 #include <isl/map.h>
5234 __isl_give isl_map *isl_map_add_dims(
5235 __isl_take isl_map *map,
5236 enum isl_dim_type type, unsigned n);
5237 __isl_give isl_basic_map *isl_basic_map_insert_dims(
5238 __isl_take isl_basic_map *bmap,
5239 enum isl_dim_type type, unsigned pos,
5241 __isl_give isl_map *isl_map_insert_dims(
5242 __isl_take isl_map *map,
5243 enum isl_dim_type type, unsigned pos, unsigned n);
5244 __isl_give isl_basic_map *isl_basic_map_move_dims(
5245 __isl_take isl_basic_map *bmap,
5246 enum isl_dim_type dst_type, unsigned dst_pos,
5247 enum isl_dim_type src_type, unsigned src_pos,
5249 __isl_give isl_map *isl_map_move_dims(
5250 __isl_take isl_map *map,
5251 enum isl_dim_type dst_type, unsigned dst_pos,
5252 enum isl_dim_type src_type, unsigned src_pos,
5255 #include <isl/val.h>
5256 __isl_give isl_multi_val *isl_multi_val_insert_dims(
5257 __isl_take isl_multi_val *mv,
5258 enum isl_dim_type type, unsigned first, unsigned n);
5259 __isl_give isl_multi_val *isl_multi_val_add_dims(
5260 __isl_take isl_multi_val *mv,
5261 enum isl_dim_type type, unsigned n);
5262 __isl_give isl_multi_val *isl_multi_val_drop_dims(
5263 __isl_take isl_multi_val *mv,
5264 enum isl_dim_type type, unsigned first, unsigned n);
5266 #include <isl/aff.h>
5267 __isl_give isl_aff *isl_aff_insert_dims(
5268 __isl_take isl_aff *aff,
5269 enum isl_dim_type type, unsigned first, unsigned n);
5270 __isl_give isl_multi_aff *isl_multi_aff_insert_dims(
5271 __isl_take isl_multi_aff *ma,
5272 enum isl_dim_type type, unsigned first, unsigned n);
5273 __isl_give isl_pw_aff *isl_pw_aff_insert_dims(
5274 __isl_take isl_pw_aff *pwaff,
5275 enum isl_dim_type type, unsigned first, unsigned n);
5276 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_insert_dims(
5277 __isl_take isl_multi_pw_aff *mpa,
5278 enum isl_dim_type type, unsigned first, unsigned n);
5279 __isl_give isl_aff *isl_aff_add_dims(
5280 __isl_take isl_aff *aff,
5281 enum isl_dim_type type, unsigned n);
5282 __isl_give isl_multi_aff *isl_multi_aff_add_dims(
5283 __isl_take isl_multi_aff *ma,
5284 enum isl_dim_type type, unsigned n);
5285 __isl_give isl_pw_aff *isl_pw_aff_add_dims(
5286 __isl_take isl_pw_aff *pwaff,
5287 enum isl_dim_type type, unsigned n);
5288 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_add_dims(
5289 __isl_take isl_multi_pw_aff *mpa,
5290 enum isl_dim_type type, unsigned n);
5291 __isl_give isl_aff *isl_aff_drop_dims(
5292 __isl_take isl_aff *aff,
5293 enum isl_dim_type type, unsigned first, unsigned n);
5294 __isl_give isl_multi_aff *isl_multi_aff_drop_dims(
5295 __isl_take isl_multi_aff *maff,
5296 enum isl_dim_type type, unsigned first, unsigned n);
5297 __isl_give isl_pw_aff *isl_pw_aff_drop_dims(
5298 __isl_take isl_pw_aff *pwaff,
5299 enum isl_dim_type type, unsigned first, unsigned n);
5300 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_drop_dims(
5301 __isl_take isl_pw_multi_aff *pma,
5302 enum isl_dim_type type, unsigned first, unsigned n);
5303 __isl_give isl_union_pw_aff *isl_union_pw_aff_drop_dims(
5304 __isl_take isl_union_pw_aff *upa,
5305 enum isl_dim_type type, unsigned first, unsigned n);
5306 __isl_give isl_union_pw_multi_aff *
5307 isl_union_pw_multi_aff_drop_dims(
5308 __isl_take isl_union_pw_multi_aff *upma,
5309 enum isl_dim_type type,
5310 unsigned first, unsigned n);
5311 __isl_give isl_multi_union_pw_aff *
5312 isl_multi_union_pw_aff_drop_dims(
5313 __isl_take isl_multi_union_pw_aff *mupa,
5314 enum isl_dim_type type, unsigned first,
5316 __isl_give isl_aff *isl_aff_move_dims(
5317 __isl_take isl_aff *aff,
5318 enum isl_dim_type dst_type, unsigned dst_pos,
5319 enum isl_dim_type src_type, unsigned src_pos,
5321 __isl_give isl_multi_aff *isl_multi_aff_move_dims(
5322 __isl_take isl_multi_aff *ma,
5323 enum isl_dim_type dst_type, unsigned dst_pos,
5324 enum isl_dim_type src_type, unsigned src_pos,
5326 __isl_give isl_pw_aff *isl_pw_aff_move_dims(
5327 __isl_take isl_pw_aff *pa,
5328 enum isl_dim_type dst_type, unsigned dst_pos,
5329 enum isl_dim_type src_type, unsigned src_pos,
5331 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_move_dims(
5332 __isl_take isl_multi_pw_aff *pma,
5333 enum isl_dim_type dst_type, unsigned dst_pos,
5334 enum isl_dim_type src_type, unsigned src_pos,
5337 #include <isl/polynomial.h>
5338 __isl_give isl_union_pw_qpolynomial *
5339 isl_union_pw_qpolynomial_drop_dims(
5340 __isl_take isl_union_pw_qpolynomial *upwqp,
5341 enum isl_dim_type type,
5342 unsigned first, unsigned n);
5343 __isl_give isl_union_pw_qpolynomial_fold *
5344 isl_union_pw_qpolynomial_fold_drop_dims(
5345 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5346 enum isl_dim_type type,
5347 unsigned first, unsigned n);
5349 The operations on union expressions can only manipulate parameters.
5353 =head2 Binary Operations
5355 The two arguments of a binary operation not only need to live
5356 in the same C<isl_ctx>, they currently also need to have
5357 the same (number of) parameters.
5359 =head3 Basic Operations
5363 =item * Intersection
5365 #include <isl/local_space.h>
5366 __isl_give isl_local_space *isl_local_space_intersect(
5367 __isl_take isl_local_space *ls1,
5368 __isl_take isl_local_space *ls2);
5370 #include <isl/set.h>
5371 __isl_give isl_basic_set *isl_basic_set_intersect_params(
5372 __isl_take isl_basic_set *bset1,
5373 __isl_take isl_basic_set *bset2);
5374 __isl_give isl_basic_set *isl_basic_set_intersect(
5375 __isl_take isl_basic_set *bset1,
5376 __isl_take isl_basic_set *bset2);
5377 __isl_give isl_basic_set *isl_basic_set_list_intersect(
5378 __isl_take struct isl_basic_set_list *list);
5379 __isl_give isl_set *isl_set_intersect_params(
5380 __isl_take isl_set *set,
5381 __isl_take isl_set *params);
5382 __isl_give isl_set *isl_set_intersect(
5383 __isl_take isl_set *set1,
5384 __isl_take isl_set *set2);
5386 #include <isl/map.h>
5387 __isl_give isl_basic_map *isl_basic_map_intersect_domain(
5388 __isl_take isl_basic_map *bmap,
5389 __isl_take isl_basic_set *bset);
5390 __isl_give isl_basic_map *isl_basic_map_intersect_range(
5391 __isl_take isl_basic_map *bmap,
5392 __isl_take isl_basic_set *bset);
5393 __isl_give isl_basic_map *isl_basic_map_intersect(
5394 __isl_take isl_basic_map *bmap1,
5395 __isl_take isl_basic_map *bmap2);
5396 __isl_give isl_basic_map *isl_basic_map_list_intersect(
5397 __isl_take isl_basic_map_list *list);
5398 __isl_give isl_map *isl_map_intersect_params(
5399 __isl_take isl_map *map,
5400 __isl_take isl_set *params);
5401 __isl_give isl_map *isl_map_intersect_domain(
5402 __isl_take isl_map *map,
5403 __isl_take isl_set *set);
5404 __isl_give isl_map *isl_map_intersect_range(
5405 __isl_take isl_map *map,
5406 __isl_take isl_set *set);
5407 __isl_give isl_map *isl_map_intersect(
5408 __isl_take isl_map *map1,
5409 __isl_take isl_map *map2);
5411 #include <isl/union_set.h>
5412 __isl_give isl_union_set *isl_union_set_intersect_params(
5413 __isl_take isl_union_set *uset,
5414 __isl_take isl_set *set);
5415 __isl_give isl_union_set *isl_union_set_intersect(
5416 __isl_take isl_union_set *uset1,
5417 __isl_take isl_union_set *uset2);
5419 #include <isl/union_map.h>
5420 __isl_give isl_union_map *isl_union_map_intersect_params(
5421 __isl_take isl_union_map *umap,
5422 __isl_take isl_set *set);
5423 __isl_give isl_union_map *isl_union_map_intersect_domain(
5424 __isl_take isl_union_map *umap,
5425 __isl_take isl_union_set *uset);
5426 __isl_give isl_union_map *isl_union_map_intersect_range(
5427 __isl_take isl_union_map *umap,
5428 __isl_take isl_union_set *uset);
5429 __isl_give isl_union_map *isl_union_map_intersect(
5430 __isl_take isl_union_map *umap1,
5431 __isl_take isl_union_map *umap2);
5433 #include <isl/aff.h>
5434 __isl_give isl_pw_aff *isl_pw_aff_intersect_domain(
5435 __isl_take isl_pw_aff *pa,
5436 __isl_take isl_set *set);
5437 __isl_give isl_multi_pw_aff *
5438 isl_multi_pw_aff_intersect_domain(
5439 __isl_take isl_multi_pw_aff *mpa,
5440 __isl_take isl_set *domain);
5441 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_domain(
5442 __isl_take isl_pw_multi_aff *pma,
5443 __isl_take isl_set *set);
5444 __isl_give isl_union_pw_aff *isl_union_pw_aff_intersect_domain(
5445 __isl_take isl_union_pw_aff *upa,
5446 __isl_take isl_union_set *uset);
5447 __isl_give isl_union_pw_multi_aff *
5448 isl_union_pw_multi_aff_intersect_domain(
5449 __isl_take isl_union_pw_multi_aff *upma,
5450 __isl_take isl_union_set *uset);
5451 __isl_give isl_multi_union_pw_aff *
5452 isl_multi_union_pw_aff_intersect_domain(
5453 __isl_take isl_multi_union_pw_aff *mupa,
5454 __isl_take isl_union_set *uset);
5455 __isl_give isl_pw_aff *isl_pw_aff_intersect_params(
5456 __isl_take isl_pw_aff *pa,
5457 __isl_take isl_set *set);
5458 __isl_give isl_multi_pw_aff *
5459 isl_multi_pw_aff_intersect_params(
5460 __isl_take isl_multi_pw_aff *mpa,
5461 __isl_take isl_set *set);
5462 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_params(
5463 __isl_take isl_pw_multi_aff *pma,
5464 __isl_take isl_set *set);
5465 __isl_give isl_union_pw_aff *
5466 isl_union_pw_aff_intersect_params(
5467 __isl_take isl_union_pw_aff *upa,
5468 __isl_give isl_union_pw_multi_aff *
5469 isl_union_pw_multi_aff_intersect_params(
5470 __isl_take isl_union_pw_multi_aff *upma,
5471 __isl_take isl_set *set);
5472 __isl_give isl_multi_union_pw_aff *
5473 isl_multi_union_pw_aff_intersect_params(
5474 __isl_take isl_multi_union_pw_aff *mupa,
5475 __isl_take isl_set *params);
5476 isl_multi_union_pw_aff_intersect_range(
5477 __isl_take isl_multi_union_pw_aff *mupa,
5478 __isl_take isl_set *set);
5480 #include <isl/polynomial.h>
5481 __isl_give isl_pw_qpolynomial *
5482 isl_pw_qpolynomial_intersect_domain(
5483 __isl_take isl_pw_qpolynomial *pwpq,
5484 __isl_take isl_set *set);
5485 __isl_give isl_union_pw_qpolynomial *
5486 isl_union_pw_qpolynomial_intersect_domain(
5487 __isl_take isl_union_pw_qpolynomial *upwpq,
5488 __isl_take isl_union_set *uset);
5489 __isl_give isl_union_pw_qpolynomial_fold *
5490 isl_union_pw_qpolynomial_fold_intersect_domain(
5491 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5492 __isl_take isl_union_set *uset);
5493 __isl_give isl_pw_qpolynomial *
5494 isl_pw_qpolynomial_intersect_params(
5495 __isl_take isl_pw_qpolynomial *pwpq,
5496 __isl_take isl_set *set);
5497 __isl_give isl_pw_qpolynomial_fold *
5498 isl_pw_qpolynomial_fold_intersect_params(
5499 __isl_take isl_pw_qpolynomial_fold *pwf,
5500 __isl_take isl_set *set);
5501 __isl_give isl_union_pw_qpolynomial *
5502 isl_union_pw_qpolynomial_intersect_params(
5503 __isl_take isl_union_pw_qpolynomial *upwpq,
5504 __isl_take isl_set *set);
5505 __isl_give isl_union_pw_qpolynomial_fold *
5506 isl_union_pw_qpolynomial_fold_intersect_params(
5507 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5508 __isl_take isl_set *set);
5510 The second argument to the C<_params> functions needs to be
5511 a parametric (basic) set. For the other functions, a parametric set
5512 for either argument is only allowed if the other argument is
5513 a parametric set as well.
5514 The list passed to C<isl_basic_set_list_intersect> needs to have
5515 at least one element and all elements need to live in the same space.
5516 The function C<isl_multi_union_pw_aff_intersect_range>
5517 restricts the input function to those shared domain elements
5518 that map to the specified range.
5522 #include <isl/set.h>
5523 __isl_give isl_set *isl_basic_set_union(
5524 __isl_take isl_basic_set *bset1,
5525 __isl_take isl_basic_set *bset2);
5526 __isl_give isl_set *isl_set_union(
5527 __isl_take isl_set *set1,
5528 __isl_take isl_set *set2);
5530 #include <isl/map.h>
5531 __isl_give isl_map *isl_basic_map_union(
5532 __isl_take isl_basic_map *bmap1,
5533 __isl_take isl_basic_map *bmap2);
5534 __isl_give isl_map *isl_map_union(
5535 __isl_take isl_map *map1,
5536 __isl_take isl_map *map2);
5538 #include <isl/union_set.h>
5539 __isl_give isl_union_set *isl_union_set_union(
5540 __isl_take isl_union_set *uset1,
5541 __isl_take isl_union_set *uset2);
5542 __isl_give isl_union_set *isl_union_set_list_union(
5543 __isl_take isl_union_set_list *list);
5545 #include <isl/union_map.h>
5546 __isl_give isl_union_map *isl_union_map_union(
5547 __isl_take isl_union_map *umap1,
5548 __isl_take isl_union_map *umap2);
5550 =item * Set difference
5552 #include <isl/set.h>
5553 __isl_give isl_set *isl_set_subtract(
5554 __isl_take isl_set *set1,
5555 __isl_take isl_set *set2);
5557 #include <isl/map.h>
5558 __isl_give isl_map *isl_map_subtract(
5559 __isl_take isl_map *map1,
5560 __isl_take isl_map *map2);
5561 __isl_give isl_map *isl_map_subtract_domain(
5562 __isl_take isl_map *map,
5563 __isl_take isl_set *dom);
5564 __isl_give isl_map *isl_map_subtract_range(
5565 __isl_take isl_map *map,
5566 __isl_take isl_set *dom);
5568 #include <isl/union_set.h>
5569 __isl_give isl_union_set *isl_union_set_subtract(
5570 __isl_take isl_union_set *uset1,
5571 __isl_take isl_union_set *uset2);
5573 #include <isl/union_map.h>
5574 __isl_give isl_union_map *isl_union_map_subtract(
5575 __isl_take isl_union_map *umap1,
5576 __isl_take isl_union_map *umap2);
5577 __isl_give isl_union_map *isl_union_map_subtract_domain(
5578 __isl_take isl_union_map *umap,
5579 __isl_take isl_union_set *dom);
5580 __isl_give isl_union_map *isl_union_map_subtract_range(
5581 __isl_take isl_union_map *umap,
5582 __isl_take isl_union_set *dom);
5584 #include <isl/aff.h>
5585 __isl_give isl_pw_aff *isl_pw_aff_subtract_domain(
5586 __isl_take isl_pw_aff *pa,
5587 __isl_take isl_set *set);
5588 __isl_give isl_pw_multi_aff *
5589 isl_pw_multi_aff_subtract_domain(
5590 __isl_take isl_pw_multi_aff *pma,
5591 __isl_take isl_set *set);
5592 __isl_give isl_union_pw_aff *
5593 isl_union_pw_aff_subtract_domain(
5594 __isl_take isl_union_pw_aff *upa,
5595 __isl_take isl_union_set *uset);
5596 __isl_give isl_union_pw_multi_aff *
5597 isl_union_pw_multi_aff_subtract_domain(
5598 __isl_take isl_union_pw_multi_aff *upma,
5599 __isl_take isl_set *set);
5601 #include <isl/polynomial.h>
5602 __isl_give isl_pw_qpolynomial *
5603 isl_pw_qpolynomial_subtract_domain(
5604 __isl_take isl_pw_qpolynomial *pwpq,
5605 __isl_take isl_set *set);
5606 __isl_give isl_pw_qpolynomial_fold *
5607 isl_pw_qpolynomial_fold_subtract_domain(
5608 __isl_take isl_pw_qpolynomial_fold *pwf,
5609 __isl_take isl_set *set);
5610 __isl_give isl_union_pw_qpolynomial *
5611 isl_union_pw_qpolynomial_subtract_domain(
5612 __isl_take isl_union_pw_qpolynomial *upwpq,
5613 __isl_take isl_union_set *uset);
5614 __isl_give isl_union_pw_qpolynomial_fold *
5615 isl_union_pw_qpolynomial_fold_subtract_domain(
5616 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5617 __isl_take isl_union_set *uset);
5621 #include <isl/space.h>
5622 __isl_give isl_space *isl_space_join(
5623 __isl_take isl_space *left,
5624 __isl_take isl_space *right);
5626 #include <isl/map.h>
5627 __isl_give isl_basic_set *isl_basic_set_apply(
5628 __isl_take isl_basic_set *bset,
5629 __isl_take isl_basic_map *bmap);
5630 __isl_give isl_set *isl_set_apply(
5631 __isl_take isl_set *set,
5632 __isl_take isl_map *map);
5633 __isl_give isl_union_set *isl_union_set_apply(
5634 __isl_take isl_union_set *uset,
5635 __isl_take isl_union_map *umap);
5636 __isl_give isl_basic_map *isl_basic_map_apply_domain(
5637 __isl_take isl_basic_map *bmap1,
5638 __isl_take isl_basic_map *bmap2);
5639 __isl_give isl_basic_map *isl_basic_map_apply_range(
5640 __isl_take isl_basic_map *bmap1,
5641 __isl_take isl_basic_map *bmap2);
5642 __isl_give isl_map *isl_map_apply_domain(
5643 __isl_take isl_map *map1,
5644 __isl_take isl_map *map2);
5645 __isl_give isl_map *isl_map_apply_range(
5646 __isl_take isl_map *map1,
5647 __isl_take isl_map *map2);
5649 #include <isl/union_map.h>
5650 __isl_give isl_union_map *isl_union_map_apply_domain(
5651 __isl_take isl_union_map *umap1,
5652 __isl_take isl_union_map *umap2);
5653 __isl_give isl_union_map *isl_union_map_apply_range(
5654 __isl_take isl_union_map *umap1,
5655 __isl_take isl_union_map *umap2);
5657 #include <isl/aff.h>
5658 __isl_give isl_union_pw_aff *
5659 isl_multi_union_pw_aff_apply_aff(
5660 __isl_take isl_multi_union_pw_aff *mupa,
5661 __isl_take isl_aff *aff);
5662 __isl_give isl_union_pw_aff *
5663 isl_multi_union_pw_aff_apply_pw_aff(
5664 __isl_take isl_multi_union_pw_aff *mupa,
5665 __isl_take isl_pw_aff *pa);
5666 __isl_give isl_multi_union_pw_aff *
5667 isl_multi_union_pw_aff_apply_multi_aff(
5668 __isl_take isl_multi_union_pw_aff *mupa,
5669 __isl_take isl_multi_aff *ma);
5670 __isl_give isl_multi_union_pw_aff *
5671 isl_multi_union_pw_aff_apply_pw_multi_aff(
5672 __isl_take isl_multi_union_pw_aff *mupa,
5673 __isl_take isl_pw_multi_aff *pma);
5675 The result of C<isl_multi_union_pw_aff_apply_aff> is defined
5676 over the shared domain of the elements of the input. The dimension is
5677 required to be greater than zero.
5678 The C<isl_multi_union_pw_aff> argument of
5679 C<isl_multi_union_pw_aff_apply_multi_aff> is allowed to be zero-dimensional,
5680 but only if the range of the C<isl_multi_aff> argument
5681 is also zero-dimensional.
5682 Similarly for C<isl_multi_union_pw_aff_apply_pw_multi_aff>.
5684 #include <isl/polynomial.h>
5685 __isl_give isl_pw_qpolynomial_fold *
5686 isl_set_apply_pw_qpolynomial_fold(
5687 __isl_take isl_set *set,
5688 __isl_take isl_pw_qpolynomial_fold *pwf,
5690 __isl_give isl_pw_qpolynomial_fold *
5691 isl_map_apply_pw_qpolynomial_fold(
5692 __isl_take isl_map *map,
5693 __isl_take isl_pw_qpolynomial_fold *pwf,
5695 __isl_give isl_union_pw_qpolynomial_fold *
5696 isl_union_set_apply_union_pw_qpolynomial_fold(
5697 __isl_take isl_union_set *uset,
5698 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5700 __isl_give isl_union_pw_qpolynomial_fold *
5701 isl_union_map_apply_union_pw_qpolynomial_fold(
5702 __isl_take isl_union_map *umap,
5703 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5706 The functions taking a map
5707 compose the given map with the given piecewise quasipolynomial reduction.
5708 That is, compute a bound (of the same type as C<pwf> or C<upwf> itself)
5709 over all elements in the intersection of the range of the map
5710 and the domain of the piecewise quasipolynomial reduction
5711 as a function of an element in the domain of the map.
5712 The functions taking a set compute a bound over all elements in the
5713 intersection of the set and the domain of the
5714 piecewise quasipolynomial reduction.
5718 #include <isl/set.h>
5719 __isl_give isl_basic_set *
5720 isl_basic_set_preimage_multi_aff(
5721 __isl_take isl_basic_set *bset,
5722 __isl_take isl_multi_aff *ma);
5723 __isl_give isl_set *isl_set_preimage_multi_aff(
5724 __isl_take isl_set *set,
5725 __isl_take isl_multi_aff *ma);
5726 __isl_give isl_set *isl_set_preimage_pw_multi_aff(
5727 __isl_take isl_set *set,
5728 __isl_take isl_pw_multi_aff *pma);
5729 __isl_give isl_set *isl_set_preimage_multi_pw_aff(
5730 __isl_take isl_set *set,
5731 __isl_take isl_multi_pw_aff *mpa);
5733 #include <isl/union_set.h>
5734 __isl_give isl_union_set *
5735 isl_union_set_preimage_multi_aff(
5736 __isl_take isl_union_set *uset,
5737 __isl_take isl_multi_aff *ma);
5738 __isl_give isl_union_set *
5739 isl_union_set_preimage_pw_multi_aff(
5740 __isl_take isl_union_set *uset,
5741 __isl_take isl_pw_multi_aff *pma);
5742 __isl_give isl_union_set *
5743 isl_union_set_preimage_union_pw_multi_aff(
5744 __isl_take isl_union_set *uset,
5745 __isl_take isl_union_pw_multi_aff *upma);
5747 #include <isl/map.h>
5748 __isl_give isl_basic_map *
5749 isl_basic_map_preimage_domain_multi_aff(
5750 __isl_take isl_basic_map *bmap,
5751 __isl_take isl_multi_aff *ma);
5752 __isl_give isl_map *isl_map_preimage_domain_multi_aff(
5753 __isl_take isl_map *map,
5754 __isl_take isl_multi_aff *ma);
5755 __isl_give isl_map *isl_map_preimage_range_multi_aff(
5756 __isl_take isl_map *map,
5757 __isl_take isl_multi_aff *ma);
5758 __isl_give isl_map *
5759 isl_map_preimage_domain_pw_multi_aff(
5760 __isl_take isl_map *map,
5761 __isl_take isl_pw_multi_aff *pma);
5762 __isl_give isl_map *
5763 isl_map_preimage_range_pw_multi_aff(
5764 __isl_take isl_map *map,
5765 __isl_take isl_pw_multi_aff *pma);
5766 __isl_give isl_map *
5767 isl_map_preimage_domain_multi_pw_aff(
5768 __isl_take isl_map *map,
5769 __isl_take isl_multi_pw_aff *mpa);
5770 __isl_give isl_basic_map *
5771 isl_basic_map_preimage_range_multi_aff(
5772 __isl_take isl_basic_map *bmap,
5773 __isl_take isl_multi_aff *ma);
5775 #include <isl/union_map.h>
5776 __isl_give isl_union_map *
5777 isl_union_map_preimage_domain_multi_aff(
5778 __isl_take isl_union_map *umap,
5779 __isl_take isl_multi_aff *ma);
5780 __isl_give isl_union_map *
5781 isl_union_map_preimage_range_multi_aff(
5782 __isl_take isl_union_map *umap,
5783 __isl_take isl_multi_aff *ma);
5784 __isl_give isl_union_map *
5785 isl_union_map_preimage_domain_pw_multi_aff(
5786 __isl_take isl_union_map *umap,
5787 __isl_take isl_pw_multi_aff *pma);
5788 __isl_give isl_union_map *
5789 isl_union_map_preimage_range_pw_multi_aff(
5790 __isl_take isl_union_map *umap,
5791 __isl_take isl_pw_multi_aff *pma);
5792 __isl_give isl_union_map *
5793 isl_union_map_preimage_domain_union_pw_multi_aff(
5794 __isl_take isl_union_map *umap,
5795 __isl_take isl_union_pw_multi_aff *upma);
5796 __isl_give isl_union_map *
5797 isl_union_map_preimage_range_union_pw_multi_aff(
5798 __isl_take isl_union_map *umap,
5799 __isl_take isl_union_pw_multi_aff *upma);
5801 These functions compute the preimage of the given set or map domain/range under
5802 the given function. In other words, the expression is plugged
5803 into the set description or into the domain/range of the map.
5807 #include <isl/aff.h>
5808 __isl_give isl_aff *isl_aff_pullback_aff(
5809 __isl_take isl_aff *aff1,
5810 __isl_take isl_aff *aff2);
5811 __isl_give isl_aff *isl_aff_pullback_multi_aff(
5812 __isl_take isl_aff *aff,
5813 __isl_take isl_multi_aff *ma);
5814 __isl_give isl_pw_aff *isl_pw_aff_pullback_multi_aff(
5815 __isl_take isl_pw_aff *pa,
5816 __isl_take isl_multi_aff *ma);
5817 __isl_give isl_pw_aff *isl_pw_aff_pullback_pw_multi_aff(
5818 __isl_take isl_pw_aff *pa,
5819 __isl_take isl_pw_multi_aff *pma);
5820 __isl_give isl_pw_aff *isl_pw_aff_pullback_multi_pw_aff(
5821 __isl_take isl_pw_aff *pa,
5822 __isl_take isl_multi_pw_aff *mpa);
5823 __isl_give isl_multi_aff *isl_multi_aff_pullback_multi_aff(
5824 __isl_take isl_multi_aff *ma1,
5825 __isl_take isl_multi_aff *ma2);
5826 __isl_give isl_pw_multi_aff *
5827 isl_pw_multi_aff_pullback_multi_aff(
5828 __isl_take isl_pw_multi_aff *pma,
5829 __isl_take isl_multi_aff *ma);
5830 __isl_give isl_multi_pw_aff *
5831 isl_multi_pw_aff_pullback_multi_aff(
5832 __isl_take isl_multi_pw_aff *mpa,
5833 __isl_take isl_multi_aff *ma);
5834 __isl_give isl_pw_multi_aff *
5835 isl_pw_multi_aff_pullback_pw_multi_aff(
5836 __isl_take isl_pw_multi_aff *pma1,
5837 __isl_take isl_pw_multi_aff *pma2);
5838 __isl_give isl_multi_pw_aff *
5839 isl_multi_pw_aff_pullback_pw_multi_aff(
5840 __isl_take isl_multi_pw_aff *mpa,
5841 __isl_take isl_pw_multi_aff *pma);
5842 __isl_give isl_multi_pw_aff *
5843 isl_multi_pw_aff_pullback_multi_pw_aff(
5844 __isl_take isl_multi_pw_aff *mpa1,
5845 __isl_take isl_multi_pw_aff *mpa2);
5846 __isl_give isl_union_pw_aff *
5847 isl_union_pw_aff_pullback_union_pw_multi_aff(
5848 __isl_take isl_union_pw_aff *upa,
5849 __isl_take isl_union_pw_multi_aff *upma);
5850 __isl_give isl_union_pw_multi_aff *
5851 isl_union_pw_multi_aff_pullback_union_pw_multi_aff(
5852 __isl_take isl_union_pw_multi_aff *upma1,
5853 __isl_take isl_union_pw_multi_aff *upma2);
5854 __isl_give isl_multi_union_pw_aff *
5855 isl_multi_union_pw_aff_pullback_union_pw_multi_aff(
5856 __isl_take isl_multi_union_pw_aff *mupa,
5857 __isl_take isl_union_pw_multi_aff *upma);
5859 These functions precompose the first expression by the second function.
5860 In other words, the second function is plugged
5861 into the first expression.
5865 #include <isl/aff.h>
5866 __isl_give isl_basic_set *isl_aff_le_basic_set(
5867 __isl_take isl_aff *aff1,
5868 __isl_take isl_aff *aff2);
5869 __isl_give isl_basic_set *isl_aff_ge_basic_set(
5870 __isl_take isl_aff *aff1,
5871 __isl_take isl_aff *aff2);
5872 __isl_give isl_set *isl_pw_aff_eq_set(
5873 __isl_take isl_pw_aff *pwaff1,
5874 __isl_take isl_pw_aff *pwaff2);
5875 __isl_give isl_set *isl_pw_aff_ne_set(
5876 __isl_take isl_pw_aff *pwaff1,
5877 __isl_take isl_pw_aff *pwaff2);
5878 __isl_give isl_set *isl_pw_aff_le_set(
5879 __isl_take isl_pw_aff *pwaff1,
5880 __isl_take isl_pw_aff *pwaff2);
5881 __isl_give isl_set *isl_pw_aff_lt_set(
5882 __isl_take isl_pw_aff *pwaff1,
5883 __isl_take isl_pw_aff *pwaff2);
5884 __isl_give isl_set *isl_pw_aff_ge_set(
5885 __isl_take isl_pw_aff *pwaff1,
5886 __isl_take isl_pw_aff *pwaff2);
5887 __isl_give isl_set *isl_pw_aff_gt_set(
5888 __isl_take isl_pw_aff *pwaff1,
5889 __isl_take isl_pw_aff *pwaff2);
5891 __isl_give isl_set *isl_multi_aff_lex_le_set(
5892 __isl_take isl_multi_aff *ma1,
5893 __isl_take isl_multi_aff *ma2);
5894 __isl_give isl_set *isl_multi_aff_lex_ge_set(
5895 __isl_take isl_multi_aff *ma1,
5896 __isl_take isl_multi_aff *ma2);
5898 __isl_give isl_set *isl_pw_aff_list_eq_set(
5899 __isl_take isl_pw_aff_list *list1,
5900 __isl_take isl_pw_aff_list *list2);
5901 __isl_give isl_set *isl_pw_aff_list_ne_set(
5902 __isl_take isl_pw_aff_list *list1,
5903 __isl_take isl_pw_aff_list *list2);
5904 __isl_give isl_set *isl_pw_aff_list_le_set(
5905 __isl_take isl_pw_aff_list *list1,
5906 __isl_take isl_pw_aff_list *list2);
5907 __isl_give isl_set *isl_pw_aff_list_lt_set(
5908 __isl_take isl_pw_aff_list *list1,
5909 __isl_take isl_pw_aff_list *list2);
5910 __isl_give isl_set *isl_pw_aff_list_ge_set(
5911 __isl_take isl_pw_aff_list *list1,
5912 __isl_take isl_pw_aff_list *list2);
5913 __isl_give isl_set *isl_pw_aff_list_gt_set(
5914 __isl_take isl_pw_aff_list *list1,
5915 __isl_take isl_pw_aff_list *list2);
5917 The function C<isl_aff_ge_basic_set> returns a basic set
5918 containing those elements in the shared space
5919 of C<aff1> and C<aff2> where C<aff1> is greater than or equal to C<aff2>.
5920 The function C<isl_pw_aff_ge_set> returns a set
5921 containing those elements in the shared domain
5922 of C<pwaff1> and C<pwaff2> where C<pwaff1> is
5923 greater than or equal to C<pwaff2>.
5924 The function C<isl_multi_aff_lex_le_set> returns a set
5925 containing those elements in the shared domain space
5926 where C<ma1> is lexicographically smaller than or
5928 The functions operating on C<isl_pw_aff_list> apply the corresponding
5929 C<isl_pw_aff> function to each pair of elements in the two lists.
5931 #include <isl/aff.h>
5932 __isl_give isl_map *isl_pw_aff_eq_map(
5933 __isl_take isl_pw_aff *pa1,
5934 __isl_take isl_pw_aff *pa2);
5935 __isl_give isl_map *isl_pw_aff_lt_map(
5936 __isl_take isl_pw_aff *pa1,
5937 __isl_take isl_pw_aff *pa2);
5938 __isl_give isl_map *isl_pw_aff_gt_map(
5939 __isl_take isl_pw_aff *pa1,
5940 __isl_take isl_pw_aff *pa2);
5942 __isl_give isl_map *isl_multi_pw_aff_eq_map(
5943 __isl_take isl_multi_pw_aff *mpa1,
5944 __isl_take isl_multi_pw_aff *mpa2);
5945 __isl_give isl_map *isl_multi_pw_aff_lex_lt_map(
5946 __isl_take isl_multi_pw_aff *mpa1,
5947 __isl_take isl_multi_pw_aff *mpa2);
5948 __isl_give isl_map *isl_multi_pw_aff_lex_gt_map(
5949 __isl_take isl_multi_pw_aff *mpa1,
5950 __isl_take isl_multi_pw_aff *mpa2);
5952 These functions return a map between domain elements of the arguments
5953 where the function values satisfy the given relation.
5955 #include <isl/union_map.h>
5956 __isl_give isl_union_map *
5957 isl_union_map_eq_at_multi_union_pw_aff(
5958 __isl_take isl_union_map *umap,
5959 __isl_take isl_multi_union_pw_aff *mupa);
5960 __isl_give isl_union_map *
5961 isl_union_map_lex_lt_at_multi_union_pw_aff(
5962 __isl_take isl_union_map *umap,
5963 __isl_take isl_multi_union_pw_aff *mupa);
5964 __isl_give isl_union_map *
5965 isl_union_map_lex_gt_at_multi_union_pw_aff(
5966 __isl_take isl_union_map *umap,
5967 __isl_take isl_multi_union_pw_aff *mupa);
5969 These functions select the subset of elements in the union map
5970 that have an equal or lexicographically smaller function value.
5972 =item * Cartesian Product
5974 #include <isl/space.h>
5975 __isl_give isl_space *isl_space_product(
5976 __isl_take isl_space *space1,
5977 __isl_take isl_space *space2);
5978 __isl_give isl_space *isl_space_domain_product(
5979 __isl_take isl_space *space1,
5980 __isl_take isl_space *space2);
5981 __isl_give isl_space *isl_space_range_product(
5982 __isl_take isl_space *space1,
5983 __isl_take isl_space *space2);
5986 C<isl_space_product>, C<isl_space_domain_product>
5987 and C<isl_space_range_product> take pairs or relation spaces and
5988 produce a single relations space, where either the domain, the range
5989 or both domain and range are wrapped spaces of relations between
5990 the domains and/or ranges of the input spaces.
5991 If the product is only constructed over the domain or the range
5992 then the ranges or the domains of the inputs should be the same.
5993 The function C<isl_space_product> also accepts a pair of set spaces,
5994 in which case it returns a wrapped space of a relation between the
5997 #include <isl/set.h>
5998 __isl_give isl_set *isl_set_product(
5999 __isl_take isl_set *set1,
6000 __isl_take isl_set *set2);
6002 #include <isl/map.h>
6003 __isl_give isl_basic_map *isl_basic_map_domain_product(
6004 __isl_take isl_basic_map *bmap1,
6005 __isl_take isl_basic_map *bmap2);
6006 __isl_give isl_basic_map *isl_basic_map_range_product(
6007 __isl_take isl_basic_map *bmap1,
6008 __isl_take isl_basic_map *bmap2);
6009 __isl_give isl_basic_map *isl_basic_map_product(
6010 __isl_take isl_basic_map *bmap1,
6011 __isl_take isl_basic_map *bmap2);
6012 __isl_give isl_map *isl_map_domain_product(
6013 __isl_take isl_map *map1,
6014 __isl_take isl_map *map2);
6015 __isl_give isl_map *isl_map_range_product(
6016 __isl_take isl_map *map1,
6017 __isl_take isl_map *map2);
6018 __isl_give isl_map *isl_map_product(
6019 __isl_take isl_map *map1,
6020 __isl_take isl_map *map2);
6022 #include <isl/union_set.h>
6023 __isl_give isl_union_set *isl_union_set_product(
6024 __isl_take isl_union_set *uset1,
6025 __isl_take isl_union_set *uset2);
6027 #include <isl/union_map.h>
6028 __isl_give isl_union_map *isl_union_map_domain_product(
6029 __isl_take isl_union_map *umap1,
6030 __isl_take isl_union_map *umap2);
6031 __isl_give isl_union_map *isl_union_map_range_product(
6032 __isl_take isl_union_map *umap1,
6033 __isl_take isl_union_map *umap2);
6034 __isl_give isl_union_map *isl_union_map_product(
6035 __isl_take isl_union_map *umap1,
6036 __isl_take isl_union_map *umap2);
6038 #include <isl/val.h>
6039 __isl_give isl_multi_val *isl_multi_val_range_product(
6040 __isl_take isl_multi_val *mv1,
6041 __isl_take isl_multi_val *mv2);
6042 __isl_give isl_multi_val *isl_multi_val_product(
6043 __isl_take isl_multi_val *mv1,
6044 __isl_take isl_multi_val *mv2);
6046 #include <isl/aff.h>
6047 __isl_give isl_multi_aff *isl_multi_aff_range_product(
6048 __isl_take isl_multi_aff *ma1,
6049 __isl_take isl_multi_aff *ma2);
6050 __isl_give isl_multi_aff *isl_multi_aff_product(
6051 __isl_take isl_multi_aff *ma1,
6052 __isl_take isl_multi_aff *ma2);
6053 __isl_give isl_multi_pw_aff *
6054 isl_multi_pw_aff_range_product(
6055 __isl_take isl_multi_pw_aff *mpa1,
6056 __isl_take isl_multi_pw_aff *mpa2);
6057 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_product(
6058 __isl_take isl_multi_pw_aff *mpa1,
6059 __isl_take isl_multi_pw_aff *mpa2);
6060 __isl_give isl_pw_multi_aff *
6061 isl_pw_multi_aff_range_product(
6062 __isl_take isl_pw_multi_aff *pma1,
6063 __isl_take isl_pw_multi_aff *pma2);
6064 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_product(
6065 __isl_take isl_pw_multi_aff *pma1,
6066 __isl_take isl_pw_multi_aff *pma2);
6067 __isl_give isl_multi_union_pw_aff *
6068 isl_multi_union_pw_aff_range_product(
6069 __isl_take isl_multi_union_pw_aff *mupa1,
6070 __isl_take isl_multi_union_pw_aff *mupa2);
6072 The above functions compute the cross product of the given
6073 sets, relations or functions. The domains and ranges of the results
6074 are wrapped maps between domains and ranges of the inputs.
6075 To obtain a ``flat'' product, use the following functions
6078 #include <isl/set.h>
6079 __isl_give isl_basic_set *isl_basic_set_flat_product(
6080 __isl_take isl_basic_set *bset1,
6081 __isl_take isl_basic_set *bset2);
6082 __isl_give isl_set *isl_set_flat_product(
6083 __isl_take isl_set *set1,
6084 __isl_take isl_set *set2);
6086 #include <isl/map.h>
6087 __isl_give isl_basic_map *isl_basic_map_flat_range_product(
6088 __isl_take isl_basic_map *bmap1,
6089 __isl_take isl_basic_map *bmap2);
6090 __isl_give isl_map *isl_map_flat_domain_product(
6091 __isl_take isl_map *map1,
6092 __isl_take isl_map *map2);
6093 __isl_give isl_map *isl_map_flat_range_product(
6094 __isl_take isl_map *map1,
6095 __isl_take isl_map *map2);
6096 __isl_give isl_basic_map *isl_basic_map_flat_product(
6097 __isl_take isl_basic_map *bmap1,
6098 __isl_take isl_basic_map *bmap2);
6099 __isl_give isl_map *isl_map_flat_product(
6100 __isl_take isl_map *map1,
6101 __isl_take isl_map *map2);
6103 #include <isl/union_map.h>
6104 __isl_give isl_union_map *
6105 isl_union_map_flat_domain_product(
6106 __isl_take isl_union_map *umap1,
6107 __isl_take isl_union_map *umap2);
6108 __isl_give isl_union_map *
6109 isl_union_map_flat_range_product(
6110 __isl_take isl_union_map *umap1,
6111 __isl_take isl_union_map *umap2);
6113 #include <isl/val.h>
6114 __isl_give isl_multi_val *isl_multi_val_flat_range_product(
6115 __isl_take isl_multi_val *mv1,
6116 __isl_take isl_multi_aff *mv2);
6118 #include <isl/aff.h>
6119 __isl_give isl_multi_aff *isl_multi_aff_flat_range_product(
6120 __isl_take isl_multi_aff *ma1,
6121 __isl_take isl_multi_aff *ma2);
6122 __isl_give isl_pw_multi_aff *
6123 isl_pw_multi_aff_flat_range_product(
6124 __isl_take isl_pw_multi_aff *pma1,
6125 __isl_take isl_pw_multi_aff *pma2);
6126 __isl_give isl_multi_pw_aff *
6127 isl_multi_pw_aff_flat_range_product(
6128 __isl_take isl_multi_pw_aff *mpa1,
6129 __isl_take isl_multi_pw_aff *mpa2);
6130 __isl_give isl_union_pw_multi_aff *
6131 isl_union_pw_multi_aff_flat_range_product(
6132 __isl_take isl_union_pw_multi_aff *upma1,
6133 __isl_take isl_union_pw_multi_aff *upma2);
6134 __isl_give isl_multi_union_pw_aff *
6135 isl_multi_union_pw_aff_flat_range_product(
6136 __isl_take isl_multi_union_pw_aff *mupa1,
6137 __isl_take isl_multi_union_pw_aff *mupa2);
6139 #include <isl/space.h>
6140 __isl_give isl_space *isl_space_factor_domain(
6141 __isl_take isl_space *space);
6142 __isl_give isl_space *isl_space_factor_range(
6143 __isl_take isl_space *space);
6144 __isl_give isl_space *isl_space_domain_factor_domain(
6145 __isl_take isl_space *space);
6146 __isl_give isl_space *isl_space_domain_factor_range(
6147 __isl_take isl_space *space);
6148 __isl_give isl_space *isl_space_range_factor_domain(
6149 __isl_take isl_space *space);
6150 __isl_give isl_space *isl_space_range_factor_range(
6151 __isl_take isl_space *space);
6153 The functions C<isl_space_range_factor_domain> and
6154 C<isl_space_range_factor_range> extract the two arguments from
6155 the result of a call to C<isl_space_range_product>.
6157 The arguments of a call to C<isl_map_range_product> can be extracted
6158 from the result using the following functions.
6160 #include <isl/map.h>
6161 __isl_give isl_map *isl_map_factor_domain(
6162 __isl_take isl_map *map);
6163 __isl_give isl_map *isl_map_factor_range(
6164 __isl_take isl_map *map);
6165 __isl_give isl_map *isl_map_domain_factor_domain(
6166 __isl_take isl_map *map);
6167 __isl_give isl_map *isl_map_domain_factor_range(
6168 __isl_take isl_map *map);
6169 __isl_give isl_map *isl_map_range_factor_domain(
6170 __isl_take isl_map *map);
6171 __isl_give isl_map *isl_map_range_factor_range(
6172 __isl_take isl_map *map);
6174 #include <isl/union_map.h>
6175 __isl_give isl_union_map *isl_union_map_factor_domain(
6176 __isl_take isl_union_map *umap);
6177 __isl_give isl_union_map *isl_union_map_factor_range(
6178 __isl_take isl_union_map *umap);
6179 __isl_give isl_union_map *
6180 isl_union_map_domain_factor_domain(
6181 __isl_take isl_union_map *umap);
6182 __isl_give isl_union_map *
6183 isl_union_map_domain_factor_range(
6184 __isl_take isl_union_map *umap);
6185 __isl_give isl_union_map *
6186 isl_union_map_range_factor_range(
6187 __isl_take isl_union_map *umap);
6189 #include <isl/val.h>
6190 __isl_give isl_multi_val *
6191 isl_multi_val_range_factor_domain(
6192 __isl_take isl_multi_val *mv);
6193 __isl_give isl_multi_val *
6194 isl_multi_val_range_factor_range(
6195 __isl_take isl_multi_val *mv);
6197 #include <isl/aff.h>
6198 __isl_give isl_multi_aff *
6199 isl_multi_aff_range_factor_domain(
6200 __isl_take isl_multi_aff *ma);
6201 __isl_give isl_multi_aff *
6202 isl_multi_aff_range_factor_range(
6203 __isl_take isl_multi_aff *ma);
6204 __isl_give isl_multi_pw_aff *
6205 isl_multi_pw_aff_range_factor_domain(
6206 __isl_take isl_multi_pw_aff *mpa);
6207 __isl_give isl_multi_pw_aff *
6208 isl_multi_pw_aff_range_factor_range(
6209 __isl_take isl_multi_pw_aff *mpa);
6210 __isl_give isl_multi_union_pw_aff *
6211 isl_multi_union_pw_aff_range_factor_domain(
6212 __isl_take isl_multi_union_pw_aff *mupa);
6213 __isl_give isl_multi_union_pw_aff *
6214 isl_multi_union_pw_aff_range_factor_range(
6215 __isl_take isl_multi_union_pw_aff *mupa);
6217 The splice functions are a generalization of the flat product functions,
6218 where the second argument may be inserted at any position inside
6219 the first argument rather than being placed at the end.
6221 #include <isl/val.h>
6222 __isl_give isl_multi_val *isl_multi_val_range_splice(
6223 __isl_take isl_multi_val *mv1, unsigned pos,
6224 __isl_take isl_multi_val *mv2);
6226 #include <isl/aff.h>
6227 __isl_give isl_multi_aff *isl_multi_aff_range_splice(
6228 __isl_take isl_multi_aff *ma1, unsigned pos,
6229 __isl_take isl_multi_aff *ma2);
6230 __isl_give isl_multi_aff *isl_multi_aff_splice(
6231 __isl_take isl_multi_aff *ma1,
6232 unsigned in_pos, unsigned out_pos,
6233 __isl_take isl_multi_aff *ma2);
6234 __isl_give isl_multi_pw_aff *
6235 isl_multi_pw_aff_range_splice(
6236 __isl_take isl_multi_pw_aff *mpa1, unsigned pos,
6237 __isl_take isl_multi_pw_aff *mpa2);
6238 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_splice(
6239 __isl_take isl_multi_pw_aff *mpa1,
6240 unsigned in_pos, unsigned out_pos,
6241 __isl_take isl_multi_pw_aff *mpa2);
6242 __isl_give isl_multi_union_pw_aff *
6243 isl_multi_union_pw_aff_range_splice(
6244 __isl_take isl_multi_union_pw_aff *mupa1,
6246 __isl_take isl_multi_union_pw_aff *mupa2);
6248 =item * Simplification
6250 When applied to a set or relation,
6251 the gist operation returns a set or relation that has the
6252 same intersection with the context as the input set or relation.
6253 Any implicit equality in the intersection is made explicit in the result,
6254 while all inequalities that are redundant with respect to the intersection
6256 In case of union sets and relations, the gist operation is performed
6259 When applied to a function,
6260 the gist operation applies the set gist operation to each of
6261 the cells in the domain of the input piecewise expression.
6262 The context is also exploited
6263 to simplify the expression associated to each cell.
6265 #include <isl/set.h>
6266 __isl_give isl_basic_set *isl_basic_set_gist(
6267 __isl_take isl_basic_set *bset,
6268 __isl_take isl_basic_set *context);
6269 __isl_give isl_set *isl_set_gist(__isl_take isl_set *set,
6270 __isl_take isl_set *context);
6271 __isl_give isl_set *isl_set_gist_params(
6272 __isl_take isl_set *set,
6273 __isl_take isl_set *context);
6275 #include <isl/map.h>
6276 __isl_give isl_basic_map *isl_basic_map_gist(
6277 __isl_take isl_basic_map *bmap,
6278 __isl_take isl_basic_map *context);
6279 __isl_give isl_basic_map *isl_basic_map_gist_domain(
6280 __isl_take isl_basic_map *bmap,
6281 __isl_take isl_basic_set *context);
6282 __isl_give isl_map *isl_map_gist(__isl_take isl_map *map,
6283 __isl_take isl_map *context);
6284 __isl_give isl_map *isl_map_gist_params(
6285 __isl_take isl_map *map,
6286 __isl_take isl_set *context);
6287 __isl_give isl_map *isl_map_gist_domain(
6288 __isl_take isl_map *map,
6289 __isl_take isl_set *context);
6290 __isl_give isl_map *isl_map_gist_range(
6291 __isl_take isl_map *map,
6292 __isl_take isl_set *context);
6294 #include <isl/union_set.h>
6295 __isl_give isl_union_set *isl_union_set_gist(
6296 __isl_take isl_union_set *uset,
6297 __isl_take isl_union_set *context);
6298 __isl_give isl_union_set *isl_union_set_gist_params(
6299 __isl_take isl_union_set *uset,
6300 __isl_take isl_set *set);
6302 #include <isl/union_map.h>
6303 __isl_give isl_union_map *isl_union_map_gist(
6304 __isl_take isl_union_map *umap,
6305 __isl_take isl_union_map *context);
6306 __isl_give isl_union_map *isl_union_map_gist_params(
6307 __isl_take isl_union_map *umap,
6308 __isl_take isl_set *set);
6309 __isl_give isl_union_map *isl_union_map_gist_domain(
6310 __isl_take isl_union_map *umap,
6311 __isl_take isl_union_set *uset);
6312 __isl_give isl_union_map *isl_union_map_gist_range(
6313 __isl_take isl_union_map *umap,
6314 __isl_take isl_union_set *uset);
6316 #include <isl/aff.h>
6317 __isl_give isl_aff *isl_aff_gist_params(
6318 __isl_take isl_aff *aff,
6319 __isl_take isl_set *context);
6320 __isl_give isl_aff *isl_aff_gist(__isl_take isl_aff *aff,
6321 __isl_take isl_set *context);
6322 __isl_give isl_multi_aff *isl_multi_aff_gist_params(
6323 __isl_take isl_multi_aff *maff,
6324 __isl_take isl_set *context);
6325 __isl_give isl_multi_aff *isl_multi_aff_gist(
6326 __isl_take isl_multi_aff *maff,
6327 __isl_take isl_set *context);
6328 __isl_give isl_pw_aff *isl_pw_aff_gist_params(
6329 __isl_take isl_pw_aff *pwaff,
6330 __isl_take isl_set *context);
6331 __isl_give isl_pw_aff *isl_pw_aff_gist(
6332 __isl_take isl_pw_aff *pwaff,
6333 __isl_take isl_set *context);
6334 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist_params(
6335 __isl_take isl_pw_multi_aff *pma,
6336 __isl_take isl_set *set);
6337 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist(
6338 __isl_take isl_pw_multi_aff *pma,
6339 __isl_take isl_set *set);
6340 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_gist_params(
6341 __isl_take isl_multi_pw_aff *mpa,
6342 __isl_take isl_set *set);
6343 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_gist(
6344 __isl_take isl_multi_pw_aff *mpa,
6345 __isl_take isl_set *set);
6346 __isl_give isl_union_pw_aff *isl_union_pw_aff_gist(
6347 __isl_take isl_union_pw_aff *upa,
6348 __isl_take isl_union_set *context);
6349 __isl_give isl_union_pw_aff *isl_union_pw_aff_gist_params(
6350 __isl_take isl_union_pw_aff *upa,
6351 __isl_take isl_set *context);
6352 __isl_give isl_union_pw_multi_aff *
6353 isl_union_pw_multi_aff_gist_params(
6354 __isl_take isl_union_pw_multi_aff *upma,
6355 __isl_take isl_set *context);
6356 __isl_give isl_union_pw_multi_aff *
6357 isl_union_pw_multi_aff_gist(
6358 __isl_take isl_union_pw_multi_aff *upma,
6359 __isl_take isl_union_set *context);
6360 __isl_give isl_multi_union_pw_aff *
6361 isl_multi_union_pw_aff_gist_params(
6362 __isl_take isl_multi_union_pw_aff *aff,
6363 __isl_take isl_set *context);
6364 __isl_give isl_multi_union_pw_aff *
6365 isl_multi_union_pw_aff_gist(
6366 __isl_take isl_multi_union_pw_aff *aff,
6367 __isl_take isl_union_set *context);
6369 #include <isl/polynomial.h>
6370 __isl_give isl_qpolynomial *isl_qpolynomial_gist_params(
6371 __isl_take isl_qpolynomial *qp,
6372 __isl_take isl_set *context);
6373 __isl_give isl_qpolynomial *isl_qpolynomial_gist(
6374 __isl_take isl_qpolynomial *qp,
6375 __isl_take isl_set *context);
6376 __isl_give isl_qpolynomial_fold *
6377 isl_qpolynomial_fold_gist_params(
6378 __isl_take isl_qpolynomial_fold *fold,
6379 __isl_take isl_set *context);
6380 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist(
6381 __isl_take isl_qpolynomial_fold *fold,
6382 __isl_take isl_set *context);
6383 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist_params(
6384 __isl_take isl_pw_qpolynomial *pwqp,
6385 __isl_take isl_set *context);
6386 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist(
6387 __isl_take isl_pw_qpolynomial *pwqp,
6388 __isl_take isl_set *context);
6389 __isl_give isl_pw_qpolynomial_fold *
6390 isl_pw_qpolynomial_fold_gist(
6391 __isl_take isl_pw_qpolynomial_fold *pwf,
6392 __isl_take isl_set *context);
6393 __isl_give isl_pw_qpolynomial_fold *
6394 isl_pw_qpolynomial_fold_gist_params(
6395 __isl_take isl_pw_qpolynomial_fold *pwf,
6396 __isl_take isl_set *context);
6397 __isl_give isl_union_pw_qpolynomial *
6398 isl_union_pw_qpolynomial_gist_params(
6399 __isl_take isl_union_pw_qpolynomial *upwqp,
6400 __isl_take isl_set *context);
6401 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_gist(
6402 __isl_take isl_union_pw_qpolynomial *upwqp,
6403 __isl_take isl_union_set *context);
6404 __isl_give isl_union_pw_qpolynomial_fold *
6405 isl_union_pw_qpolynomial_fold_gist(
6406 __isl_take isl_union_pw_qpolynomial_fold *upwf,
6407 __isl_take isl_union_set *context);
6408 __isl_give isl_union_pw_qpolynomial_fold *
6409 isl_union_pw_qpolynomial_fold_gist_params(
6410 __isl_take isl_union_pw_qpolynomial_fold *upwf,
6411 __isl_take isl_set *context);
6413 =item * Binary Arithmethic Operations
6415 #include <isl/val.h>
6416 __isl_give isl_multi_val *isl_multi_val_sub(
6417 __isl_take isl_multi_val *mv1,
6418 __isl_take isl_multi_val *mv2);
6420 #include <isl/aff.h>
6421 __isl_give isl_aff *isl_aff_add(
6422 __isl_take isl_aff *aff1,
6423 __isl_take isl_aff *aff2);
6424 __isl_give isl_multi_aff *isl_multi_aff_add(
6425 __isl_take isl_multi_aff *maff1,
6426 __isl_take isl_multi_aff *maff2);
6427 __isl_give isl_pw_aff *isl_pw_aff_add(
6428 __isl_take isl_pw_aff *pwaff1,
6429 __isl_take isl_pw_aff *pwaff2);
6430 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_add(
6431 __isl_take isl_pw_multi_aff *pma1,
6432 __isl_take isl_pw_multi_aff *pma2);
6433 __isl_give isl_union_pw_aff *isl_union_pw_aff_add(
6434 __isl_take isl_union_pw_aff *upa1,
6435 __isl_take isl_union_pw_aff *upa2);
6436 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_add(
6437 __isl_take isl_union_pw_multi_aff *upma1,
6438 __isl_take isl_union_pw_multi_aff *upma2);
6439 __isl_give isl_pw_aff *isl_pw_aff_min(
6440 __isl_take isl_pw_aff *pwaff1,
6441 __isl_take isl_pw_aff *pwaff2);
6442 __isl_give isl_pw_aff *isl_pw_aff_max(
6443 __isl_take isl_pw_aff *pwaff1,
6444 __isl_take isl_pw_aff *pwaff2);
6445 __isl_give isl_aff *isl_aff_sub(
6446 __isl_take isl_aff *aff1,
6447 __isl_take isl_aff *aff2);
6448 __isl_give isl_multi_aff *isl_multi_aff_sub(
6449 __isl_take isl_multi_aff *ma1,
6450 __isl_take isl_multi_aff *ma2);
6451 __isl_give isl_pw_aff *isl_pw_aff_sub(
6452 __isl_take isl_pw_aff *pwaff1,
6453 __isl_take isl_pw_aff *pwaff2);
6454 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_sub(
6455 __isl_take isl_multi_pw_aff *mpa1,
6456 __isl_take isl_multi_pw_aff *mpa2);
6457 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_sub(
6458 __isl_take isl_pw_multi_aff *pma1,
6459 __isl_take isl_pw_multi_aff *pma2);
6460 __isl_give isl_union_pw_aff *isl_union_pw_aff_sub(
6461 __isl_take isl_union_pw_aff *upa1,
6462 __isl_take isl_union_pw_aff *upa2);
6463 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_sub(
6464 __isl_take isl_union_pw_multi_aff *upma1,
6465 __isl_take isl_union_pw_multi_aff *upma2);
6466 __isl_give isl_multi_union_pw_aff *
6467 isl_multi_union_pw_aff_sub(
6468 __isl_take isl_multi_union_pw_aff *mupa1,
6469 __isl_take isl_multi_union_pw_aff *mupa2);
6471 C<isl_aff_sub> subtracts the second argument from the first.
6473 #include <isl/polynomial.h>
6474 __isl_give isl_qpolynomial *isl_qpolynomial_add(
6475 __isl_take isl_qpolynomial *qp1,
6476 __isl_take isl_qpolynomial *qp2);
6477 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add(
6478 __isl_take isl_pw_qpolynomial *pwqp1,
6479 __isl_take isl_pw_qpolynomial *pwqp2);
6480 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add_disjoint(
6481 __isl_take isl_pw_qpolynomial *pwqp1,
6482 __isl_take isl_pw_qpolynomial *pwqp2);
6483 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_add(
6484 __isl_take isl_pw_qpolynomial_fold *pwf1,
6485 __isl_take isl_pw_qpolynomial_fold *pwf2);
6486 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add(
6487 __isl_take isl_union_pw_qpolynomial *upwqp1,
6488 __isl_take isl_union_pw_qpolynomial *upwqp2);
6489 __isl_give isl_qpolynomial *isl_qpolynomial_sub(
6490 __isl_take isl_qpolynomial *qp1,
6491 __isl_take isl_qpolynomial *qp2);
6492 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_sub(
6493 __isl_take isl_pw_qpolynomial *pwqp1,
6494 __isl_take isl_pw_qpolynomial *pwqp2);
6495 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_sub(
6496 __isl_take isl_union_pw_qpolynomial *upwqp1,
6497 __isl_take isl_union_pw_qpolynomial *upwqp2);
6498 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_fold(
6499 __isl_take isl_pw_qpolynomial_fold *pwf1,
6500 __isl_take isl_pw_qpolynomial_fold *pwf2);
6501 __isl_give isl_union_pw_qpolynomial_fold *
6502 isl_union_pw_qpolynomial_fold_fold(
6503 __isl_take isl_union_pw_qpolynomial_fold *upwf1,
6504 __isl_take isl_union_pw_qpolynomial_fold *upwf2);
6506 #include <isl/aff.h>
6507 __isl_give isl_pw_aff *isl_pw_aff_union_add(
6508 __isl_take isl_pw_aff *pwaff1,
6509 __isl_take isl_pw_aff *pwaff2);
6510 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_add(
6511 __isl_take isl_pw_multi_aff *pma1,
6512 __isl_take isl_pw_multi_aff *pma2);
6513 __isl_give isl_union_pw_aff *isl_union_pw_aff_union_add(
6514 __isl_take isl_union_pw_aff *upa1,
6515 __isl_take isl_union_pw_aff *upa2);
6516 __isl_give isl_union_pw_multi_aff *
6517 isl_union_pw_multi_aff_union_add(
6518 __isl_take isl_union_pw_multi_aff *upma1,
6519 __isl_take isl_union_pw_multi_aff *upma2);
6520 __isl_give isl_multi_union_pw_aff *
6521 isl_multi_union_pw_aff_union_add(
6522 __isl_take isl_multi_union_pw_aff *mupa1,
6523 __isl_take isl_multi_union_pw_aff *mupa2);
6524 __isl_give isl_pw_aff *isl_pw_aff_union_min(
6525 __isl_take isl_pw_aff *pwaff1,
6526 __isl_take isl_pw_aff *pwaff2);
6527 __isl_give isl_pw_aff *isl_pw_aff_union_max(
6528 __isl_take isl_pw_aff *pwaff1,
6529 __isl_take isl_pw_aff *pwaff2);
6531 The function C<isl_pw_aff_union_max> computes a piecewise quasi-affine
6532 expression with a domain that is the union of those of C<pwaff1> and
6533 C<pwaff2> and such that on each cell, the quasi-affine expression is
6534 the maximum of those of C<pwaff1> and C<pwaff2>. If only one of
6535 C<pwaff1> or C<pwaff2> is defined on a given cell, then the
6536 associated expression is the defined one.
6537 This in contrast to the C<isl_pw_aff_max> function, which is
6538 only defined on the shared definition domain of the arguments.
6540 #include <isl/val.h>
6541 __isl_give isl_multi_val *isl_multi_val_add_val(
6542 __isl_take isl_multi_val *mv,
6543 __isl_take isl_val *v);
6544 __isl_give isl_multi_val *isl_multi_val_mod_val(
6545 __isl_take isl_multi_val *mv,
6546 __isl_take isl_val *v);
6547 __isl_give isl_multi_val *isl_multi_val_scale_val(
6548 __isl_take isl_multi_val *mv,
6549 __isl_take isl_val *v);
6550 __isl_give isl_multi_val *isl_multi_val_scale_down_val(
6551 __isl_take isl_multi_val *mv,
6552 __isl_take isl_val *v);
6554 #include <isl/aff.h>
6555 __isl_give isl_aff *isl_aff_mod_val(__isl_take isl_aff *aff,
6556 __isl_take isl_val *mod);
6557 __isl_give isl_pw_aff *isl_pw_aff_mod_val(
6558 __isl_take isl_pw_aff *pa,
6559 __isl_take isl_val *mod);
6560 __isl_give isl_union_pw_aff *isl_union_pw_aff_mod_val(
6561 __isl_take isl_union_pw_aff *upa,
6562 __isl_take isl_val *f);
6563 __isl_give isl_aff *isl_aff_scale_val(__isl_take isl_aff *aff,
6564 __isl_take isl_val *v);
6565 __isl_give isl_multi_aff *isl_multi_aff_scale_val(
6566 __isl_take isl_multi_aff *ma,
6567 __isl_take isl_val *v);
6568 __isl_give isl_pw_aff *isl_pw_aff_scale_val(
6569 __isl_take isl_pw_aff *pa, __isl_take isl_val *v);
6570 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_scale_val(
6571 __isl_take isl_multi_pw_aff *mpa,
6572 __isl_take isl_val *v);
6573 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_val(
6574 __isl_take isl_pw_multi_aff *pma,
6575 __isl_take isl_val *v);
6576 __isl_give isl_union_pw_multi_aff *
6577 __isl_give isl_union_pw_aff *isl_union_pw_aff_scale_val(
6578 __isl_take isl_union_pw_aff *upa,
6579 __isl_take isl_val *f);
6580 isl_union_pw_multi_aff_scale_val(
6581 __isl_take isl_union_pw_multi_aff *upma,
6582 __isl_take isl_val *val);
6583 __isl_give isl_multi_union_pw_aff *
6584 isl_multi_union_pw_aff_scale_val(
6585 __isl_take isl_multi_union_pw_aff *mupa,
6586 __isl_take isl_val *v);
6587 __isl_give isl_aff *isl_aff_scale_down_ui(
6588 __isl_take isl_aff *aff, unsigned f);
6589 __isl_give isl_aff *isl_aff_scale_down_val(
6590 __isl_take isl_aff *aff, __isl_take isl_val *v);
6591 __isl_give isl_multi_aff *isl_multi_aff_scale_down_val(
6592 __isl_take isl_multi_aff *ma,
6593 __isl_take isl_val *v);
6594 __isl_give isl_pw_aff *isl_pw_aff_scale_down_val(
6595 __isl_take isl_pw_aff *pa,
6596 __isl_take isl_val *f);
6597 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_scale_down_val(
6598 __isl_take isl_multi_pw_aff *mpa,
6599 __isl_take isl_val *v);
6600 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_down_val(
6601 __isl_take isl_pw_multi_aff *pma,
6602 __isl_take isl_val *v);
6603 __isl_give isl_union_pw_aff *isl_union_pw_aff_scale_down_val(
6604 __isl_take isl_union_pw_aff *upa,
6605 __isl_take isl_val *v);
6606 __isl_give isl_union_pw_multi_aff *
6607 isl_union_pw_multi_aff_scale_down_val(
6608 __isl_take isl_union_pw_multi_aff *upma,
6609 __isl_take isl_val *val);
6610 __isl_give isl_multi_union_pw_aff *
6611 isl_multi_union_pw_aff_scale_down_val(
6612 __isl_take isl_multi_union_pw_aff *mupa,
6613 __isl_take isl_val *v);
6615 #include <isl/polynomial.h>
6616 __isl_give isl_qpolynomial *isl_qpolynomial_scale_val(
6617 __isl_take isl_qpolynomial *qp,
6618 __isl_take isl_val *v);
6619 __isl_give isl_qpolynomial_fold *
6620 isl_qpolynomial_fold_scale_val(
6621 __isl_take isl_qpolynomial_fold *fold,
6622 __isl_take isl_val *v);
6623 __isl_give isl_pw_qpolynomial *
6624 isl_pw_qpolynomial_scale_val(
6625 __isl_take isl_pw_qpolynomial *pwqp,
6626 __isl_take isl_val *v);
6627 __isl_give isl_pw_qpolynomial_fold *
6628 isl_pw_qpolynomial_fold_scale_val(
6629 __isl_take isl_pw_qpolynomial_fold *pwf,
6630 __isl_take isl_val *v);
6631 __isl_give isl_union_pw_qpolynomial *
6632 isl_union_pw_qpolynomial_scale_val(
6633 __isl_take isl_union_pw_qpolynomial *upwqp,
6634 __isl_take isl_val *v);
6635 __isl_give isl_union_pw_qpolynomial_fold *
6636 isl_union_pw_qpolynomial_fold_scale_val(
6637 __isl_take isl_union_pw_qpolynomial_fold *upwf,
6638 __isl_take isl_val *v);
6639 __isl_give isl_qpolynomial *
6640 isl_qpolynomial_scale_down_val(
6641 __isl_take isl_qpolynomial *qp,
6642 __isl_take isl_val *v);
6643 __isl_give isl_qpolynomial_fold *
6644 isl_qpolynomial_fold_scale_down_val(
6645 __isl_take isl_qpolynomial_fold *fold,
6646 __isl_take isl_val *v);
6647 __isl_give isl_pw_qpolynomial *
6648 isl_pw_qpolynomial_scale_down_val(
6649 __isl_take isl_pw_qpolynomial *pwqp,
6650 __isl_take isl_val *v);
6651 __isl_give isl_pw_qpolynomial_fold *
6652 isl_pw_qpolynomial_fold_scale_down_val(
6653 __isl_take isl_pw_qpolynomial_fold *pwf,
6654 __isl_take isl_val *v);
6655 __isl_give isl_union_pw_qpolynomial *
6656 isl_union_pw_qpolynomial_scale_down_val(
6657 __isl_take isl_union_pw_qpolynomial *upwqp,
6658 __isl_take isl_val *v);
6659 __isl_give isl_union_pw_qpolynomial_fold *
6660 isl_union_pw_qpolynomial_fold_scale_down_val(
6661 __isl_take isl_union_pw_qpolynomial_fold *upwf,
6662 __isl_take isl_val *v);
6664 #include <isl/val.h>
6665 __isl_give isl_multi_val *isl_multi_val_mod_multi_val(
6666 __isl_take isl_multi_val *mv1,
6667 __isl_take isl_multi_val *mv2);
6668 __isl_give isl_multi_val *isl_multi_val_scale_multi_val(
6669 __isl_take isl_multi_val *mv1,
6670 __isl_take isl_multi_val *mv2);
6671 __isl_give isl_multi_val *
6672 isl_multi_val_scale_down_multi_val(
6673 __isl_take isl_multi_val *mv1,
6674 __isl_take isl_multi_val *mv2);
6676 #include <isl/aff.h>
6677 __isl_give isl_multi_aff *isl_multi_aff_mod_multi_val(
6678 __isl_take isl_multi_aff *ma,
6679 __isl_take isl_multi_val *mv);
6680 __isl_give isl_multi_union_pw_aff *
6681 isl_multi_union_pw_aff_mod_multi_val(
6682 __isl_take isl_multi_union_pw_aff *upma,
6683 __isl_take isl_multi_val *mv);
6684 __isl_give isl_multi_pw_aff *
6685 isl_multi_pw_aff_mod_multi_val(
6686 __isl_take isl_multi_pw_aff *mpa,
6687 __isl_take isl_multi_val *mv);
6688 __isl_give isl_multi_aff *isl_multi_aff_scale_multi_val(
6689 __isl_take isl_multi_aff *ma,
6690 __isl_take isl_multi_val *mv);
6691 __isl_give isl_pw_multi_aff *
6692 isl_pw_multi_aff_scale_multi_val(
6693 __isl_take isl_pw_multi_aff *pma,
6694 __isl_take isl_multi_val *mv);
6695 __isl_give isl_multi_pw_aff *
6696 isl_multi_pw_aff_scale_multi_val(
6697 __isl_take isl_multi_pw_aff *mpa,
6698 __isl_take isl_multi_val *mv);
6699 __isl_give isl_multi_union_pw_aff *
6700 isl_multi_union_pw_aff_scale_multi_val(
6701 __isl_take isl_multi_union_pw_aff *mupa,
6702 __isl_take isl_multi_val *mv);
6703 __isl_give isl_union_pw_multi_aff *
6704 isl_union_pw_multi_aff_scale_multi_val(
6705 __isl_take isl_union_pw_multi_aff *upma,
6706 __isl_take isl_multi_val *mv);
6707 __isl_give isl_multi_aff *
6708 isl_multi_aff_scale_down_multi_val(
6709 __isl_take isl_multi_aff *ma,
6710 __isl_take isl_multi_val *mv);
6711 __isl_give isl_multi_pw_aff *
6712 isl_multi_pw_aff_scale_down_multi_val(
6713 __isl_take isl_multi_pw_aff *mpa,
6714 __isl_take isl_multi_val *mv);
6715 __isl_give isl_multi_union_pw_aff *
6716 isl_multi_union_pw_aff_scale_down_multi_val(
6717 __isl_take isl_multi_union_pw_aff *mupa,
6718 __isl_take isl_multi_val *mv);
6720 C<isl_multi_aff_scale_multi_val> scales the elements of C<ma>
6721 by the corresponding elements of C<mv>.
6723 #include <isl/aff.h>
6724 __isl_give isl_aff *isl_aff_mul(
6725 __isl_take isl_aff *aff1,
6726 __isl_take isl_aff *aff2);
6727 __isl_give isl_aff *isl_aff_div(
6728 __isl_take isl_aff *aff1,
6729 __isl_take isl_aff *aff2);
6730 __isl_give isl_pw_aff *isl_pw_aff_mul(
6731 __isl_take isl_pw_aff *pwaff1,
6732 __isl_take isl_pw_aff *pwaff2);
6733 __isl_give isl_pw_aff *isl_pw_aff_div(
6734 __isl_take isl_pw_aff *pa1,
6735 __isl_take isl_pw_aff *pa2);
6736 __isl_give isl_pw_aff *isl_pw_aff_tdiv_q(
6737 __isl_take isl_pw_aff *pa1,
6738 __isl_take isl_pw_aff *pa2);
6739 __isl_give isl_pw_aff *isl_pw_aff_tdiv_r(
6740 __isl_take isl_pw_aff *pa1,
6741 __isl_take isl_pw_aff *pa2);
6743 When multiplying two affine expressions, at least one of the two needs
6744 to be a constant. Similarly, when dividing an affine expression by another,
6745 the second expression needs to be a constant.
6746 C<isl_pw_aff_tdiv_q> computes the quotient of an integer division with
6747 rounding towards zero. C<isl_pw_aff_tdiv_r> computes the corresponding
6750 #include <isl/polynomial.h>
6751 __isl_give isl_qpolynomial *isl_qpolynomial_mul(
6752 __isl_take isl_qpolynomial *qp1,
6753 __isl_take isl_qpolynomial *qp2);
6754 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_mul(
6755 __isl_take isl_pw_qpolynomial *pwqp1,
6756 __isl_take isl_pw_qpolynomial *pwqp2);
6757 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_mul(
6758 __isl_take isl_union_pw_qpolynomial *upwqp1,
6759 __isl_take isl_union_pw_qpolynomial *upwqp2);
6763 =head3 Lexicographic Optimization
6765 Given a (basic) set C<set> (or C<bset>) and a zero-dimensional domain C<dom>,
6766 the following functions
6767 compute a set that contains the lexicographic minimum or maximum
6768 of the elements in C<set> (or C<bset>) for those values of the parameters
6769 that satisfy C<dom>.
6770 If C<empty> is not C<NULL>, then C<*empty> is assigned a set
6771 that contains the parameter values in C<dom> for which C<set> (or C<bset>)
6773 In other words, the union of the parameter values
6774 for which the result is non-empty and of C<*empty>
6777 #include <isl/set.h>
6778 __isl_give isl_set *isl_basic_set_partial_lexmin(
6779 __isl_take isl_basic_set *bset,
6780 __isl_take isl_basic_set *dom,
6781 __isl_give isl_set **empty);
6782 __isl_give isl_set *isl_basic_set_partial_lexmax(
6783 __isl_take isl_basic_set *bset,
6784 __isl_take isl_basic_set *dom,
6785 __isl_give isl_set **empty);
6786 __isl_give isl_set *isl_set_partial_lexmin(
6787 __isl_take isl_set *set, __isl_take isl_set *dom,
6788 __isl_give isl_set **empty);
6789 __isl_give isl_set *isl_set_partial_lexmax(
6790 __isl_take isl_set *set, __isl_take isl_set *dom,
6791 __isl_give isl_set **empty);
6793 Given a (basic) set C<set> (or C<bset>), the following functions simply
6794 return a set containing the lexicographic minimum or maximum
6795 of the elements in C<set> (or C<bset>).
6796 In case of union sets, the optimum is computed per space.
6798 #include <isl/set.h>
6799 __isl_give isl_set *isl_basic_set_lexmin(
6800 __isl_take isl_basic_set *bset);
6801 __isl_give isl_set *isl_basic_set_lexmax(
6802 __isl_take isl_basic_set *bset);
6803 __isl_give isl_set *isl_set_lexmin(
6804 __isl_take isl_set *set);
6805 __isl_give isl_set *isl_set_lexmax(
6806 __isl_take isl_set *set);
6807 __isl_give isl_union_set *isl_union_set_lexmin(
6808 __isl_take isl_union_set *uset);
6809 __isl_give isl_union_set *isl_union_set_lexmax(
6810 __isl_take isl_union_set *uset);
6812 Given a (basic) relation C<map> (or C<bmap>) and a domain C<dom>,
6813 the following functions
6814 compute a relation that maps each element of C<dom>
6815 to the single lexicographic minimum or maximum
6816 of the elements that are associated to that same
6817 element in C<map> (or C<bmap>).
6818 If C<empty> is not C<NULL>, then C<*empty> is assigned a set
6819 that contains the elements in C<dom> that do not map
6820 to any elements in C<map> (or C<bmap>).
6821 In other words, the union of the domain of the result and of C<*empty>
6824 #include <isl/map.h>
6825 __isl_give isl_map *isl_basic_map_partial_lexmax(
6826 __isl_take isl_basic_map *bmap,
6827 __isl_take isl_basic_set *dom,
6828 __isl_give isl_set **empty);
6829 __isl_give isl_map *isl_basic_map_partial_lexmin(
6830 __isl_take isl_basic_map *bmap,
6831 __isl_take isl_basic_set *dom,
6832 __isl_give isl_set **empty);
6833 __isl_give isl_map *isl_map_partial_lexmax(
6834 __isl_take isl_map *map, __isl_take isl_set *dom,
6835 __isl_give isl_set **empty);
6836 __isl_give isl_map *isl_map_partial_lexmin(
6837 __isl_take isl_map *map, __isl_take isl_set *dom,
6838 __isl_give isl_set **empty);
6840 Given a (basic) map C<map> (or C<bmap>), the following functions simply
6841 return a map mapping each element in the domain of
6842 C<map> (or C<bmap>) to the lexicographic minimum or maximum
6843 of all elements associated to that element.
6844 In case of union relations, the optimum is computed per space.
6846 #include <isl/map.h>
6847 __isl_give isl_map *isl_basic_map_lexmin(
6848 __isl_take isl_basic_map *bmap);
6849 __isl_give isl_map *isl_basic_map_lexmax(
6850 __isl_take isl_basic_map *bmap);
6851 __isl_give isl_map *isl_map_lexmin(
6852 __isl_take isl_map *map);
6853 __isl_give isl_map *isl_map_lexmax(
6854 __isl_take isl_map *map);
6855 __isl_give isl_union_map *isl_union_map_lexmin(
6856 __isl_take isl_union_map *umap);
6857 __isl_give isl_union_map *isl_union_map_lexmax(
6858 __isl_take isl_union_map *umap);
6860 The following functions return their result in the form of
6861 a piecewise multi-affine expression,
6862 but are otherwise equivalent to the corresponding functions
6863 returning a basic set or relation.
6865 #include <isl/set.h>
6866 __isl_give isl_pw_multi_aff *
6867 isl_basic_set_partial_lexmin_pw_multi_aff(
6868 __isl_take isl_basic_set *bset,
6869 __isl_take isl_basic_set *dom,
6870 __isl_give isl_set **empty);
6871 __isl_give isl_pw_multi_aff *
6872 isl_basic_set_partial_lexmax_pw_multi_aff(
6873 __isl_take isl_basic_set *bset,
6874 __isl_take isl_basic_set *dom,
6875 __isl_give isl_set **empty);
6876 __isl_give isl_pw_multi_aff *isl_set_lexmin_pw_multi_aff(
6877 __isl_take isl_set *set);
6878 __isl_give isl_pw_multi_aff *isl_set_lexmax_pw_multi_aff(
6879 __isl_take isl_set *set);
6881 #include <isl/map.h>
6882 __isl_give isl_pw_multi_aff *
6883 isl_basic_map_lexmin_pw_multi_aff(
6884 __isl_take isl_basic_map *bmap);
6885 __isl_give isl_pw_multi_aff *
6886 isl_basic_map_partial_lexmin_pw_multi_aff(
6887 __isl_take isl_basic_map *bmap,
6888 __isl_take isl_basic_set *dom,
6889 __isl_give isl_set **empty);
6890 __isl_give isl_pw_multi_aff *
6891 isl_basic_map_partial_lexmax_pw_multi_aff(
6892 __isl_take isl_basic_map *bmap,
6893 __isl_take isl_basic_set *dom,
6894 __isl_give isl_set **empty);
6895 __isl_give isl_pw_multi_aff *isl_map_lexmin_pw_multi_aff(
6896 __isl_take isl_map *map);
6897 __isl_give isl_pw_multi_aff *isl_map_lexmax_pw_multi_aff(
6898 __isl_take isl_map *map);
6900 The following functions return the lexicographic minimum or maximum
6901 on the shared domain of the inputs and the single defined function
6902 on those parts of the domain where only a single function is defined.
6904 #include <isl/aff.h>
6905 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmin(
6906 __isl_take isl_pw_multi_aff *pma1,
6907 __isl_take isl_pw_multi_aff *pma2);
6908 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmax(
6909 __isl_take isl_pw_multi_aff *pma1,
6910 __isl_take isl_pw_multi_aff *pma2);
6912 =head2 Ternary Operations
6914 #include <isl/aff.h>
6915 __isl_give isl_pw_aff *isl_pw_aff_cond(
6916 __isl_take isl_pw_aff *cond,
6917 __isl_take isl_pw_aff *pwaff_true,
6918 __isl_take isl_pw_aff *pwaff_false);
6920 The function C<isl_pw_aff_cond> performs a conditional operator
6921 and returns an expression that is equal to C<pwaff_true>
6922 for elements where C<cond> is non-zero and equal to C<pwaff_false> for elements
6923 where C<cond> is zero.
6927 Lists are defined over several element types, including
6928 C<isl_val>, C<isl_id>, C<isl_aff>, C<isl_pw_aff>, C<isl_union_pw_aff>,
6929 C<isl_union_pw_multi_aff>, C<isl_constraint>,
6930 C<isl_basic_set>, C<isl_set>, C<isl_basic_map>, C<isl_map>, C<isl_union_set>,
6931 C<isl_union_map>, C<isl_ast_expr> and C<isl_ast_node>.
6932 Here we take lists of C<isl_set>s as an example.
6933 Lists can be created, copied, modified and freed using the following functions.
6935 #include <isl/set.h>
6936 __isl_give isl_set_list *isl_set_list_from_set(
6937 __isl_take isl_set *el);
6938 __isl_give isl_set_list *isl_set_list_alloc(
6939 isl_ctx *ctx, int n);
6940 __isl_give isl_set_list *isl_set_list_copy(
6941 __isl_keep isl_set_list *list);
6942 __isl_give isl_set_list *isl_set_list_insert(
6943 __isl_take isl_set_list *list, unsigned pos,
6944 __isl_take isl_set *el);
6945 __isl_give isl_set_list *isl_set_list_add(
6946 __isl_take isl_set_list *list,
6947 __isl_take isl_set *el);
6948 __isl_give isl_set_list *isl_set_list_drop(
6949 __isl_take isl_set_list *list,
6950 unsigned first, unsigned n);
6951 __isl_give isl_set_list *isl_set_list_set_set(
6952 __isl_take isl_set_list *list, int index,
6953 __isl_take isl_set *set);
6954 __isl_give isl_set_list *isl_set_list_concat(
6955 __isl_take isl_set_list *list1,
6956 __isl_take isl_set_list *list2);
6957 __isl_give isl_set_list *isl_set_list_sort(
6958 __isl_take isl_set_list *list,
6959 int (*cmp)(__isl_keep isl_set *a,
6960 __isl_keep isl_set *b, void *user),
6962 __isl_null isl_set_list *isl_set_list_free(
6963 __isl_take isl_set_list *list);
6965 C<isl_set_list_alloc> creates an empty list with an initial capacity
6966 for C<n> elements. C<isl_set_list_insert> and C<isl_set_list_add>
6967 add elements to a list, increasing its capacity as needed.
6968 C<isl_set_list_from_set> creates a list with a single element.
6970 Lists can be inspected using the following functions.
6972 #include <isl/set.h>
6973 int isl_set_list_n_set(__isl_keep isl_set_list *list);
6974 __isl_give isl_set *isl_set_list_get_set(
6975 __isl_keep isl_set_list *list, int index);
6976 int isl_set_list_foreach(__isl_keep isl_set_list *list,
6977 int (*fn)(__isl_take isl_set *el, void *user),
6979 int isl_set_list_foreach_scc(__isl_keep isl_set_list *list,
6980 int (*follows)(__isl_keep isl_set *a,
6981 __isl_keep isl_set *b, void *user),
6983 int (*fn)(__isl_take isl_set *el, void *user),
6986 The function C<isl_set_list_foreach_scc> calls C<fn> on each of the
6987 strongly connected components of the graph with as vertices the elements
6988 of C<list> and a directed edge from vertex C<b> to vertex C<a>
6989 iff C<follows(a, b)> returns C<1>. The callbacks C<follows> and C<fn>
6990 should return C<-1> on error.
6992 Lists can be printed using
6994 #include <isl/set.h>
6995 __isl_give isl_printer *isl_printer_print_set_list(
6996 __isl_take isl_printer *p,
6997 __isl_keep isl_set_list *list);
6999 =head2 Associative arrays
7001 Associative arrays map isl objects of a specific type to isl objects
7002 of some (other) specific type. They are defined for several pairs
7003 of types, including (C<isl_map>, C<isl_basic_set>),
7004 (C<isl_id>, C<isl_ast_expr>) and.
7005 (C<isl_id>, C<isl_pw_aff>).
7006 Here, we take associative arrays that map C<isl_id>s to C<isl_ast_expr>s
7009 Associative arrays can be created, copied and freed using
7010 the following functions.
7012 #include <isl/id_to_ast_expr.h>
7013 __isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_alloc(
7014 isl_ctx *ctx, int min_size);
7015 __isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_copy(
7016 __isl_keep isl_id_to_ast_expr *id2expr);
7017 __isl_null isl_id_to_ast_expr *isl_id_to_ast_expr_free(
7018 __isl_take isl_id_to_ast_expr *id2expr);
7020 The C<min_size> argument to C<isl_id_to_ast_expr_alloc> can be used
7021 to specify the expected size of the associative array.
7022 The associative array will be grown automatically as needed.
7024 Associative arrays can be inspected using the following functions.
7026 #include <isl/id_to_ast_expr.h>
7027 int isl_id_to_ast_expr_has(
7028 __isl_keep isl_id_to_ast_expr *id2expr,
7029 __isl_keep isl_id *key);
7030 __isl_give isl_ast_expr *isl_id_to_ast_expr_get(
7031 __isl_keep isl_id_to_ast_expr *id2expr,
7032 __isl_take isl_id *key);
7033 int isl_id_to_ast_expr_foreach(
7034 __isl_keep isl_id_to_ast_expr *id2expr,
7035 int (*fn)(__isl_take isl_id *key,
7036 __isl_take isl_ast_expr *val, void *user),
7039 They can be modified using the following function.
7041 #include <isl/id_to_ast_expr.h>
7042 __isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_set(
7043 __isl_take isl_id_to_ast_expr *id2expr,
7044 __isl_take isl_id *key,
7045 __isl_take isl_ast_expr *val);
7046 __isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_drop(
7047 __isl_take isl_id_to_ast_expr *id2expr,
7048 __isl_take isl_id *key);
7050 Associative arrays can be printed using the following function.
7052 #include <isl/id_to_ast_expr.h>
7053 __isl_give isl_printer *isl_printer_print_id_to_ast_expr(
7054 __isl_take isl_printer *p,
7055 __isl_keep isl_id_to_ast_expr *id2expr);
7059 Vectors can be created, copied and freed using the following functions.
7061 #include <isl/vec.h>
7062 __isl_give isl_vec *isl_vec_alloc(isl_ctx *ctx,
7064 __isl_give isl_vec *isl_vec_copy(__isl_keep isl_vec *vec);
7065 __isl_null isl_vec *isl_vec_free(__isl_take isl_vec *vec);
7067 Note that the elements of a newly created vector may have arbitrary values.
7068 The elements can be changed and inspected using the following functions.
7070 int isl_vec_size(__isl_keep isl_vec *vec);
7071 __isl_give isl_val *isl_vec_get_element_val(
7072 __isl_keep isl_vec *vec, int pos);
7073 __isl_give isl_vec *isl_vec_set_element_si(
7074 __isl_take isl_vec *vec, int pos, int v);
7075 __isl_give isl_vec *isl_vec_set_element_val(
7076 __isl_take isl_vec *vec, int pos,
7077 __isl_take isl_val *v);
7078 __isl_give isl_vec *isl_vec_set_si(__isl_take isl_vec *vec,
7080 __isl_give isl_vec *isl_vec_set_val(
7081 __isl_take isl_vec *vec, __isl_take isl_val *v);
7082 int isl_vec_cmp_element(__isl_keep isl_vec *vec1,
7083 __isl_keep isl_vec *vec2, int pos);
7085 C<isl_vec_get_element> will return a negative value if anything went wrong.
7086 In that case, the value of C<*v> is undefined.
7088 The following function can be used to concatenate two vectors.
7090 __isl_give isl_vec *isl_vec_concat(__isl_take isl_vec *vec1,
7091 __isl_take isl_vec *vec2);
7095 Matrices can be created, copied and freed using the following functions.
7097 #include <isl/mat.h>
7098 __isl_give isl_mat *isl_mat_alloc(isl_ctx *ctx,
7099 unsigned n_row, unsigned n_col);
7100 __isl_give isl_mat *isl_mat_copy(__isl_keep isl_mat *mat);
7101 __isl_null isl_mat *isl_mat_free(__isl_take isl_mat *mat);
7103 Note that the elements of a newly created matrix may have arbitrary values.
7104 The elements can be changed and inspected using the following functions.
7106 int isl_mat_rows(__isl_keep isl_mat *mat);
7107 int isl_mat_cols(__isl_keep isl_mat *mat);
7108 __isl_give isl_val *isl_mat_get_element_val(
7109 __isl_keep isl_mat *mat, int row, int col);
7110 __isl_give isl_mat *isl_mat_set_element_si(__isl_take isl_mat *mat,
7111 int row, int col, int v);
7112 __isl_give isl_mat *isl_mat_set_element_val(
7113 __isl_take isl_mat *mat, int row, int col,
7114 __isl_take isl_val *v);
7116 C<isl_mat_get_element> will return a negative value if anything went wrong.
7117 In that case, the value of C<*v> is undefined.
7119 The following function can be used to compute the (right) inverse
7120 of a matrix, i.e., a matrix such that the product of the original
7121 and the inverse (in that order) is a multiple of the identity matrix.
7122 The input matrix is assumed to be of full row-rank.
7124 __isl_give isl_mat *isl_mat_right_inverse(__isl_take isl_mat *mat);
7126 The following function can be used to compute the (right) kernel
7127 (or null space) of a matrix, i.e., a matrix such that the product of
7128 the original and the kernel (in that order) is the zero matrix.
7130 __isl_give isl_mat *isl_mat_right_kernel(__isl_take isl_mat *mat);
7132 =head2 Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions
7134 The following functions determine
7135 an upper or lower bound on a quasipolynomial over its domain.
7137 __isl_give isl_pw_qpolynomial_fold *
7138 isl_pw_qpolynomial_bound(
7139 __isl_take isl_pw_qpolynomial *pwqp,
7140 enum isl_fold type, int *tight);
7142 __isl_give isl_union_pw_qpolynomial_fold *
7143 isl_union_pw_qpolynomial_bound(
7144 __isl_take isl_union_pw_qpolynomial *upwqp,
7145 enum isl_fold type, int *tight);
7147 The C<type> argument may be either C<isl_fold_min> or C<isl_fold_max>.
7148 If C<tight> is not C<NULL>, then C<*tight> is set to C<1>
7149 is the returned bound is known be tight, i.e., for each value
7150 of the parameters there is at least
7151 one element in the domain that reaches the bound.
7152 If the domain of C<pwqp> is not wrapping, then the bound is computed
7153 over all elements in that domain and the result has a purely parametric
7154 domain. If the domain of C<pwqp> is wrapping, then the bound is
7155 computed over the range of the wrapped relation. The domain of the
7156 wrapped relation becomes the domain of the result.
7158 =head2 Parametric Vertex Enumeration
7160 The parametric vertex enumeration described in this section
7161 is mainly intended to be used internally and by the C<barvinok>
7164 #include <isl/vertices.h>
7165 __isl_give isl_vertices *isl_basic_set_compute_vertices(
7166 __isl_keep isl_basic_set *bset);
7168 The function C<isl_basic_set_compute_vertices> performs the
7169 actual computation of the parametric vertices and the chamber
7170 decomposition and store the result in an C<isl_vertices> object.
7171 This information can be queried by either iterating over all
7172 the vertices or iterating over all the chambers or cells
7173 and then iterating over all vertices that are active on the chamber.
7175 int isl_vertices_foreach_vertex(
7176 __isl_keep isl_vertices *vertices,
7177 int (*fn)(__isl_take isl_vertex *vertex, void *user),
7180 int isl_vertices_foreach_cell(
7181 __isl_keep isl_vertices *vertices,
7182 int (*fn)(__isl_take isl_cell *cell, void *user),
7184 int isl_cell_foreach_vertex(__isl_keep isl_cell *cell,
7185 int (*fn)(__isl_take isl_vertex *vertex, void *user),
7188 Other operations that can be performed on an C<isl_vertices> object are
7191 int isl_vertices_get_n_vertices(
7192 __isl_keep isl_vertices *vertices);
7193 void isl_vertices_free(__isl_take isl_vertices *vertices);
7195 Vertices can be inspected and destroyed using the following functions.
7197 int isl_vertex_get_id(__isl_keep isl_vertex *vertex);
7198 __isl_give isl_basic_set *isl_vertex_get_domain(
7199 __isl_keep isl_vertex *vertex);
7200 __isl_give isl_multi_aff *isl_vertex_get_expr(
7201 __isl_keep isl_vertex *vertex);
7202 void isl_vertex_free(__isl_take isl_vertex *vertex);
7204 C<isl_vertex_get_expr> returns a multiple quasi-affine expression
7205 describing the vertex in terms of the parameters,
7206 while C<isl_vertex_get_domain> returns the activity domain
7209 Chambers can be inspected and destroyed using the following functions.
7211 __isl_give isl_basic_set *isl_cell_get_domain(
7212 __isl_keep isl_cell *cell);
7213 void isl_cell_free(__isl_take isl_cell *cell);
7215 =head1 Polyhedral Compilation Library
7217 This section collects functionality in C<isl> that has been specifically
7218 designed for use during polyhedral compilation.
7220 =head2 Schedule Trees
7222 A schedule tree is a structured representation of a schedule,
7223 assigning a relative order to a set of domain elements.
7224 The relative order expressed by the schedule tree is
7225 defined recursively. In particular, the order between
7226 two domain elements is determined by the node that is closest
7227 to the root that refers to both elements and that orders them apart.
7228 Each node in the tree is of one of several types.
7229 The root node is always of type C<isl_schedule_node_domain>
7230 and it describes the domain elements to which the schedule applies.
7231 The other types of nodes are as follows.
7235 =item C<isl_schedule_node_band>
7237 A band of schedule dimensions. Each schedule dimension is represented
7238 by a union piecewise quasi-affine expression. If this expression
7239 assigns a different value to two domain elements, while all previous
7240 schedule dimensions in the same band assign them the same value,
7241 then the two domain elements are ordered according to these two
7244 =item C<isl_schedule_node_filter>
7246 A filter node does not impose any ordering, but rather intersects
7247 the set of domain elements that the current subtree refers to
7248 with a given union set. The subtree of the filter node only
7249 refers to domain elements in the intersection.
7250 A filter node is typically only used a child of a sequence or
7253 =item C<isl_schedule_node_leaf>
7255 A leaf of the schedule tree. Leaf nodes do not impose any ordering.
7257 =item C<isl_schedule_node_sequence>
7259 A sequence node has one or more children, each of which is a filter node.
7260 The filters on these filter nodes form a partition of
7261 the domain elements that the current subtree refers to.
7262 If two domain elements appear in distinct filters then the sequence
7263 node orders them according to the child positions of the corresponding
7266 =item C<isl_schedule_node_set>
7268 A set node is similar to a sequence node, except that
7269 it expresses that domain elements appearing in distinct filters
7270 may have any order. The order of the children of a set node
7271 is therefore also immaterial.
7275 A schedule tree is encapsulated in an C<isl_schedule> object.
7276 The simplest such objects, those with a tree consisting of single domain node,
7277 can be created using the following functions with either an empty
7278 domain or a given domain.
7280 #include <isl/schedule.h>
7281 __isl_give isl_schedule *isl_schedule_empty(
7282 __isl_take isl_space *space);
7283 __isl_give isl_schedule *isl_schedule_from_domain(
7284 __isl_take isl_union_set *domain);
7286 The function C<isl_schedule_constraints_compute_schedule> described
7287 in L</"Scheduling"> can also be used to construct schedules.
7289 C<isl_schedule> objects may be copied and freed using the following functions.
7291 #include <isl/schedule.h>
7292 __isl_give isl_schedule *isl_schedule_copy(
7293 __isl_keep isl_schedule *sched);
7294 __isl_null isl_schedule *isl_schedule_free(
7295 __isl_take isl_schedule *sched);
7297 The following functions checks whether two C<isl_schedule> objects
7298 are obviously the same.
7300 #include <isl/schedule.h>
7301 int isl_schedule_plain_is_equal(
7302 __isl_keep isl_schedule *schedule1,
7303 __isl_keep isl_schedule *schedule2);
7305 The domain of the schedule, i.e., the domain described by the root node,
7306 can be obtained using the following function.
7308 #include <isl/schedule.h>
7309 __isl_give isl_union_set *isl_schedule_get_domain(
7310 __isl_keep isl_schedule *schedule);
7312 An extra top-level band node (right underneath the domain node) can
7313 be introduced into the schedule using the following function.
7315 #include <isl/schedule.h>
7316 __isl_give isl_schedule *
7317 isl_schedule_insert_partial_schedule(
7318 __isl_take isl_schedule *schedule,
7319 __isl_take isl_multi_union_pw_aff *partial);
7321 A schedule that combines two schedules either in the given
7322 order or in an arbitrary order, i.e., with an C<isl_schedule_node_sequence>
7323 or an C<isl_schedule_node_set> node,
7324 can be created using the following functions.
7326 #include <isl/schedule.h>
7327 __isl_give isl_schedule *isl_schedule_sequence(
7328 __isl_take isl_schedule *schedule1,
7329 __isl_take isl_schedule *schedule2);
7330 __isl_give isl_schedule *isl_schedule_set(
7331 __isl_take isl_schedule *schedule1,
7332 __isl_take isl_schedule *schedule2);
7334 The domains of the two input schedules need to be disjoint.
7336 The following function can be used to restrict the domain
7337 of a schedule to be a subset of the given union set.
7338 This operation may remove nodes in the tree that have become
7341 #include <isl/schedule.h>
7342 __isl_give isl_schedule *isl_schedule_intersect_domain(
7343 __isl_take isl_schedule *schedule,
7344 __isl_take isl_union_set *domain);
7346 The following function resets the user pointers on all parameter
7347 and tuple identifiers referenced by the nodes of the given schedule.
7349 #include <isl/schedule.h>
7350 __isl_give isl_schedule *isl_schedule_reset_user(
7351 __isl_take isl_schedule *schedule);
7353 The following function aligns the parameters of all nodes
7354 in the given schedule to the given space.
7356 #include <isl/schedule.h>
7357 __isl_give isl_schedule *isl_schedule_align_params(
7358 __isl_take isl_schedule *schedule,
7359 __isl_take isl_space *space);
7361 The following function allows the user to plug in a given function
7362 in the iteration domains.
7364 #include <isl/schedule.h>
7365 __isl_give isl_schedule *
7366 isl_schedule_pullback_union_pw_multi_aff(
7367 __isl_take isl_schedule *schedule,
7368 __isl_take isl_union_pw_multi_aff *upma);
7370 An C<isl_union_map> representation of the schedule can be obtained
7371 from an C<isl_schedule> using the following function.
7373 #include <isl/schedule.h>
7374 __isl_give isl_union_map *isl_schedule_get_map(
7375 __isl_keep isl_schedule *sched);
7377 The resulting relation encodes the same relative ordering as
7378 the schedule by mapping the domain elements to a common schedule space.
7379 If the schedule_separate_components option is set, then the order
7380 of the children of a set node is explicitly encoded in the result.
7382 Schedules can be read from input using the following functions.
7384 #include <isl/schedule.h>
7385 __isl_give isl_schedule *isl_schedule_read_from_file(
7386 isl_ctx *ctx, FILE *input);
7387 __isl_give isl_schedule *isl_schedule_read_from_str(
7388 isl_ctx *ctx, const char *str);
7390 A representation of the schedule can be printed using
7392 #include <isl/schedule.h>
7393 __isl_give isl_printer *isl_printer_print_schedule(
7394 __isl_take isl_printer *p,
7395 __isl_keep isl_schedule *schedule);
7397 The schedule tree can be traversed through the use of
7398 C<isl_schedule_node> objects that point to a particular
7399 position in the schedule tree. Whenever a C<isl_schedule_node>
7400 is use to modify a node in the schedule tree, the original schedule
7401 tree is left untouched and the modifications are performed to a copy
7402 of the tree. The returned C<isl_schedule_node> then points to
7403 this modified copy of the tree.
7405 The root of the schedule tree can be obtained using the following function.
7407 #include <isl/schedule.h>
7408 __isl_give isl_schedule_node *isl_schedule_get_root(
7409 __isl_keep isl_schedule *schedule);
7411 A pointer to a newly created schedule tree with a single domain
7412 node can be created using the following function.
7414 #include <isl/schedule_node.h>
7415 __isl_give isl_schedule_node *
7416 isl_schedule_node_from_domain(
7417 __isl_take isl_union_set *domain);
7419 Schedule nodes can be copied and freed using the following functions.
7421 #include <isl/schedule_node.h>
7422 __isl_give isl_schedule_node *isl_schedule_node_copy(
7423 __isl_keep isl_schedule_node *node);
7424 __isl_null isl_schedule_node *isl_schedule_node_free(
7425 __isl_take isl_schedule_node *node);
7427 The following functions can be used to check if two schedule
7428 nodes point to the same position in the same schedule.
7430 #include <isl/schedule_node.h>
7431 int isl_schedule_node_is_equal(
7432 __isl_keep isl_schedule_node *node1,
7433 __isl_keep isl_schedule_node *node2);
7435 The following properties can be obtained from a schedule node.
7437 #include <isl/schedule_node.h>
7438 enum isl_schedule_node_type isl_schedule_node_get_type(
7439 __isl_keep isl_schedule_node *node);
7440 enum isl_schedule_node_type
7441 isl_schedule_node_get_parent_type(
7442 __isl_keep isl_schedule_node *node);
7443 __isl_give isl_schedule *isl_schedule_node_get_schedule(
7444 __isl_keep isl_schedule_node *node);
7446 The function C<isl_schedule_node_get_type> returns the type of
7447 the node, while C<isl_schedule_node_get_parent_type> returns
7448 type of the parent of the node, which is required to exist.
7449 The function C<isl_schedule_node_get_schedule> returns a copy
7450 to the schedule to which the node belongs.
7452 The following functions can be used to move the schedule node
7453 to a different position in the tree or to check if such a position
7456 #include <isl/schedule_node.h>
7457 int isl_schedule_node_has_parent(
7458 __isl_keep isl_schedule_node *node);
7459 __isl_give isl_schedule_node *isl_schedule_node_parent(
7460 __isl_take isl_schedule_node *node);
7461 __isl_give isl_schedule_node *isl_schedule_node_root(
7462 __isl_take isl_schedule_node *node);
7463 __isl_give isl_schedule_node *isl_schedule_node_ancestor(
7464 __isl_take isl_schedule_node *node,
7466 int isl_schedule_node_n_children(
7467 __isl_keep isl_schedule_node *node);
7468 __isl_give isl_schedule_node *isl_schedule_node_child(
7469 __isl_take isl_schedule_node *node, int pos);
7470 int isl_schedule_node_has_children(
7471 __isl_keep isl_schedule_node *node);
7472 __isl_give isl_schedule_node *isl_schedule_node_first_child(
7473 __isl_take isl_schedule_node *node);
7474 int isl_schedule_node_has_previous_sibling(
7475 __isl_keep isl_schedule_node *node);
7476 __isl_give isl_schedule_node *
7477 isl_schedule_node_previous_sibling(
7478 __isl_take isl_schedule_node *node);
7479 int isl_schedule_node_has_next_sibling(
7480 __isl_keep isl_schedule_node *node);
7481 __isl_give isl_schedule_node *
7482 isl_schedule_node_next_sibling(
7483 __isl_take isl_schedule_node *node);
7485 For C<isl_schedule_node_ancestor>, the ancestor of generation 0
7486 is the node itself, the ancestor of generation 1 is its parent and so on.
7488 It is also possible to query the number of ancestors of a node,
7489 the position of the current node
7490 within the children of its parent, the position of the subtree
7491 containing a node within the children of an ancestor
7492 or to obtain a copy of a given
7493 child without destroying the current node.
7494 Given two nodes that point to the same schedule, their closest
7495 shared ancestor can be obtained using
7496 C<isl_schedule_node_get_shared_ancestor>.
7498 #include <isl/schedule_node.h>
7499 int isl_schedule_node_get_tree_depth(
7500 __isl_keep isl_schedule_node *node);
7501 int isl_schedule_node_get_child_position(
7502 __isl_keep isl_schedule_node *node);
7503 int isl_schedule_node_get_ancestor_child_position(
7504 __isl_keep isl_schedule_node *node,
7505 __isl_keep isl_schedule_node *ancestor);
7506 __isl_give isl_schedule_node *isl_schedule_node_get_child(
7507 __isl_keep isl_schedule_node *node, int pos);
7508 __isl_give isl_schedule_node *
7509 isl_schedule_node_get_shared_ancestor(
7510 __isl_keep isl_schedule_node *node1,
7511 __isl_keep isl_schedule_node *node2);
7513 All nodes in a schedule tree or
7514 all descendants of a specific node (including the node) can be visited
7515 in depth-first pre-order using the following functions.
7517 #include <isl/schedule.h>
7518 int isl_schedule_foreach_schedule_node(
7519 __isl_keep isl_schedule *sched,
7520 int (*fn)(__isl_keep isl_schedule_node *node,
7521 void *user), void *user);
7523 #include <isl/schedule_node.h>
7524 int isl_schedule_node_foreach_descendant(
7525 __isl_keep isl_schedule_node *node,
7526 int (*fn)(__isl_keep isl_schedule_node *node,
7527 void *user), void *user);
7529 The callback function is slightly different from the usual
7530 callbacks in that it not only indicates success (non-negative result)
7531 or failure (negative result), but also indicates whether the children
7532 of the given node should be visited. In particular, if the callback
7533 returns a positive value, then the children are visited, but if
7534 the callback returns zero, then the children are not visited.
7536 The ancestors of a node in a schedule tree can be visited from
7537 the root down to and including the parent of the node using
7538 the following function.
7540 #include <isl/schedule_node.h>
7541 int isl_schedule_node_foreach_ancestor_top_down(
7542 __isl_keep isl_schedule_node *node,
7543 int (*fn)(__isl_keep isl_schedule_node *node,
7544 void *user), void *user);
7546 The following functions allows for a depth-first post-order
7547 traversal of the nodes in a schedule tree or
7548 of the descendants of a specific node (including the node
7549 itself), where the user callback is allowed to modify the
7552 #include <isl/schedule.h>
7553 __isl_give isl_schedule *isl_schedule_map_schedule_node(
7554 __isl_take isl_schedule *schedule,
7555 __isl_give isl_schedule_node *(*fn)(
7556 __isl_take isl_schedule_node *node,
7557 void *user), void *user);
7559 #include <isl/schedule_node.h>
7560 __isl_give isl_schedule_node *
7561 isl_schedule_node_map_descendant(
7562 __isl_take isl_schedule_node *node,
7563 __isl_give isl_schedule_node *(*fn)(
7564 __isl_take isl_schedule_node *node,
7565 void *user), void *user);
7567 The traversal continues from the node returned by the callback function.
7568 It is the responsibility of the user to ensure that this does not
7569 lead to an infinite loop. It is safest to always return a pointer
7570 to the same position (same ancestors and child positions) as the input node.
7572 The following function removes a node (along with its descendants)
7573 from a schedule tree and returns a pointer to the leaf at the
7574 same position in the updated tree.
7575 It is not allowed to remove the root of a schedule tree or
7576 a child of a set or sequence node.
7578 #include <isl/schedule_node.h>
7579 __isl_give isl_schedule_node *isl_schedule_node_cut(
7580 __isl_take isl_schedule_node *node);
7582 The following function removes a single node
7583 from a schedule tree and returns a pointer to the child
7584 of the node, now located at the position of the original node
7585 or to a leaf node at that position if there was no child.
7586 It is not allowed to remove the root of a schedule tree,
7587 a set or sequence node or a child of a set or sequence node.
7589 #include <isl/schedule_node.h>
7590 __isl_give isl_schedule_node *isl_schedule_node_delete(
7591 __isl_take isl_schedule_node *node);
7593 The following function resets the user pointers on all parameter
7594 and tuple identifiers referenced by the given schedule node.
7596 #include <isl/schedule_node.h>
7597 __isl_give isl_schedule_node *isl_schedule_node_reset_user(
7598 __isl_take isl_schedule_node *node);
7600 The following function aligns the parameters of the given schedule
7601 node to the given space.
7603 #include <isl/schedule_node.h>
7604 __isl_give isl_schedule_node *
7605 isl_schedule_node_align_params(
7606 __isl_take isl_schedule_node *node,
7607 __isl_take isl_space *space);
7609 Several node types have their own functions for querying
7610 (and in some cases setting) some node type specific properties.
7612 #include <isl/schedule_node.h>
7613 __isl_give isl_space *isl_schedule_node_band_get_space(
7614 __isl_keep isl_schedule_node *node);
7615 __isl_give isl_multi_union_pw_aff *
7616 isl_schedule_node_band_get_partial_schedule(
7617 __isl_keep isl_schedule_node *node);
7618 __isl_give isl_union_map *
7619 isl_schedule_node_band_get_partial_schedule_union_map(
7620 __isl_keep isl_schedule_node *node);
7621 unsigned isl_schedule_node_band_n_member(
7622 __isl_keep isl_schedule_node *node);
7623 int isl_schedule_node_band_member_get_coincident(
7624 __isl_keep isl_schedule_node *node, int pos);
7625 __isl_give isl_schedule_node *
7626 isl_schedule_node_band_member_set_coincident(
7627 __isl_take isl_schedule_node *node, int pos,
7629 int isl_schedule_node_band_get_permutable(
7630 __isl_keep isl_schedule_node *node);
7631 __isl_give isl_schedule_node *
7632 isl_schedule_node_band_set_permutable(
7633 __isl_take isl_schedule_node *node, int permutable);
7635 The function C<isl_schedule_node_band_get_space> returns the space
7636 of the partial schedule of the band.
7637 The function C<isl_schedule_node_band_get_partial_schedule_union_map>
7638 returns a representation of the partial schedule of the band node
7639 in the form of an C<isl_union_map>.
7640 The coincident and permutable properties are set by
7641 C<isl_schedule_constraints_compute_schedule> on the schedule tree
7643 A scheduling dimension is considered to be ``coincident''
7644 if it satisfies the coincidence constraints within its band.
7645 That is, if the dependence distances of the coincidence
7646 constraints are all zero in that direction (for fixed
7647 iterations of outer bands).
7648 A band is marked permutable if it was produced using the Pluto-like scheduler.
7649 Note that the scheduler may have to resort to a Feautrier style scheduling
7650 step even if the default scheduler is used.
7652 #include <isl/schedule_node.h>
7653 __isl_give isl_union_set *
7654 isl_schedule_node_domain_get_domain(
7655 __isl_keep isl_schedule_node *node);
7657 #include <isl/schedule_node.h>
7658 __isl_give isl_union_set *
7659 isl_schedule_node_filter_get_filter(
7660 __isl_keep isl_schedule_node *node);
7662 The following functions can be used to obtain an C<isl_union_pw_multi_aff>
7663 or C<isl_union_map> representation of partial schedules related to the node.
7665 #include <isl/schedule_node.h>
7666 __isl_give isl_union_pw_multi_aff *
7667 isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(
7668 __isl_keep isl_schedule_node *node);
7669 __isl_give isl_union_map *
7670 isl_schedule_node_get_prefix_schedule_union_map(
7671 __isl_keep isl_schedule_node *node);
7672 __isl_give isl_union_map *
7673 isl_schedule_node_get_subtree_schedule_union_map(
7674 __isl_keep isl_schedule_node *node);
7676 In particular, the functions
7677 C<isl_schedule_node_get_prefix_schedule_union_pw_multi_aff>
7678 and C<isl_schedule_node_get_prefix_schedule_union_map>
7679 return a relative ordering on the domain elements that reach the given
7680 node determined by its ancestors.
7681 The function C<isl_schedule_node_get_subtree_schedule_union_map>
7682 returns a representation of the partial schedule defined by the
7683 subtree rooted at the given node.
7685 The total number of outer band members of given node, i.e.,
7686 the shared output dimension of the maps in the result
7687 of C<isl_schedule_node_get_prefix_schedule_union_map> can be obtained
7688 using the following function.
7690 #include <isl/schedule_node.h>
7691 int isl_schedule_node_get_schedule_depth(
7692 __isl_keep isl_schedule_node *node);
7694 The following function returns the union of universes in the spaces that
7695 contain elements that reach the given node.
7697 #include <isl/schedule_node.h>
7698 __isl_give isl_union_set *
7699 isl_schedule_node_get_universe_domain(
7700 __isl_keep isl_schedule_node *node);
7702 The following functions can be used to introduce additional nodes
7703 in the schedule tree. The new node is introduced at the point
7704 in the tree where the C<isl_schedule_node> points to and
7705 the results points to the new node.
7707 #include <isl/schedule_node.h>
7708 __isl_give isl_schedule_node *
7709 isl_schedule_node_insert_partial_schedule(
7710 __isl_take isl_schedule_node *node,
7711 __isl_take isl_multi_union_pw_aff *schedule);
7713 This function inserts a new band node with (the greatest integer
7714 part of) the given partial schedule.
7716 #include <isl/schedule_node.h>
7717 __isl_give isl_schedule_node *
7718 isl_schedule_node_insert_filter(
7719 __isl_take isl_schedule_node *node,
7720 __isl_take isl_union_set *filter);
7722 This function inserts a new filter node with the given filter.
7723 If the original node already pointed to a filter node, then the
7724 two filter nodes are merged into one.
7726 #include <isl/schedule_node.h>
7727 __isl_give isl_schedule_node *
7728 isl_schedule_node_insert_sequence(
7729 __isl_take isl_schedule_node *node,
7730 __isl_take isl_union_set_list *filters);
7731 __isl_give isl_schedule_node *
7732 isl_schedule_node_insert_set(
7733 __isl_take isl_schedule_node *node,
7734 __isl_take isl_union_set_list *filters);
7736 These functions insert a new sequence or set node with the given
7737 filters as children.
7739 The partial schedule of a band node can be scaled (down) using
7740 the following functions.
7742 #include <isl/schedule_node.h>
7743 __isl_give isl_schedule_node *
7744 isl_schedule_node_band_scale(
7745 __isl_take isl_schedule_node *node,
7746 __isl_take isl_multi_val *mv);
7747 __isl_give isl_schedule_node *
7748 isl_schedule_node_band_scale_down(
7749 __isl_take isl_schedule_node *node,
7750 __isl_take isl_multi_val *mv);
7752 The spaces of the two arguments need to match.
7753 After scaling, the partial schedule is replaced by its greatest
7754 integer part to ensure that the schedule remains integral.
7756 A band node can be tiled using the following function.
7758 #include <isl/schedule_node.h>
7759 __isl_give isl_schedule_node *isl_schedule_node_band_tile(
7760 __isl_take isl_schedule_node *node,
7761 __isl_take isl_multi_val *sizes);
7763 int isl_options_set_tile_scale_tile_loops(isl_ctx *ctx,
7765 int isl_options_get_tile_scale_tile_loops(isl_ctx *ctx);
7766 int isl_options_set_tile_shift_point_loops(isl_ctx *ctx,
7768 int isl_options_get_tile_shift_point_loops(isl_ctx *ctx);
7770 The C<isl_schedule_node_band_tile> function tiles
7771 the band using the given tile sizes inside its schedule.
7772 A new child band node is created to represent the point loops and it is
7773 inserted between the modified band and its children.
7774 The C<tile_scale_tile_loops> option specifies whether the tile
7775 loops iterators should be scaled by the tile sizes.
7776 If the C<tile_shift_point_loops> option is set, then the point loops
7777 are shifted to start at zero.
7779 A band node can be split into two nested band nodes
7780 using the following function.
7782 #include <isl/schedule_node.h>
7783 __isl_give isl_schedule_node *isl_schedule_node_band_split(
7784 __isl_take isl_schedule_node *node, int pos);
7786 The resulting outer band node contains the first C<pos> dimensions of
7787 the schedule of C<node> while the inner band contains the remaining dimensions.
7788 The schedules of the two band nodes live in anonymous spaces.
7790 A band node can be moved down to the leaves of the subtree rooted
7791 at the band node using the following function.
7793 #include <isl/schedule_node.h>
7794 __isl_give isl_schedule_node *isl_schedule_node_band_sink(
7795 __isl_take isl_schedule_node *node);
7797 The result points to the node in the resulting tree that is in the same
7798 position as the node pointed to by C<node> in the original tree.
7800 A representation of the schedule node can be printed using
7802 #include <isl/schedule_node.h>
7803 __isl_give isl_printer *isl_printer_print_schedule_node(
7804 __isl_take isl_printer *p,
7805 __isl_keep isl_schedule_node *node);
7807 =head2 Dependence Analysis
7809 C<isl> contains specialized functionality for performing
7810 array dataflow analysis. That is, given a I<sink> access relation
7811 and a collection of possible I<source> access relations,
7812 C<isl> can compute relations that describe
7813 for each iteration of the sink access, which iteration
7814 of which of the source access relations was the last
7815 to access the same data element before the given iteration
7817 The resulting dependence relations map source iterations
7818 to the corresponding sink iterations.
7819 To compute standard flow dependences, the sink should be
7820 a read, while the sources should be writes.
7821 If any of the source accesses are marked as being I<may>
7822 accesses, then there will be a dependence from the last
7823 I<must> access B<and> from any I<may> access that follows
7824 this last I<must> access.
7825 In particular, if I<all> sources are I<may> accesses,
7826 then memory based dependence analysis is performed.
7827 If, on the other hand, all sources are I<must> accesses,
7828 then value based dependence analysis is performed.
7830 =head3 High-level Interface
7832 A high-level interface to dependence analysis is provided
7833 by the following function.
7835 #include <isl/flow.h>
7836 __isl_give isl_union_flow *
7837 isl_union_access_info_compute_flow(
7838 __isl_take isl_union_access_info *access);
7840 The input C<isl_union_access_info> object describes the sink
7841 access relations, the source access relations and a schedule,
7842 while the output C<isl_union_flow> object describes
7843 the resulting dependence relations and the subsets of the
7844 sink relations for which no source was found.
7846 An C<isl_union_access_info> is created, modified and freed using
7847 the following functions.
7849 #include <isl/flow.h>
7850 __isl_give isl_union_access_info *
7851 isl_union_access_info_from_sink(
7852 __isl_take isl_union_map *sink);
7853 __isl_give isl_union_access_info *
7854 isl_union_access_info_set_must_source(
7855 __isl_take isl_union_access_info *access,
7856 __isl_take isl_union_map *must_source);
7857 __isl_give isl_union_access_info *
7858 isl_union_access_info_set_may_source(
7859 __isl_take isl_union_access_info *access,
7860 __isl_take isl_union_map *may_source);
7861 __isl_give isl_union_access_info *
7862 isl_union_access_info_set_schedule(
7863 __isl_take isl_union_access_info *access,
7864 __isl_take isl_schedule *schedule);
7865 __isl_give isl_union_access_info *
7866 isl_union_access_info_set_schedule_map(
7867 __isl_take isl_union_access_info *access,
7868 __isl_take isl_union_map *schedule_map);
7869 __isl_null isl_union_access_info *
7870 isl_union_access_info_free(
7871 __isl_take isl_union_access_info *access);
7873 The may sources set by C<isl_union_access_info_set_may_source>
7874 do not need to include the must sources set by
7875 C<isl_union_access_info_set_must_source> as a subset.
7876 The user is free not to call one (or both) of these functions,
7877 in which case the corresponding set is kept to its empty default.
7878 Similarly, the default schedule initialized by
7879 C<isl_union_access_info_from_sink> is empty.
7880 The current schedule is determined by the last call to either
7881 C<isl_union_access_info_set_schedule> or
7882 C<isl_union_access_info_set_schedule_map>.
7883 The domain of the schedule corresponds to the domains of
7884 the access relations. In particular, the domains of the access
7885 relations are effectively intersected with the domain of the schedule
7886 and only the resulting accesses are considered by the dependence analysis.
7888 The output of C<isl_union_access_info_compute_flow> can be examined
7889 and freed using the following functions.
7891 #include <isl/flow.h>
7892 __isl_give isl_union_map *isl_union_flow_get_must_dependence(
7893 __isl_keep isl_union_flow *flow);
7894 __isl_give isl_union_map *isl_union_flow_get_may_dependence(
7895 __isl_keep isl_union_flow *flow);
7896 __isl_give isl_union_map *isl_union_flow_get_must_no_source(
7897 __isl_keep isl_union_flow *flow);
7898 __isl_give isl_union_map *isl_union_flow_get_may_no_source(
7899 __isl_keep isl_union_flow *flow);
7900 __isl_null isl_union_flow *isl_union_flow_free(
7901 __isl_take isl_union_flow *flow);
7903 The relation returned by C<isl_union_flow_get_must_dependence>
7904 relates domain elements of must sources to domain elements of the sink.
7905 The relation returned by C<isl_union_flow_get_may_dependence>
7906 relates domain elements of must or may sources to domain elements of the sink
7907 and includes the previous relation as a subset.
7908 The relation returned by C<isl_union_flow_get_must_no_source> is the subset
7909 of the sink relation for which no dependences have been found.
7910 The relation returned by C<isl_union_flow_get_may_no_source> is the subset
7911 of the sink relation for which no definite dependences have been found.
7912 That is, it contains those sink access that do not contribute to any
7913 of the elements in the relation returned
7914 by C<isl_union_flow_get_must_dependence>.
7916 =head3 Low-level Interface
7918 A lower-level interface is provided by the following functions.
7920 #include <isl/flow.h>
7922 typedef int (*isl_access_level_before)(void *first, void *second);
7924 __isl_give isl_access_info *isl_access_info_alloc(
7925 __isl_take isl_map *sink,
7926 void *sink_user, isl_access_level_before fn,
7928 __isl_give isl_access_info *isl_access_info_add_source(
7929 __isl_take isl_access_info *acc,
7930 __isl_take isl_map *source, int must,
7932 __isl_null isl_access_info *isl_access_info_free(
7933 __isl_take isl_access_info *acc);
7935 __isl_give isl_flow *isl_access_info_compute_flow(
7936 __isl_take isl_access_info *acc);
7938 int isl_flow_foreach(__isl_keep isl_flow *deps,
7939 int (*fn)(__isl_take isl_map *dep, int must,
7940 void *dep_user, void *user),
7942 __isl_give isl_map *isl_flow_get_no_source(
7943 __isl_keep isl_flow *deps, int must);
7944 void isl_flow_free(__isl_take isl_flow *deps);
7946 The function C<isl_access_info_compute_flow> performs the actual
7947 dependence analysis. The other functions are used to construct
7948 the input for this function or to read off the output.
7950 The input is collected in an C<isl_access_info>, which can
7951 be created through a call to C<isl_access_info_alloc>.
7952 The arguments to this functions are the sink access relation
7953 C<sink>, a token C<sink_user> used to identify the sink
7954 access to the user, a callback function for specifying the
7955 relative order of source and sink accesses, and the number
7956 of source access relations that will be added.
7957 The callback function has type C<int (*)(void *first, void *second)>.
7958 The function is called with two user supplied tokens identifying
7959 either a source or the sink and it should return the shared nesting
7960 level and the relative order of the two accesses.
7961 In particular, let I<n> be the number of loops shared by
7962 the two accesses. If C<first> precedes C<second> textually,
7963 then the function should return I<2 * n + 1>; otherwise,
7964 it should return I<2 * n>.
7965 The sources can be added to the C<isl_access_info> by performing
7966 (at most) C<max_source> calls to C<isl_access_info_add_source>.
7967 C<must> indicates whether the source is a I<must> access
7968 or a I<may> access. Note that a multi-valued access relation
7969 should only be marked I<must> if every iteration in the domain
7970 of the relation accesses I<all> elements in its image.
7971 The C<source_user> token is again used to identify
7972 the source access. The range of the source access relation
7973 C<source> should have the same dimension as the range
7974 of the sink access relation.
7975 The C<isl_access_info_free> function should usually not be
7976 called explicitly, because it is called implicitly by
7977 C<isl_access_info_compute_flow>.
7979 The result of the dependence analysis is collected in an
7980 C<isl_flow>. There may be elements of
7981 the sink access for which no preceding source access could be
7982 found or for which all preceding sources are I<may> accesses.
7983 The relations containing these elements can be obtained through
7984 calls to C<isl_flow_get_no_source>, the first with C<must> set
7985 and the second with C<must> unset.
7986 In the case of standard flow dependence analysis,
7987 with the sink a read and the sources I<must> writes,
7988 the first relation corresponds to the reads from uninitialized
7989 array elements and the second relation is empty.
7990 The actual flow dependences can be extracted using
7991 C<isl_flow_foreach>. This function will call the user-specified
7992 callback function C<fn> for each B<non-empty> dependence between
7993 a source and the sink. The callback function is called
7994 with four arguments, the actual flow dependence relation
7995 mapping source iterations to sink iterations, a boolean that
7996 indicates whether it is a I<must> or I<may> dependence, a token
7997 identifying the source and an additional C<void *> with value
7998 equal to the third argument of the C<isl_flow_foreach> call.
7999 A dependence is marked I<must> if it originates from a I<must>
8000 source and if it is not followed by any I<may> sources.
8002 After finishing with an C<isl_flow>, the user should call
8003 C<isl_flow_free> to free all associated memory.
8005 =head3 Interaction with the Low-level Interface
8007 During the dependence analysis, we frequently need to perform
8008 the following operation. Given a relation between sink iterations
8009 and potential source iterations from a particular source domain,
8010 what is the last potential source iteration corresponding to each
8011 sink iteration. It can sometimes be convenient to adjust
8012 the set of potential source iterations before or after each such operation.
8013 The prototypical example is fuzzy array dataflow analysis,
8014 where we need to analyze if, based on data-dependent constraints,
8015 the sink iteration can ever be executed without one or more of
8016 the corresponding potential source iterations being executed.
8017 If so, we can introduce extra parameters and select an unknown
8018 but fixed source iteration from the potential source iterations.
8019 To be able to perform such manipulations, C<isl> provides the following
8022 #include <isl/flow.h>
8024 typedef __isl_give isl_restriction *(*isl_access_restrict)(
8025 __isl_keep isl_map *source_map,
8026 __isl_keep isl_set *sink, void *source_user,
8028 __isl_give isl_access_info *isl_access_info_set_restrict(
8029 __isl_take isl_access_info *acc,
8030 isl_access_restrict fn, void *user);
8032 The function C<isl_access_info_set_restrict> should be called
8033 before calling C<isl_access_info_compute_flow> and registers a callback function
8034 that will be called any time C<isl> is about to compute the last
8035 potential source. The first argument is the (reverse) proto-dependence,
8036 mapping sink iterations to potential source iterations.
8037 The second argument represents the sink iterations for which
8038 we want to compute the last source iteration.
8039 The third argument is the token corresponding to the source
8040 and the final argument is the token passed to C<isl_access_info_set_restrict>.
8041 The callback is expected to return a restriction on either the input or
8042 the output of the operation computing the last potential source.
8043 If the input needs to be restricted then restrictions are needed
8044 for both the source and the sink iterations. The sink iterations
8045 and the potential source iterations will be intersected with these sets.
8046 If the output needs to be restricted then only a restriction on the source
8047 iterations is required.
8048 If any error occurs, the callback should return C<NULL>.
8049 An C<isl_restriction> object can be created, freed and inspected
8050 using the following functions.
8052 #include <isl/flow.h>
8054 __isl_give isl_restriction *isl_restriction_input(
8055 __isl_take isl_set *source_restr,
8056 __isl_take isl_set *sink_restr);
8057 __isl_give isl_restriction *isl_restriction_output(
8058 __isl_take isl_set *source_restr);
8059 __isl_give isl_restriction *isl_restriction_none(
8060 __isl_take isl_map *source_map);
8061 __isl_give isl_restriction *isl_restriction_empty(
8062 __isl_take isl_map *source_map);
8063 __isl_null isl_restriction *isl_restriction_free(
8064 __isl_take isl_restriction *restr);
8066 C<isl_restriction_none> and C<isl_restriction_empty> are special
8067 cases of C<isl_restriction_input>. C<isl_restriction_none>
8068 is essentially equivalent to
8070 isl_restriction_input(isl_set_universe(
8071 isl_space_range(isl_map_get_space(source_map))),
8073 isl_space_domain(isl_map_get_space(source_map))));
8075 whereas C<isl_restriction_empty> is essentially equivalent to
8077 isl_restriction_input(isl_set_empty(
8078 isl_space_range(isl_map_get_space(source_map))),
8080 isl_space_domain(isl_map_get_space(source_map))));
8084 B<The functionality described in this section is fairly new
8085 and may be subject to change.>
8087 #include <isl/schedule.h>
8088 __isl_give isl_schedule *
8089 isl_schedule_constraints_compute_schedule(
8090 __isl_take isl_schedule_constraints *sc);
8092 The function C<isl_schedule_constraints_compute_schedule> can be
8093 used to compute a schedule that satisfies the given schedule constraints.
8094 These schedule constraints include the iteration domain for which
8095 a schedule should be computed and dependences between pairs of
8096 iterations. In particular, these dependences include
8097 I<validity> dependences and I<proximity> dependences.
8098 By default, the algorithm used to construct the schedule is similar
8099 to that of C<Pluto>.
8100 Alternatively, Feautrier's multi-dimensional scheduling algorithm can
8102 The generated schedule respects all validity dependences.
8103 That is, all dependence distances over these dependences in the
8104 scheduled space are lexicographically positive.
8105 The default algorithm tries to ensure that the dependence distances
8106 over coincidence constraints are zero and to minimize the
8107 dependence distances over proximity dependences.
8108 Moreover, it tries to obtain sequences (bands) of schedule dimensions
8109 for groups of domains where the dependence distances over validity
8110 dependences have only non-negative values.
8111 When using Feautrier's algorithm, the coincidence and proximity constraints
8112 are only taken into account during the extension to a
8113 full-dimensional schedule.
8115 An C<isl_schedule_constraints> object can be constructed
8116 and manipulated using the following functions.
8118 #include <isl/schedule.h>
8119 __isl_give isl_schedule_constraints *
8120 isl_schedule_constraints_copy(
8121 __isl_keep isl_schedule_constraints *sc);
8122 __isl_give isl_schedule_constraints *
8123 isl_schedule_constraints_on_domain(
8124 __isl_take isl_union_set *domain);
8125 __isl_give isl_schedule_constraints *
8126 isl_schedule_constraints_set_context(
8127 __isl_take isl_schedule_constraints *sc,
8128 __isl_take isl_set *context);
8129 __isl_give isl_schedule_constraints *
8130 isl_schedule_constraints_set_validity(
8131 __isl_take isl_schedule_constraints *sc,
8132 __isl_take isl_union_map *validity);
8133 __isl_give isl_schedule_constraints *
8134 isl_schedule_constraints_set_coincidence(
8135 __isl_take isl_schedule_constraints *sc,
8136 __isl_take isl_union_map *coincidence);
8137 __isl_give isl_schedule_constraints *
8138 isl_schedule_constraints_set_proximity(
8139 __isl_take isl_schedule_constraints *sc,
8140 __isl_take isl_union_map *proximity);
8141 __isl_give isl_schedule_constraints *
8142 isl_schedule_constraints_set_conditional_validity(
8143 __isl_take isl_schedule_constraints *sc,
8144 __isl_take isl_union_map *condition,
8145 __isl_take isl_union_map *validity);
8146 __isl_null isl_schedule_constraints *
8147 isl_schedule_constraints_free(
8148 __isl_take isl_schedule_constraints *sc);
8150 The initial C<isl_schedule_constraints> object created by
8151 C<isl_schedule_constraints_on_domain> does not impose any constraints.
8152 That is, it has an empty set of dependences.
8153 The function C<isl_schedule_constraints_set_context> allows the user
8154 to specify additional constraints on the parameters that may
8155 be assumed to hold during the construction of the schedule.
8156 The function C<isl_schedule_constraints_set_validity> replaces the
8157 validity dependences, mapping domain elements I<i> to domain
8158 elements that should be scheduled after I<i>.
8159 The function C<isl_schedule_constraints_set_coincidence> replaces the
8160 coincidence dependences, mapping domain elements I<i> to domain
8161 elements that should be scheduled together with I<I>, if possible.
8162 The function C<isl_schedule_constraints_set_proximity> replaces the
8163 proximity dependences, mapping domain elements I<i> to domain
8164 elements that should be scheduled either before I<I>
8165 or as early as possible after I<i>.
8167 The function C<isl_schedule_constraints_set_conditional_validity>
8168 replaces the conditional validity constraints.
8169 A conditional validity constraint is only imposed when any of the corresponding
8170 conditions is satisfied, i.e., when any of them is non-zero.
8171 That is, the scheduler ensures that within each band if the dependence
8172 distances over the condition constraints are not all zero
8173 then all corresponding conditional validity constraints are respected.
8174 A conditional validity constraint corresponds to a condition
8175 if the two are adjacent, i.e., if the domain of one relation intersect
8176 the range of the other relation.
8177 The typical use case of conditional validity constraints is
8178 to allow order constraints between live ranges to be violated
8179 as long as the live ranges themselves are local to the band.
8180 To allow more fine-grained control over which conditions correspond
8181 to which conditional validity constraints, the domains and ranges
8182 of these relations may include I<tags>. That is, the domains and
8183 ranges of those relation may themselves be wrapped relations
8184 where the iteration domain appears in the domain of those wrapped relations
8185 and the range of the wrapped relations can be arbitrarily chosen
8186 by the user. Conditions and conditional validity constraints are only
8187 considered adjacent to each other if the entire wrapped relation matches.
8188 In particular, a relation with a tag will never be considered adjacent
8189 to a relation without a tag.
8191 The following function computes a schedule directly from
8192 an iteration domain and validity and proximity dependences
8193 and is implemented in terms of the functions described above.
8194 The use of C<isl_union_set_compute_schedule> is discouraged.
8196 #include <isl/schedule.h>
8197 __isl_give isl_schedule *isl_union_set_compute_schedule(
8198 __isl_take isl_union_set *domain,
8199 __isl_take isl_union_map *validity,
8200 __isl_take isl_union_map *proximity);
8202 The generated schedule represents a schedule tree.
8203 For more information on schedule trees, see
8204 L</"Schedule Trees">.
8208 #include <isl/schedule.h>
8209 int isl_options_set_schedule_max_coefficient(
8210 isl_ctx *ctx, int val);
8211 int isl_options_get_schedule_max_coefficient(
8213 int isl_options_set_schedule_max_constant_term(
8214 isl_ctx *ctx, int val);
8215 int isl_options_get_schedule_max_constant_term(
8217 int isl_options_set_schedule_fuse(isl_ctx *ctx, int val);
8218 int isl_options_get_schedule_fuse(isl_ctx *ctx);
8219 int isl_options_set_schedule_maximize_band_depth(
8220 isl_ctx *ctx, int val);
8221 int isl_options_get_schedule_maximize_band_depth(
8223 int isl_options_set_schedule_outer_coincidence(
8224 isl_ctx *ctx, int val);
8225 int isl_options_get_schedule_outer_coincidence(
8227 int isl_options_set_schedule_split_scaled(
8228 isl_ctx *ctx, int val);
8229 int isl_options_get_schedule_split_scaled(
8231 int isl_options_set_schedule_algorithm(
8232 isl_ctx *ctx, int val);
8233 int isl_options_get_schedule_algorithm(
8235 int isl_options_set_schedule_separate_components(
8236 isl_ctx *ctx, int val);
8237 int isl_options_get_schedule_separate_components(
8242 =item * schedule_max_coefficient
8244 This option enforces that the coefficients for variable and parameter
8245 dimensions in the calculated schedule are not larger than the specified value.
8246 This option can significantly increase the speed of the scheduling calculation
8247 and may also prevent fusing of unrelated dimensions. A value of -1 means that
8248 this option does not introduce bounds on the variable or parameter
8251 =item * schedule_max_constant_term
8253 This option enforces that the constant coefficients in the calculated schedule
8254 are not larger than the maximal constant term. This option can significantly
8255 increase the speed of the scheduling calculation and may also prevent fusing of
8256 unrelated dimensions. A value of -1 means that this option does not introduce
8257 bounds on the constant coefficients.
8259 =item * schedule_fuse
8261 This option controls the level of fusion.
8262 If this option is set to C<ISL_SCHEDULE_FUSE_MIN>, then loops in the
8263 resulting schedule will be distributed as much as possible.
8264 If this option is set to C<ISL_SCHEDULE_FUSE_MAX>, then C<isl> will
8265 try to fuse loops in the resulting schedule.
8267 =item * schedule_maximize_band_depth
8269 If this option is set, we do not split bands at the point
8270 where we detect splitting is necessary. Instead, we
8271 backtrack and split bands as early as possible. This
8272 reduces the number of splits and maximizes the width of
8273 the bands. Wider bands give more possibilities for tiling.
8274 Note that if the C<schedule_fuse> option is set to C<ISL_SCHEDULE_FUSE_MIN>,
8275 then bands will be split as early as possible, even if there is no need.
8276 The C<schedule_maximize_band_depth> option therefore has no effect in this case.
8278 =item * schedule_outer_coincidence
8280 If this option is set, then we try to construct schedules
8281 where the outermost scheduling dimension in each band
8282 satisfies the coincidence constraints.
8284 =item * schedule_split_scaled
8286 If this option is set, then we try to construct schedules in which the
8287 constant term is split off from the linear part if the linear parts of
8288 the scheduling rows for all nodes in the graphs have a common non-trivial
8290 The constant term is then placed in a separate band and the linear
8293 =item * schedule_algorithm
8295 Selects the scheduling algorithm to be used.
8296 Available scheduling algorithms are C<ISL_SCHEDULE_ALGORITHM_ISL>
8297 and C<ISL_SCHEDULE_ALGORITHM_FEAUTRIER>.
8299 =item * schedule_separate_components
8301 If this option is set then the function C<isl_schedule_get_map>
8302 will treat set nodes in the same way as sequence nodes.
8306 =head2 AST Generation
8308 This section describes the C<isl> functionality for generating
8309 ASTs that visit all the elements
8310 in a domain in an order specified by a schedule.
8311 In particular, given a C<isl_union_map>, an AST is generated
8312 that visits all the elements in the domain of the C<isl_union_map>
8313 according to the lexicographic order of the corresponding image
8314 element(s). If the range of the C<isl_union_map> consists of
8315 elements in more than one space, then each of these spaces is handled
8316 separately in an arbitrary order.
8317 It should be noted that the image elements only specify the I<order>
8318 in which the corresponding domain elements should be visited.
8319 No direct relation between the image elements and the loop iterators
8320 in the generated AST should be assumed.
8322 Each AST is generated within a build. The initial build
8323 simply specifies the constraints on the parameters (if any)
8324 and can be created, inspected, copied and freed using the following functions.
8326 #include <isl/ast_build.h>
8327 __isl_give isl_ast_build *isl_ast_build_from_context(
8328 __isl_take isl_set *set);
8329 __isl_give isl_ast_build *isl_ast_build_copy(
8330 __isl_keep isl_ast_build *build);
8331 __isl_null isl_ast_build *isl_ast_build_free(
8332 __isl_take isl_ast_build *build);
8334 The C<set> argument is usually a parameter set with zero or more parameters.
8335 More C<isl_ast_build> functions are described in L</"Nested AST Generation">
8336 and L</"Fine-grained Control over AST Generation">.
8337 Finally, the AST itself can be constructed using the following
8340 #include <isl/ast_build.h>
8341 __isl_give isl_ast_node *isl_ast_build_ast_from_schedule(
8342 __isl_keep isl_ast_build *build,
8343 __isl_take isl_union_map *schedule);
8345 =head3 Inspecting the AST
8347 The basic properties of an AST node can be obtained as follows.
8349 #include <isl/ast.h>
8350 enum isl_ast_node_type isl_ast_node_get_type(
8351 __isl_keep isl_ast_node *node);
8353 The type of an AST node is one of
8354 C<isl_ast_node_for>,
8356 C<isl_ast_node_block> or
8357 C<isl_ast_node_user>.
8358 An C<isl_ast_node_for> represents a for node.
8359 An C<isl_ast_node_if> represents an if node.
8360 An C<isl_ast_node_block> represents a compound node.
8361 An C<isl_ast_node_user> represents an expression statement.
8362 An expression statement typically corresponds to a domain element, i.e.,
8363 one of the elements that is visited by the AST.
8365 Each type of node has its own additional properties.
8367 #include <isl/ast.h>
8368 __isl_give isl_ast_expr *isl_ast_node_for_get_iterator(
8369 __isl_keep isl_ast_node *node);
8370 __isl_give isl_ast_expr *isl_ast_node_for_get_init(
8371 __isl_keep isl_ast_node *node);
8372 __isl_give isl_ast_expr *isl_ast_node_for_get_cond(
8373 __isl_keep isl_ast_node *node);
8374 __isl_give isl_ast_expr *isl_ast_node_for_get_inc(
8375 __isl_keep isl_ast_node *node);
8376 __isl_give isl_ast_node *isl_ast_node_for_get_body(
8377 __isl_keep isl_ast_node *node);
8378 int isl_ast_node_for_is_degenerate(
8379 __isl_keep isl_ast_node *node);
8381 An C<isl_ast_for> is considered degenerate if it is known to execute
8384 #include <isl/ast.h>
8385 __isl_give isl_ast_expr *isl_ast_node_if_get_cond(
8386 __isl_keep isl_ast_node *node);
8387 __isl_give isl_ast_node *isl_ast_node_if_get_then(
8388 __isl_keep isl_ast_node *node);
8389 int isl_ast_node_if_has_else(
8390 __isl_keep isl_ast_node *node);
8391 __isl_give isl_ast_node *isl_ast_node_if_get_else(
8392 __isl_keep isl_ast_node *node);
8394 __isl_give isl_ast_node_list *
8395 isl_ast_node_block_get_children(
8396 __isl_keep isl_ast_node *node);
8398 __isl_give isl_ast_expr *isl_ast_node_user_get_expr(
8399 __isl_keep isl_ast_node *node);
8401 Each of the returned C<isl_ast_expr>s can in turn be inspected using
8402 the following functions.
8404 #include <isl/ast.h>
8405 enum isl_ast_expr_type isl_ast_expr_get_type(
8406 __isl_keep isl_ast_expr *expr);
8408 The type of an AST expression is one of
8410 C<isl_ast_expr_id> or
8411 C<isl_ast_expr_int>.
8412 An C<isl_ast_expr_op> represents the result of an operation.
8413 An C<isl_ast_expr_id> represents an identifier.
8414 An C<isl_ast_expr_int> represents an integer value.
8416 Each type of expression has its own additional properties.
8418 #include <isl/ast.h>
8419 enum isl_ast_op_type isl_ast_expr_get_op_type(
8420 __isl_keep isl_ast_expr *expr);
8421 int isl_ast_expr_get_op_n_arg(__isl_keep isl_ast_expr *expr);
8422 __isl_give isl_ast_expr *isl_ast_expr_get_op_arg(
8423 __isl_keep isl_ast_expr *expr, int pos);
8424 int isl_ast_node_foreach_ast_op_type(
8425 __isl_keep isl_ast_node *node,
8426 int (*fn)(enum isl_ast_op_type type, void *user),
8429 C<isl_ast_expr_get_op_type> returns the type of the operation
8430 performed. C<isl_ast_expr_get_op_n_arg> returns the number of
8431 arguments. C<isl_ast_expr_get_op_arg> returns the specified
8433 C<isl_ast_node_foreach_ast_op_type> calls C<fn> for each distinct
8434 C<isl_ast_op_type> that appears in C<node>.
8435 The operation type is one of the following.
8439 =item C<isl_ast_op_and>
8441 Logical I<and> of two arguments.
8442 Both arguments can be evaluated.
8444 =item C<isl_ast_op_and_then>
8446 Logical I<and> of two arguments.
8447 The second argument can only be evaluated if the first evaluates to true.
8449 =item C<isl_ast_op_or>
8451 Logical I<or> of two arguments.
8452 Both arguments can be evaluated.
8454 =item C<isl_ast_op_or_else>
8456 Logical I<or> of two arguments.
8457 The second argument can only be evaluated if the first evaluates to false.
8459 =item C<isl_ast_op_max>
8461 Maximum of two or more arguments.
8463 =item C<isl_ast_op_min>
8465 Minimum of two or more arguments.
8467 =item C<isl_ast_op_minus>
8471 =item C<isl_ast_op_add>
8473 Sum of two arguments.
8475 =item C<isl_ast_op_sub>
8477 Difference of two arguments.
8479 =item C<isl_ast_op_mul>
8481 Product of two arguments.
8483 =item C<isl_ast_op_div>
8485 Exact division. That is, the result is known to be an integer.
8487 =item C<isl_ast_op_fdiv_q>
8489 Result of integer division, rounded towards negative
8492 =item C<isl_ast_op_pdiv_q>
8494 Result of integer division, where dividend is known to be non-negative.
8496 =item C<isl_ast_op_pdiv_r>
8498 Remainder of integer division, where dividend is known to be non-negative.
8500 =item C<isl_ast_op_zdiv_r>
8502 Equal to zero iff the remainder on integer division is zero.
8504 =item C<isl_ast_op_cond>
8506 Conditional operator defined on three arguments.
8507 If the first argument evaluates to true, then the result
8508 is equal to the second argument. Otherwise, the result
8509 is equal to the third argument.
8510 The second and third argument may only be evaluated if
8511 the first argument evaluates to true and false, respectively.
8512 Corresponds to C<a ? b : c> in C.
8514 =item C<isl_ast_op_select>
8516 Conditional operator defined on three arguments.
8517 If the first argument evaluates to true, then the result
8518 is equal to the second argument. Otherwise, the result
8519 is equal to the third argument.
8520 The second and third argument may be evaluated independently
8521 of the value of the first argument.
8522 Corresponds to C<a * b + (1 - a) * c> in C.
8524 =item C<isl_ast_op_eq>
8528 =item C<isl_ast_op_le>
8530 Less than or equal relation.
8532 =item C<isl_ast_op_lt>
8536 =item C<isl_ast_op_ge>
8538 Greater than or equal relation.
8540 =item C<isl_ast_op_gt>
8542 Greater than relation.
8544 =item C<isl_ast_op_call>
8547 The number of arguments of the C<isl_ast_expr> is one more than
8548 the number of arguments in the function call, the first argument
8549 representing the function being called.
8551 =item C<isl_ast_op_access>
8554 The number of arguments of the C<isl_ast_expr> is one more than
8555 the number of index expressions in the array access, the first argument
8556 representing the array being accessed.
8558 =item C<isl_ast_op_member>
8561 This operation has two arguments, a structure and the name of
8562 the member of the structure being accessed.
8566 #include <isl/ast.h>
8567 __isl_give isl_id *isl_ast_expr_get_id(
8568 __isl_keep isl_ast_expr *expr);
8570 Return the identifier represented by the AST expression.
8572 #include <isl/ast.h>
8573 __isl_give isl_val *isl_ast_expr_get_val(
8574 __isl_keep isl_ast_expr *expr);
8576 Return the integer represented by the AST expression.
8578 =head3 Properties of ASTs
8580 #include <isl/ast.h>
8581 int isl_ast_expr_is_equal(__isl_keep isl_ast_expr *expr1,
8582 __isl_keep isl_ast_expr *expr2);
8584 Check if two C<isl_ast_expr>s are equal to each other.
8586 =head3 Manipulating and printing the AST
8588 AST nodes can be copied and freed using the following functions.
8590 #include <isl/ast.h>
8591 __isl_give isl_ast_node *isl_ast_node_copy(
8592 __isl_keep isl_ast_node *node);
8593 __isl_null isl_ast_node *isl_ast_node_free(
8594 __isl_take isl_ast_node *node);
8596 AST expressions can be copied and freed using the following functions.
8598 #include <isl/ast.h>
8599 __isl_give isl_ast_expr *isl_ast_expr_copy(
8600 __isl_keep isl_ast_expr *expr);
8601 __isl_null isl_ast_expr *isl_ast_expr_free(
8602 __isl_take isl_ast_expr *expr);
8604 New AST expressions can be created either directly or within
8605 the context of an C<isl_ast_build>.
8607 #include <isl/ast.h>
8608 __isl_give isl_ast_expr *isl_ast_expr_from_val(
8609 __isl_take isl_val *v);
8610 __isl_give isl_ast_expr *isl_ast_expr_from_id(
8611 __isl_take isl_id *id);
8612 __isl_give isl_ast_expr *isl_ast_expr_neg(
8613 __isl_take isl_ast_expr *expr);
8614 __isl_give isl_ast_expr *isl_ast_expr_address_of(
8615 __isl_take isl_ast_expr *expr);
8616 __isl_give isl_ast_expr *isl_ast_expr_add(
8617 __isl_take isl_ast_expr *expr1,
8618 __isl_take isl_ast_expr *expr2);
8619 __isl_give isl_ast_expr *isl_ast_expr_sub(
8620 __isl_take isl_ast_expr *expr1,
8621 __isl_take isl_ast_expr *expr2);
8622 __isl_give isl_ast_expr *isl_ast_expr_mul(
8623 __isl_take isl_ast_expr *expr1,
8624 __isl_take isl_ast_expr *expr2);
8625 __isl_give isl_ast_expr *isl_ast_expr_div(
8626 __isl_take isl_ast_expr *expr1,
8627 __isl_take isl_ast_expr *expr2);
8628 __isl_give isl_ast_expr *isl_ast_expr_and(
8629 __isl_take isl_ast_expr *expr1,
8630 __isl_take isl_ast_expr *expr2)
8631 __isl_give isl_ast_expr *isl_ast_expr_or(
8632 __isl_take isl_ast_expr *expr1,
8633 __isl_take isl_ast_expr *expr2)
8634 __isl_give isl_ast_expr *isl_ast_expr_eq(
8635 __isl_take isl_ast_expr *expr1,
8636 __isl_take isl_ast_expr *expr2);
8637 __isl_give isl_ast_expr *isl_ast_expr_le(
8638 __isl_take isl_ast_expr *expr1,
8639 __isl_take isl_ast_expr *expr2);
8640 __isl_give isl_ast_expr *isl_ast_expr_lt(
8641 __isl_take isl_ast_expr *expr1,
8642 __isl_take isl_ast_expr *expr2);
8643 __isl_give isl_ast_expr *isl_ast_expr_ge(
8644 __isl_take isl_ast_expr *expr1,
8645 __isl_take isl_ast_expr *expr2);
8646 __isl_give isl_ast_expr *isl_ast_expr_gt(
8647 __isl_take isl_ast_expr *expr1,
8648 __isl_take isl_ast_expr *expr2);
8649 __isl_give isl_ast_expr *isl_ast_expr_access(
8650 __isl_take isl_ast_expr *array,
8651 __isl_take isl_ast_expr_list *indices);
8653 The function C<isl_ast_expr_address_of> can be applied to an
8654 C<isl_ast_expr> of type C<isl_ast_op_access> only. It is meant
8655 to represent the address of the C<isl_ast_expr_access>.
8657 #include <isl/ast_build.h>
8658 __isl_give isl_ast_expr *isl_ast_build_expr_from_pw_aff(
8659 __isl_keep isl_ast_build *build,
8660 __isl_take isl_pw_aff *pa);
8661 __isl_give isl_ast_expr *
8662 isl_ast_build_access_from_pw_multi_aff(
8663 __isl_keep isl_ast_build *build,
8664 __isl_take isl_pw_multi_aff *pma);
8665 __isl_give isl_ast_expr *
8666 isl_ast_build_access_from_multi_pw_aff(
8667 __isl_keep isl_ast_build *build,
8668 __isl_take isl_multi_pw_aff *mpa);
8669 __isl_give isl_ast_expr *
8670 isl_ast_build_call_from_pw_multi_aff(
8671 __isl_keep isl_ast_build *build,
8672 __isl_take isl_pw_multi_aff *pma);
8673 __isl_give isl_ast_expr *
8674 isl_ast_build_call_from_multi_pw_aff(
8675 __isl_keep isl_ast_build *build,
8676 __isl_take isl_multi_pw_aff *mpa);
8678 The domains of C<pa>, C<mpa> and C<pma> should correspond
8679 to the schedule space of C<build>.
8680 The tuple id of C<mpa> or C<pma> is used as the array being accessed or
8681 the function being called.
8682 If the accessed space is a nested relation, then it is taken
8683 to represent an access of the member specified by the range
8684 of this nested relation of the structure specified by the domain
8685 of the nested relation.
8687 The following functions can be used to modify an C<isl_ast_expr>.
8689 #include <isl/ast.h>
8690 __isl_give isl_ast_expr *isl_ast_expr_set_op_arg(
8691 __isl_take isl_ast_expr *expr, int pos,
8692 __isl_take isl_ast_expr *arg);
8694 Replace the argument of C<expr> at position C<pos> by C<arg>.
8696 #include <isl/ast.h>
8697 __isl_give isl_ast_expr *isl_ast_expr_substitute_ids(
8698 __isl_take isl_ast_expr *expr,
8699 __isl_take isl_id_to_ast_expr *id2expr);
8701 The function C<isl_ast_expr_substitute_ids> replaces the
8702 subexpressions of C<expr> of type C<isl_ast_expr_id>
8703 by the corresponding expression in C<id2expr>, if there is any.
8706 User specified data can be attached to an C<isl_ast_node> and obtained
8707 from the same C<isl_ast_node> using the following functions.
8709 #include <isl/ast.h>
8710 __isl_give isl_ast_node *isl_ast_node_set_annotation(
8711 __isl_take isl_ast_node *node,
8712 __isl_take isl_id *annotation);
8713 __isl_give isl_id *isl_ast_node_get_annotation(
8714 __isl_keep isl_ast_node *node);
8716 Basic printing can be performed using the following functions.
8718 #include <isl/ast.h>
8719 __isl_give isl_printer *isl_printer_print_ast_expr(
8720 __isl_take isl_printer *p,
8721 __isl_keep isl_ast_expr *expr);
8722 __isl_give isl_printer *isl_printer_print_ast_node(
8723 __isl_take isl_printer *p,
8724 __isl_keep isl_ast_node *node);
8725 __isl_give char *isl_ast_expr_to_str(
8726 __isl_keep isl_ast_expr *expr);
8728 More advanced printing can be performed using the following functions.
8730 #include <isl/ast.h>
8731 __isl_give isl_printer *isl_ast_op_type_print_macro(
8732 enum isl_ast_op_type type,
8733 __isl_take isl_printer *p);
8734 __isl_give isl_printer *isl_ast_node_print_macros(
8735 __isl_keep isl_ast_node *node,
8736 __isl_take isl_printer *p);
8737 __isl_give isl_printer *isl_ast_node_print(
8738 __isl_keep isl_ast_node *node,
8739 __isl_take isl_printer *p,
8740 __isl_take isl_ast_print_options *options);
8741 __isl_give isl_printer *isl_ast_node_for_print(
8742 __isl_keep isl_ast_node *node,
8743 __isl_take isl_printer *p,
8744 __isl_take isl_ast_print_options *options);
8745 __isl_give isl_printer *isl_ast_node_if_print(
8746 __isl_keep isl_ast_node *node,
8747 __isl_take isl_printer *p,
8748 __isl_take isl_ast_print_options *options);
8750 While printing an C<isl_ast_node> in C<ISL_FORMAT_C>,
8751 C<isl> may print out an AST that makes use of macros such
8752 as C<floord>, C<min> and C<max>.
8753 C<isl_ast_op_type_print_macro> prints out the macro
8754 corresponding to a specific C<isl_ast_op_type>.
8755 C<isl_ast_node_print_macros> scans the C<isl_ast_node>
8756 for expressions where these macros would be used and prints
8757 out the required macro definitions.
8758 Essentially, C<isl_ast_node_print_macros> calls
8759 C<isl_ast_node_foreach_ast_op_type> with C<isl_ast_op_type_print_macro>
8760 as function argument.
8761 C<isl_ast_node_print>, C<isl_ast_node_for_print> and
8762 C<isl_ast_node_if_print> print an C<isl_ast_node>
8763 in C<ISL_FORMAT_C>, but allow for some extra control
8764 through an C<isl_ast_print_options> object.
8765 This object can be created using the following functions.
8767 #include <isl/ast.h>
8768 __isl_give isl_ast_print_options *
8769 isl_ast_print_options_alloc(isl_ctx *ctx);
8770 __isl_give isl_ast_print_options *
8771 isl_ast_print_options_copy(
8772 __isl_keep isl_ast_print_options *options);
8773 __isl_null isl_ast_print_options *
8774 isl_ast_print_options_free(
8775 __isl_take isl_ast_print_options *options);
8777 __isl_give isl_ast_print_options *
8778 isl_ast_print_options_set_print_user(
8779 __isl_take isl_ast_print_options *options,
8780 __isl_give isl_printer *(*print_user)(
8781 __isl_take isl_printer *p,
8782 __isl_take isl_ast_print_options *options,
8783 __isl_keep isl_ast_node *node, void *user),
8785 __isl_give isl_ast_print_options *
8786 isl_ast_print_options_set_print_for(
8787 __isl_take isl_ast_print_options *options,
8788 __isl_give isl_printer *(*print_for)(
8789 __isl_take isl_printer *p,
8790 __isl_take isl_ast_print_options *options,
8791 __isl_keep isl_ast_node *node, void *user),
8794 The callback set by C<isl_ast_print_options_set_print_user>
8795 is called whenever a node of type C<isl_ast_node_user> needs to
8797 The callback set by C<isl_ast_print_options_set_print_for>
8798 is called whenever a node of type C<isl_ast_node_for> needs to
8800 Note that C<isl_ast_node_for_print> will I<not> call the
8801 callback set by C<isl_ast_print_options_set_print_for> on the node
8802 on which C<isl_ast_node_for_print> is called, but only on nested
8803 nodes of type C<isl_ast_node_for>. It is therefore safe to
8804 call C<isl_ast_node_for_print> from within the callback set by
8805 C<isl_ast_print_options_set_print_for>.
8807 The following option determines the type to be used for iterators
8808 while printing the AST.
8810 int isl_options_set_ast_iterator_type(
8811 isl_ctx *ctx, const char *val);
8812 const char *isl_options_get_ast_iterator_type(
8815 The AST printer only prints body nodes as blocks if these
8816 blocks cannot be safely omitted.
8817 For example, a C<for> node with one body node will not be
8818 surrounded with braces in C<ISL_FORMAT_C>.
8819 A block will always be printed by setting the following option.
8821 int isl_options_set_ast_always_print_block(isl_ctx *ctx,
8823 int isl_options_get_ast_always_print_block(isl_ctx *ctx);
8827 #include <isl/ast_build.h>
8828 int isl_options_set_ast_build_atomic_upper_bound(
8829 isl_ctx *ctx, int val);
8830 int isl_options_get_ast_build_atomic_upper_bound(
8832 int isl_options_set_ast_build_prefer_pdiv(isl_ctx *ctx,
8834 int isl_options_get_ast_build_prefer_pdiv(isl_ctx *ctx);
8835 int isl_options_set_ast_build_exploit_nested_bounds(
8836 isl_ctx *ctx, int val);
8837 int isl_options_get_ast_build_exploit_nested_bounds(
8839 int isl_options_set_ast_build_group_coscheduled(
8840 isl_ctx *ctx, int val);
8841 int isl_options_get_ast_build_group_coscheduled(
8843 int isl_options_set_ast_build_scale_strides(
8844 isl_ctx *ctx, int val);
8845 int isl_options_get_ast_build_scale_strides(
8847 int isl_options_set_ast_build_allow_else(isl_ctx *ctx,
8849 int isl_options_get_ast_build_allow_else(isl_ctx *ctx);
8850 int isl_options_set_ast_build_allow_or(isl_ctx *ctx,
8852 int isl_options_get_ast_build_allow_or(isl_ctx *ctx);
8856 =item * ast_build_atomic_upper_bound
8858 Generate loop upper bounds that consist of the current loop iterator,
8859 an operator and an expression not involving the iterator.
8860 If this option is not set, then the current loop iterator may appear
8861 several times in the upper bound.
8862 For example, when this option is turned off, AST generation
8865 [n] -> { A[i] -> [i] : 0 <= i <= 100, n }
8869 for (int c0 = 0; c0 <= 100 && n >= c0; c0 += 1)
8872 When the option is turned on, the following AST is generated
8874 for (int c0 = 0; c0 <= min(100, n); c0 += 1)
8877 =item * ast_build_prefer_pdiv
8879 If this option is turned off, then the AST generation will
8880 produce ASTs that may only contain C<isl_ast_op_fdiv_q>
8881 operators, but no C<isl_ast_op_pdiv_q> or
8882 C<isl_ast_op_pdiv_r> operators.
8883 If this options is turned on, then C<isl> will try to convert
8884 some of the C<isl_ast_op_fdiv_q> operators to (expressions containing)
8885 C<isl_ast_op_pdiv_q> or C<isl_ast_op_pdiv_r> operators.
8887 =item * ast_build_exploit_nested_bounds
8889 Simplify conditions based on bounds of nested for loops.
8890 In particular, remove conditions that are implied by the fact
8891 that one or more nested loops have at least one iteration,
8892 meaning that the upper bound is at least as large as the lower bound.
8893 For example, when this option is turned off, AST generation
8896 [N,M] -> { A[i,j] -> [i,j] : 0 <= i <= N and
8902 for (int c0 = 0; c0 <= N; c0 += 1)
8903 for (int c1 = 0; c1 <= M; c1 += 1)
8906 When the option is turned on, the following AST is generated
8908 for (int c0 = 0; c0 <= N; c0 += 1)
8909 for (int c1 = 0; c1 <= M; c1 += 1)
8912 =item * ast_build_group_coscheduled
8914 If two domain elements are assigned the same schedule point, then
8915 they may be executed in any order and they may even appear in different
8916 loops. If this options is set, then the AST generator will make
8917 sure that coscheduled domain elements do not appear in separate parts
8918 of the AST. This is useful in case of nested AST generation
8919 if the outer AST generation is given only part of a schedule
8920 and the inner AST generation should handle the domains that are
8921 coscheduled by this initial part of the schedule together.
8922 For example if an AST is generated for a schedule
8924 { A[i] -> [0]; B[i] -> [0] }
8926 then the C<isl_ast_build_set_create_leaf> callback described
8927 below may get called twice, once for each domain.
8928 Setting this option ensures that the callback is only called once
8929 on both domains together.
8931 =item * ast_build_separation_bounds
8933 This option specifies which bounds to use during separation.
8934 If this option is set to C<ISL_AST_BUILD_SEPARATION_BOUNDS_IMPLICIT>
8935 then all (possibly implicit) bounds on the current dimension will
8936 be used during separation.
8937 If this option is set to C<ISL_AST_BUILD_SEPARATION_BOUNDS_EXPLICIT>
8938 then only those bounds that are explicitly available will
8939 be used during separation.
8941 =item * ast_build_scale_strides
8943 This option specifies whether the AST generator is allowed
8944 to scale down iterators of strided loops.
8946 =item * ast_build_allow_else
8948 This option specifies whether the AST generator is allowed
8949 to construct if statements with else branches.
8951 =item * ast_build_allow_or
8953 This option specifies whether the AST generator is allowed
8954 to construct if conditions with disjunctions.
8958 =head3 Fine-grained Control over AST Generation
8960 Besides specifying the constraints on the parameters,
8961 an C<isl_ast_build> object can be used to control
8962 various aspects of the AST generation process.
8963 The most prominent way of control is through ``options'',
8964 which can be set using the following function.
8966 #include <isl/ast_build.h>
8967 __isl_give isl_ast_build *
8968 isl_ast_build_set_options(
8969 __isl_take isl_ast_build *control,
8970 __isl_take isl_union_map *options);
8972 The options are encoded in an C<isl_union_map>.
8973 The domain of this union relation refers to the schedule domain,
8974 i.e., the range of the schedule passed to C<isl_ast_build_ast_from_schedule>.
8975 In the case of nested AST generation (see L</"Nested AST Generation">),
8976 the domain of C<options> should refer to the extra piece of the schedule.
8977 That is, it should be equal to the range of the wrapped relation in the
8978 range of the schedule.
8979 The range of the options can consist of elements in one or more spaces,
8980 the names of which determine the effect of the option.
8981 The values of the range typically also refer to the schedule dimension
8982 to which the option applies. In case of nested AST generation
8983 (see L</"Nested AST Generation">), these values refer to the position
8984 of the schedule dimension within the innermost AST generation.
8985 The constraints on the domain elements of
8986 the option should only refer to this dimension and earlier dimensions.
8987 We consider the following spaces.
8991 =item C<separation_class>
8993 This space is a wrapped relation between two one dimensional spaces.
8994 The input space represents the schedule dimension to which the option
8995 applies and the output space represents the separation class.
8996 While constructing a loop corresponding to the specified schedule
8997 dimension(s), the AST generator will try to generate separate loops
8998 for domain elements that are assigned different classes.
8999 If only some of the elements are assigned a class, then those elements
9000 that are not assigned any class will be treated as belonging to a class
9001 that is separate from the explicitly assigned classes.
9002 The typical use case for this option is to separate full tiles from
9004 The other options, described below, are applied after the separation
9007 As an example, consider the separation into full and partial tiles
9008 of a tiling of a triangular domain.
9009 Take, for example, the domain
9011 { A[i,j] : 0 <= i,j and i + j <= 100 }
9013 and a tiling into tiles of 10 by 10. The input to the AST generator
9014 is then the schedule
9016 { A[i,j] -> [([i/10]),[j/10],i,j] : 0 <= i,j and
9019 Without any options, the following AST is generated
9021 for (int c0 = 0; c0 <= 10; c0 += 1)
9022 for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
9023 for (int c2 = 10 * c0;
9024 c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
9026 for (int c3 = 10 * c1;
9027 c3 <= min(10 * c1 + 9, -c2 + 100);
9031 Separation into full and partial tiles can be obtained by assigning
9032 a class, say C<0>, to the full tiles. The full tiles are represented by those
9033 values of the first and second schedule dimensions for which there are
9034 values of the third and fourth dimensions to cover an entire tile.
9035 That is, we need to specify the following option
9037 { [a,b,c,d] -> separation_class[[0]->[0]] :
9038 exists b': 0 <= 10a,10b' and
9039 10a+9+10b'+9 <= 100;
9040 [a,b,c,d] -> separation_class[[1]->[0]] :
9041 0 <= 10a,10b and 10a+9+10b+9 <= 100 }
9045 { [a, b, c, d] -> separation_class[[1] -> [0]] :
9046 a >= 0 and b >= 0 and b <= 8 - a;
9047 [a, b, c, d] -> separation_class[[0] -> [0]] :
9050 With this option, the generated AST is as follows
9053 for (int c0 = 0; c0 <= 8; c0 += 1) {
9054 for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
9055 for (int c2 = 10 * c0;
9056 c2 <= 10 * c0 + 9; c2 += 1)
9057 for (int c3 = 10 * c1;
9058 c3 <= 10 * c1 + 9; c3 += 1)
9060 for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
9061 for (int c2 = 10 * c0;
9062 c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
9064 for (int c3 = 10 * c1;
9065 c3 <= min(-c2 + 100, 10 * c1 + 9);
9069 for (int c0 = 9; c0 <= 10; c0 += 1)
9070 for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
9071 for (int c2 = 10 * c0;
9072 c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
9074 for (int c3 = 10 * c1;
9075 c3 <= min(10 * c1 + 9, -c2 + 100);
9082 This is a single-dimensional space representing the schedule dimension(s)
9083 to which ``separation'' should be applied. Separation tries to split
9084 a loop into several pieces if this can avoid the generation of guards
9086 See also the C<atomic> option.
9090 This is a single-dimensional space representing the schedule dimension(s)
9091 for which the domains should be considered ``atomic''. That is, the
9092 AST generator will make sure that any given domain space will only appear
9093 in a single loop at the specified level.
9095 Consider the following schedule
9097 { a[i] -> [i] : 0 <= i < 10;
9098 b[i] -> [i+1] : 0 <= i < 10 }
9100 If the following option is specified
9102 { [i] -> separate[x] }
9104 then the following AST will be generated
9108 for (int c0 = 1; c0 <= 9; c0 += 1) {
9115 If, on the other hand, the following option is specified
9117 { [i] -> atomic[x] }
9119 then the following AST will be generated
9121 for (int c0 = 0; c0 <= 10; c0 += 1) {
9128 If neither C<atomic> nor C<separate> is specified, then the AST generator
9129 may produce either of these two results or some intermediate form.
9133 This is a single-dimensional space representing the schedule dimension(s)
9134 that should be I<completely> unrolled.
9135 To obtain a partial unrolling, the user should apply an additional
9136 strip-mining to the schedule and fully unroll the inner loop.
9140 Additional control is available through the following functions.
9142 #include <isl/ast_build.h>
9143 __isl_give isl_ast_build *
9144 isl_ast_build_set_iterators(
9145 __isl_take isl_ast_build *control,
9146 __isl_take isl_id_list *iterators);
9148 The function C<isl_ast_build_set_iterators> allows the user to
9149 specify a list of iterator C<isl_id>s to be used as iterators.
9150 If the input schedule is injective, then
9151 the number of elements in this list should be as large as the dimension
9152 of the schedule space, but no direct correspondence should be assumed
9153 between dimensions and elements.
9154 If the input schedule is not injective, then an additional number
9155 of C<isl_id>s equal to the largest dimension of the input domains
9157 If the number of provided C<isl_id>s is insufficient, then additional
9158 names are automatically generated.
9160 #include <isl/ast_build.h>
9161 __isl_give isl_ast_build *
9162 isl_ast_build_set_create_leaf(
9163 __isl_take isl_ast_build *control,
9164 __isl_give isl_ast_node *(*fn)(
9165 __isl_take isl_ast_build *build,
9166 void *user), void *user);
9169 C<isl_ast_build_set_create_leaf> function allows for the
9170 specification of a callback that should be called whenever the AST
9171 generator arrives at an element of the schedule domain.
9172 The callback should return an AST node that should be inserted
9173 at the corresponding position of the AST. The default action (when
9174 the callback is not set) is to continue generating parts of the AST to scan
9175 all the domain elements associated to the schedule domain element
9176 and to insert user nodes, ``calling'' the domain element, for each of them.
9177 The C<build> argument contains the current state of the C<isl_ast_build>.
9178 To ease nested AST generation (see L</"Nested AST Generation">),
9179 all control information that is
9180 specific to the current AST generation such as the options and
9181 the callbacks has been removed from this C<isl_ast_build>.
9182 The callback would typically return the result of a nested
9184 user defined node created using the following function.
9186 #include <isl/ast.h>
9187 __isl_give isl_ast_node *isl_ast_node_alloc_user(
9188 __isl_take isl_ast_expr *expr);
9190 #include <isl/ast_build.h>
9191 __isl_give isl_ast_build *
9192 isl_ast_build_set_at_each_domain(
9193 __isl_take isl_ast_build *build,
9194 __isl_give isl_ast_node *(*fn)(
9195 __isl_take isl_ast_node *node,
9196 __isl_keep isl_ast_build *build,
9197 void *user), void *user);
9198 __isl_give isl_ast_build *
9199 isl_ast_build_set_before_each_for(
9200 __isl_take isl_ast_build *build,
9201 __isl_give isl_id *(*fn)(
9202 __isl_keep isl_ast_build *build,
9203 void *user), void *user);
9204 __isl_give isl_ast_build *
9205 isl_ast_build_set_after_each_for(
9206 __isl_take isl_ast_build *build,
9207 __isl_give isl_ast_node *(*fn)(
9208 __isl_take isl_ast_node *node,
9209 __isl_keep isl_ast_build *build,
9210 void *user), void *user);
9212 The callback set by C<isl_ast_build_set_at_each_domain> will
9213 be called for each domain AST node.
9214 The callbacks set by C<isl_ast_build_set_before_each_for>
9215 and C<isl_ast_build_set_after_each_for> will be called
9216 for each for AST node. The first will be called in depth-first
9217 pre-order, while the second will be called in depth-first post-order.
9218 Since C<isl_ast_build_set_before_each_for> is called before the for
9219 node is actually constructed, it is only passed an C<isl_ast_build>.
9220 The returned C<isl_id> will be added as an annotation (using
9221 C<isl_ast_node_set_annotation>) to the constructed for node.
9222 In particular, if the user has also specified an C<after_each_for>
9223 callback, then the annotation can be retrieved from the node passed to
9224 that callback using C<isl_ast_node_get_annotation>.
9225 All callbacks should C<NULL> on failure.
9226 The given C<isl_ast_build> can be used to create new
9227 C<isl_ast_expr> objects using C<isl_ast_build_expr_from_pw_aff>
9228 or C<isl_ast_build_call_from_pw_multi_aff>.
9230 =head3 Nested AST Generation
9232 C<isl> allows the user to create an AST within the context
9233 of another AST. These nested ASTs are created using the
9234 same C<isl_ast_build_ast_from_schedule> function that is used to create the
9235 outer AST. The C<build> argument should be an C<isl_ast_build>
9236 passed to a callback set by
9237 C<isl_ast_build_set_create_leaf>.
9238 The space of the range of the C<schedule> argument should refer
9239 to this build. In particular, the space should be a wrapped
9240 relation and the domain of this wrapped relation should be the
9241 same as that of the range of the schedule returned by
9242 C<isl_ast_build_get_schedule> below.
9243 In practice, the new schedule is typically
9244 created by calling C<isl_union_map_range_product> on the old schedule
9245 and some extra piece of the schedule.
9246 The space of the schedule domain is also available from
9247 the C<isl_ast_build>.
9249 #include <isl/ast_build.h>
9250 __isl_give isl_union_map *isl_ast_build_get_schedule(
9251 __isl_keep isl_ast_build *build);
9252 __isl_give isl_space *isl_ast_build_get_schedule_space(
9253 __isl_keep isl_ast_build *build);
9254 __isl_give isl_ast_build *isl_ast_build_restrict(
9255 __isl_take isl_ast_build *build,
9256 __isl_take isl_set *set);
9258 The C<isl_ast_build_get_schedule> function returns a (partial)
9259 schedule for the domains elements for which part of the AST still needs to
9260 be generated in the current build.
9261 In particular, the domain elements are mapped to those iterations of the loops
9262 enclosing the current point of the AST generation inside which
9263 the domain elements are executed.
9264 No direct correspondence between
9265 the input schedule and this schedule should be assumed.
9266 The space obtained from C<isl_ast_build_get_schedule_space> can be used
9267 to create a set for C<isl_ast_build_restrict> to intersect
9268 with the current build. In particular, the set passed to
9269 C<isl_ast_build_restrict> can have additional parameters.
9270 The ids of the set dimensions in the space returned by
9271 C<isl_ast_build_get_schedule_space> correspond to the
9272 iterators of the already generated loops.
9273 The user should not rely on the ids of the output dimensions
9274 of the relations in the union relation returned by
9275 C<isl_ast_build_get_schedule> having any particular value.
9279 Although C<isl> is mainly meant to be used as a library,
9280 it also contains some basic applications that use some
9281 of the functionality of C<isl>.
9282 The input may be specified in either the L<isl format>
9283 or the L<PolyLib format>.
9285 =head2 C<isl_polyhedron_sample>
9287 C<isl_polyhedron_sample> takes a polyhedron as input and prints
9288 an integer element of the polyhedron, if there is any.
9289 The first column in the output is the denominator and is always
9290 equal to 1. If the polyhedron contains no integer points,
9291 then a vector of length zero is printed.
9295 C<isl_pip> takes the same input as the C<example> program
9296 from the C<piplib> distribution, i.e., a set of constraints
9297 on the parameters, a line containing only -1 and finally a set
9298 of constraints on a parametric polyhedron.
9299 The coefficients of the parameters appear in the last columns
9300 (but before the final constant column).
9301 The output is the lexicographic minimum of the parametric polyhedron.
9302 As C<isl> currently does not have its own output format, the output
9303 is just a dump of the internal state.
9305 =head2 C<isl_polyhedron_minimize>
9307 C<isl_polyhedron_minimize> computes the minimum of some linear
9308 or affine objective function over the integer points in a polyhedron.
9309 If an affine objective function
9310 is given, then the constant should appear in the last column.
9312 =head2 C<isl_polytope_scan>
9314 Given a polytope, C<isl_polytope_scan> prints
9315 all integer points in the polytope.
9317 =head2 C<isl_codegen>
9319 Given a schedule, a context set and an options relation,
9320 C<isl_codegen> prints out an AST that scans the domain elements
9321 of the schedule in the order of their image(s) taking into account
9322 the constraints in the context set.