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 it 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 * The function C<isl_union_pw_multi_aff_add> now consistently
216 computes the sum on the shared definition domain.
217 The function C<isl_union_pw_multi_aff_union_add> has been added
218 to compute the sum on the union of definition domains.
219 The original behavior of C<isl_union_pw_multi_aff_add> was
220 confused and is no longer available.
222 =item * Band forests have been replaced by schedule trees.
224 =item * The function C<isl_union_map_compute_flow> has been
225 replaced by the function C<isl_union_access_info_compute_flow>.
226 Note that the may dependence relation returned by
227 C<isl_union_flow_get_may_dependence> is the union of
228 the two dependence relations returned by
229 C<isl_union_map_compute_flow>. Similarly for the no source relations.
230 The function C<isl_union_map_compute_flow> is still available
231 for backward compatibility, but it will be removed in the future.
233 =item * The function C<isl_basic_set_drop_constraint> has been
236 =item * The function C<isl_ast_build_ast_from_schedule> has been
237 renamed to C<isl_ast_build_node_from_schedule_map>.
238 The original name is still available
239 for backward compatibility, but it will be removed in the future.
241 =item * The C<separation_class> AST generation option has been
244 =item * The functions C<isl_equality_alloc> and C<isl_inequality_alloc>
245 have been renamed to C<isl_constraint_alloc_equality> and
246 C<isl_constraint_alloc_inequality>. The original names have been
247 kept for backward compatibility, but they will be removed in the future.
249 =item * The C<schedule_fuse> option has been replaced
250 by the C<schedule_serialize_sccs> option. The effect
251 of setting the C<schedule_fuse> option to C<ISL_SCHEDULE_FUSE_MIN>
252 is now obtained by turning on the C<schedule_serialize_sccs> option.
256 =head3 Changes since isl-0.17
260 =item * The function C<isl_printer_print_ast_expr> no longer prints
261 in C format by default. To print in C format, the output format
262 of the printer needs to have been explicitly set to C<ISL_FORMAT_C>.
263 As a result, the function C<isl_ast_expr_to_str> no longer prints
264 the expression in C format. Use C<isl_ast_expr_to_C_str> instead.
266 =item * The functions C<isl_set_align_divs> and C<isl_map_align_divs>
267 have been deprecated. The function C<isl_set_lift> has an effect
268 that is similar to C<isl_set_align_divs> and could in some cases
269 be used as an alternative.
275 C<isl> is released under the MIT license.
279 Permission is hereby granted, free of charge, to any person obtaining a copy of
280 this software and associated documentation files (the "Software"), to deal in
281 the Software without restriction, including without limitation the rights to
282 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
283 of the Software, and to permit persons to whom the Software is furnished to do
284 so, subject to the following conditions:
286 The above copyright notice and this permission notice shall be included in all
287 copies or substantial portions of the Software.
289 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
290 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
291 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
292 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
293 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
294 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
299 Note that by default C<isl> requires C<GMP>, which is released
300 under the GNU Lesser General Public License (LGPL). This means
301 that code linked against C<isl> is also linked against LGPL code.
303 When configuring with C<--with-int=imath> or C<--with-int=imath-32>, C<isl>
304 will link against C<imath>, a library for exact integer arithmetic released
305 under the MIT license.
309 The source of C<isl> can be obtained either as a tarball
310 or from the git repository. Both are available from
311 L<http://isl.gforge.inria.fr/>.
312 The installation process depends on how you obtained
315 =head2 Installation from the git repository
319 =item 1 Clone or update the repository
321 The first time the source is obtained, you need to clone
324 git clone git://repo.or.cz/isl.git
326 To obtain updates, you need to pull in the latest changes
330 =item 2 Optionally get C<imath> submodule
332 To build C<isl> with C<imath>, you need to obtain the C<imath>
333 submodule by running in the git source tree of C<isl>
338 This will fetch the required version of C<imath> in a subdirectory of C<isl>.
340 =item 2 Generate C<configure>
346 After performing the above steps, continue
347 with the L<Common installation instructions>.
349 =head2 Common installation instructions
353 =item 1 Obtain C<GMP>
355 By default, building C<isl> requires C<GMP>, including its headers files.
356 Your distribution may not provide these header files by default
357 and you may need to install a package called C<gmp-devel> or something
358 similar. Alternatively, C<GMP> can be built from
359 source, available from L<http://gmplib.org/>.
360 C<GMP> is not needed if you build C<isl> with C<imath>.
364 C<isl> uses the standard C<autoconf> C<configure> script.
369 optionally followed by some configure options.
370 A complete list of options can be obtained by running
374 Below we discuss some of the more common options.
380 Installation prefix for C<isl>
382 =item C<--with-int=[gmp|imath|imath-32]>
384 Select the integer library to be used by C<isl>, the default is C<gmp>.
385 With C<imath-32>, C<isl> will use 32 bit integers, but fall back to C<imath>
386 for values out of the 32 bit range. In most applications, C<isl> will run
387 fastest with the C<imath-32> option, followed by C<gmp> and C<imath>, the
390 =item C<--with-gmp-prefix>
392 Installation prefix for C<GMP> (architecture-independent files).
394 =item C<--with-gmp-exec-prefix>
396 Installation prefix for C<GMP> (architecture-dependent files).
404 =item 4 Install (optional)
410 =head1 Integer Set Library
412 =head2 Memory Management
414 Since a high-level operation on isl objects usually involves
415 several substeps and since the user is usually not interested in
416 the intermediate results, most functions that return a new object
417 will also release all the objects passed as arguments.
418 If the user still wants to use one or more of these arguments
419 after the function call, she should pass along a copy of the
420 object rather than the object itself.
421 The user is then responsible for making sure that the original
422 object gets used somewhere else or is explicitly freed.
424 The arguments and return values of all documented functions are
425 annotated to make clear which arguments are released and which
426 arguments are preserved. In particular, the following annotations
433 C<__isl_give> means that a new object is returned.
434 The user should make sure that the returned pointer is
435 used exactly once as a value for an C<__isl_take> argument.
436 In between, it can be used as a value for as many
437 C<__isl_keep> arguments as the user likes.
438 There is one exception, and that is the case where the
439 pointer returned is C<NULL>. Is this case, the user
440 is free to use it as an C<__isl_take> argument or not.
441 When applied to a C<char *>, the returned pointer needs to be
446 C<__isl_null> means that a C<NULL> value is returned.
450 C<__isl_take> means that the object the argument points to
451 is taken over by the function and may no longer be used
452 by the user as an argument to any other function.
453 The pointer value must be one returned by a function
454 returning an C<__isl_give> pointer.
455 If the user passes in a C<NULL> value, then this will
456 be treated as an error in the sense that the function will
457 not perform its usual operation. However, it will still
458 make sure that all the other C<__isl_take> arguments
463 C<__isl_keep> means that the function will only use the object
464 temporarily. After the function has finished, the user
465 can still use it as an argument to other functions.
466 A C<NULL> value will be treated in the same way as
467 a C<NULL> value for an C<__isl_take> argument.
468 This annotation may also be used on return values of
469 type C<const char *>, in which case the returned pointer should
470 not be freed by the user and is only valid until the object
471 from which it was derived is updated or freed.
475 =head2 Initialization
477 All manipulations of integer sets and relations occur within
478 the context of an C<isl_ctx>.
479 A given C<isl_ctx> can only be used within a single thread.
480 All arguments of a function are required to have been allocated
481 within the same context.
482 There are currently no functions available for moving an object
483 from one C<isl_ctx> to another C<isl_ctx>. This means that
484 there is currently no way of safely moving an object from one
485 thread to another, unless the whole C<isl_ctx> is moved.
487 An C<isl_ctx> can be allocated using C<isl_ctx_alloc> and
488 freed using C<isl_ctx_free>.
489 All objects allocated within an C<isl_ctx> should be freed
490 before the C<isl_ctx> itself is freed.
492 isl_ctx *isl_ctx_alloc();
493 void isl_ctx_free(isl_ctx *ctx);
495 The user can impose a bound on the number of low-level I<operations>
496 that can be performed by an C<isl_ctx>. This bound can be set and
497 retrieved using the following functions. A bound of zero means that
498 no bound is imposed. The number of operations performed can be
499 reset using C<isl_ctx_reset_operations>. Note that the number
500 of low-level operations needed to perform a high-level computation
501 may differ significantly across different versions
502 of C<isl>, but it should be the same across different platforms
503 for the same version of C<isl>.
505 Warning: This feature is experimental. C<isl> has good support to abort and
506 bail out during the computation, but this feature may exercise error code paths
507 that are normally not used that much. Consequently, it is not unlikely that
508 hidden bugs will be exposed.
510 void isl_ctx_set_max_operations(isl_ctx *ctx,
511 unsigned long max_operations);
512 unsigned long isl_ctx_get_max_operations(isl_ctx *ctx);
513 void isl_ctx_reset_operations(isl_ctx *ctx);
515 In order to be able to create an object in the same context
516 as another object, most object types (described later in
517 this document) provide a function to obtain the context
518 in which the object was created.
521 isl_ctx *isl_val_get_ctx(__isl_keep isl_val *val);
522 isl_ctx *isl_multi_val_get_ctx(
523 __isl_keep isl_multi_val *mv);
526 isl_ctx *isl_id_get_ctx(__isl_keep isl_id *id);
528 #include <isl/local_space.h>
529 isl_ctx *isl_local_space_get_ctx(
530 __isl_keep isl_local_space *ls);
533 isl_ctx *isl_set_list_get_ctx(
534 __isl_keep isl_set_list *list);
537 isl_ctx *isl_aff_get_ctx(__isl_keep isl_aff *aff);
538 isl_ctx *isl_multi_aff_get_ctx(
539 __isl_keep isl_multi_aff *maff);
540 isl_ctx *isl_pw_aff_get_ctx(__isl_keep isl_pw_aff *pa);
541 isl_ctx *isl_pw_multi_aff_get_ctx(
542 __isl_keep isl_pw_multi_aff *pma);
543 isl_ctx *isl_multi_pw_aff_get_ctx(
544 __isl_keep isl_multi_pw_aff *mpa);
545 isl_ctx *isl_union_pw_aff_get_ctx(
546 __isl_keep isl_union_pw_aff *upa);
547 isl_ctx *isl_union_pw_multi_aff_get_ctx(
548 __isl_keep isl_union_pw_multi_aff *upma);
549 isl_ctx *isl_multi_union_pw_aff_get_ctx(
550 __isl_keep isl_multi_union_pw_aff *mupa);
552 #include <isl/id_to_ast_expr.h>
553 isl_ctx *isl_id_to_ast_expr_get_ctx(
554 __isl_keep isl_id_to_ast_expr *id2expr);
556 #include <isl/point.h>
557 isl_ctx *isl_point_get_ctx(__isl_keep isl_point *pnt);
560 isl_ctx *isl_vec_get_ctx(__isl_keep isl_vec *vec);
563 isl_ctx *isl_mat_get_ctx(__isl_keep isl_mat *mat);
565 #include <isl/vertices.h>
566 isl_ctx *isl_vertices_get_ctx(
567 __isl_keep isl_vertices *vertices);
568 isl_ctx *isl_vertex_get_ctx(__isl_keep isl_vertex *vertex);
569 isl_ctx *isl_cell_get_ctx(__isl_keep isl_cell *cell);
571 #include <isl/flow.h>
572 isl_ctx *isl_restriction_get_ctx(
573 __isl_keep isl_restriction *restr);
574 isl_ctx *isl_union_access_info_get_ctx(
575 __isl_keep isl_union_access_info *access);
576 isl_ctx *isl_union_flow_get_ctx(
577 __isl_keep isl_union_flow *flow);
579 #include <isl/schedule.h>
580 isl_ctx *isl_schedule_get_ctx(
581 __isl_keep isl_schedule *sched);
582 isl_ctx *isl_schedule_constraints_get_ctx(
583 __isl_keep isl_schedule_constraints *sc);
585 #include <isl/schedule_node.h>
586 isl_ctx *isl_schedule_node_get_ctx(
587 __isl_keep isl_schedule_node *node);
589 #include <isl/band.h>
590 isl_ctx *isl_band_get_ctx(__isl_keep isl_band *band);
592 #include <isl/ast_build.h>
593 isl_ctx *isl_ast_build_get_ctx(
594 __isl_keep isl_ast_build *build);
597 isl_ctx *isl_ast_expr_get_ctx(
598 __isl_keep isl_ast_expr *expr);
599 isl_ctx *isl_ast_node_get_ctx(
600 __isl_keep isl_ast_node *node);
604 C<isl> uses two special return types for functions that either return
605 a boolean or that in principle do not return anything.
606 In particular, the C<isl_bool> type has three possible values:
607 C<isl_bool_true> (a positive integer value), indicating I<true> or I<yes>;
608 C<isl_bool_false> (the integer value zero), indicating I<false> or I<no>; and
609 C<isl_bool_error> (a negative integer value), indicating that something
610 went wrong. The following function can be used to negate an C<isl_bool>,
611 where the negation of C<isl_bool_error> is C<isl_bool_error> again.
614 isl_bool isl_bool_not(isl_bool b);
616 The C<isl_stat> type has two possible values:
617 C<isl_stat_ok> (the integer value zero), indicating a successful
619 C<isl_stat_error> (a negative integer value), indicating that something
621 See L</"Error Handling"> for more information on
622 C<isl_bool_error> and C<isl_stat_error>.
626 An C<isl_val> represents an integer value, a rational value
627 or one of three special values, infinity, negative infinity and NaN.
628 Some predefined values can be created using the following functions.
631 __isl_give isl_val *isl_val_zero(isl_ctx *ctx);
632 __isl_give isl_val *isl_val_one(isl_ctx *ctx);
633 __isl_give isl_val *isl_val_negone(isl_ctx *ctx);
634 __isl_give isl_val *isl_val_nan(isl_ctx *ctx);
635 __isl_give isl_val *isl_val_infty(isl_ctx *ctx);
636 __isl_give isl_val *isl_val_neginfty(isl_ctx *ctx);
638 Specific integer values can be created using the following functions.
641 __isl_give isl_val *isl_val_int_from_si(isl_ctx *ctx,
643 __isl_give isl_val *isl_val_int_from_ui(isl_ctx *ctx,
645 __isl_give isl_val *isl_val_int_from_chunks(isl_ctx *ctx,
646 size_t n, size_t size, const void *chunks);
648 The function C<isl_val_int_from_chunks> constructs an C<isl_val>
649 from the C<n> I<digits>, each consisting of C<size> bytes, stored at C<chunks>.
650 The least significant digit is assumed to be stored first.
652 Value objects can be copied and freed using the following functions.
655 __isl_give isl_val *isl_val_copy(__isl_keep isl_val *v);
656 __isl_null isl_val *isl_val_free(__isl_take isl_val *v);
658 They can be inspected using the following functions.
661 long isl_val_get_num_si(__isl_keep isl_val *v);
662 long isl_val_get_den_si(__isl_keep isl_val *v);
663 __isl_give isl_val *isl_val_get_den_val(
664 __isl_keep isl_val *v);
665 double isl_val_get_d(__isl_keep isl_val *v);
666 size_t isl_val_n_abs_num_chunks(__isl_keep isl_val *v,
668 int isl_val_get_abs_num_chunks(__isl_keep isl_val *v,
669 size_t size, void *chunks);
671 C<isl_val_n_abs_num_chunks> returns the number of I<digits>
672 of C<size> bytes needed to store the absolute value of the
674 C<isl_val_get_abs_num_chunks> stores these digits at C<chunks>,
675 which is assumed to have been preallocated by the caller.
676 The least significant digit is stored first.
677 Note that C<isl_val_get_num_si>, C<isl_val_get_den_si>,
678 C<isl_val_get_d>, C<isl_val_n_abs_num_chunks>
679 and C<isl_val_get_abs_num_chunks> can only be applied to rational values.
681 An C<isl_val> can be modified using the following function.
684 __isl_give isl_val *isl_val_set_si(__isl_take isl_val *v,
687 The following unary properties are defined on C<isl_val>s.
690 int isl_val_sgn(__isl_keep isl_val *v);
691 isl_bool isl_val_is_zero(__isl_keep isl_val *v);
692 isl_bool isl_val_is_one(__isl_keep isl_val *v);
693 isl_bool isl_val_is_negone(__isl_keep isl_val *v);
694 isl_bool isl_val_is_nonneg(__isl_keep isl_val *v);
695 isl_bool isl_val_is_nonpos(__isl_keep isl_val *v);
696 isl_bool isl_val_is_pos(__isl_keep isl_val *v);
697 isl_bool isl_val_is_neg(__isl_keep isl_val *v);
698 isl_bool isl_val_is_int(__isl_keep isl_val *v);
699 isl_bool isl_val_is_rat(__isl_keep isl_val *v);
700 isl_bool isl_val_is_nan(__isl_keep isl_val *v);
701 isl_bool isl_val_is_infty(__isl_keep isl_val *v);
702 isl_bool isl_val_is_neginfty(__isl_keep isl_val *v);
704 Note that the sign of NaN is undefined.
706 The following binary properties are defined on pairs of C<isl_val>s.
709 isl_bool isl_val_lt(__isl_keep isl_val *v1,
710 __isl_keep isl_val *v2);
711 isl_bool isl_val_le(__isl_keep isl_val *v1,
712 __isl_keep isl_val *v2);
713 isl_bool isl_val_gt(__isl_keep isl_val *v1,
714 __isl_keep isl_val *v2);
715 isl_bool isl_val_ge(__isl_keep isl_val *v1,
716 __isl_keep isl_val *v2);
717 isl_bool isl_val_eq(__isl_keep isl_val *v1,
718 __isl_keep isl_val *v2);
719 isl_bool isl_val_ne(__isl_keep isl_val *v1,
720 __isl_keep isl_val *v2);
721 isl_bool isl_val_abs_eq(__isl_keep isl_val *v1,
722 __isl_keep isl_val *v2);
724 The function C<isl_val_abs_eq> checks whether its two arguments
725 are equal in absolute value.
727 For integer C<isl_val>s we additionally have the following binary property.
730 isl_bool isl_val_is_divisible_by(__isl_keep isl_val *v1,
731 __isl_keep isl_val *v2);
733 An C<isl_val> can also be compared to an integer using the following
734 function. The result is undefined for NaN.
737 int isl_val_cmp_si(__isl_keep isl_val *v, long i);
739 The following unary operations are available on C<isl_val>s.
742 __isl_give isl_val *isl_val_abs(__isl_take isl_val *v);
743 __isl_give isl_val *isl_val_neg(__isl_take isl_val *v);
744 __isl_give isl_val *isl_val_floor(__isl_take isl_val *v);
745 __isl_give isl_val *isl_val_ceil(__isl_take isl_val *v);
746 __isl_give isl_val *isl_val_trunc(__isl_take isl_val *v);
747 __isl_give isl_val *isl_val_inv(__isl_take isl_val *v);
748 __isl_give isl_val *isl_val_2exp(__isl_take isl_val *v);
750 The following binary operations are available on C<isl_val>s.
753 __isl_give isl_val *isl_val_min(__isl_take isl_val *v1,
754 __isl_take isl_val *v2);
755 __isl_give isl_val *isl_val_max(__isl_take isl_val *v1,
756 __isl_take isl_val *v2);
757 __isl_give isl_val *isl_val_add(__isl_take isl_val *v1,
758 __isl_take isl_val *v2);
759 __isl_give isl_val *isl_val_add_ui(__isl_take isl_val *v1,
761 __isl_give isl_val *isl_val_sub(__isl_take isl_val *v1,
762 __isl_take isl_val *v2);
763 __isl_give isl_val *isl_val_sub_ui(__isl_take isl_val *v1,
765 __isl_give isl_val *isl_val_mul(__isl_take isl_val *v1,
766 __isl_take isl_val *v2);
767 __isl_give isl_val *isl_val_mul_ui(__isl_take isl_val *v1,
769 __isl_give isl_val *isl_val_div(__isl_take isl_val *v1,
770 __isl_take isl_val *v2);
772 On integer values, we additionally have the following operations.
775 __isl_give isl_val *isl_val_2exp(__isl_take isl_val *v);
776 __isl_give isl_val *isl_val_mod(__isl_take isl_val *v1,
777 __isl_take isl_val *v2);
778 __isl_give isl_val *isl_val_gcd(__isl_take isl_val *v1,
779 __isl_take isl_val *v2);
780 __isl_give isl_val *isl_val_gcdext(__isl_take isl_val *v1,
781 __isl_take isl_val *v2, __isl_give isl_val **x,
782 __isl_give isl_val **y);
784 The function C<isl_val_gcdext> returns the greatest common divisor g
785 of C<v1> and C<v2> as well as two integers C<*x> and C<*y> such
786 that C<*x> * C<v1> + C<*y> * C<v2> = g.
788 =head3 GMP specific functions
790 These functions are only available if C<isl> has been compiled with C<GMP>
793 Specific integer and rational values can be created from C<GMP> values using
794 the following functions.
796 #include <isl/val_gmp.h>
797 __isl_give isl_val *isl_val_int_from_gmp(isl_ctx *ctx,
799 __isl_give isl_val *isl_val_from_gmp(isl_ctx *ctx,
800 const mpz_t n, const mpz_t d);
802 The numerator and denominator of a rational value can be extracted as
803 C<GMP> values using the following functions.
805 #include <isl/val_gmp.h>
806 int isl_val_get_num_gmp(__isl_keep isl_val *v, mpz_t z);
807 int isl_val_get_den_gmp(__isl_keep isl_val *v, mpz_t z);
809 =head2 Sets and Relations
811 C<isl> uses six types of objects for representing sets and relations,
812 C<isl_basic_set>, C<isl_basic_map>, C<isl_set>, C<isl_map>,
813 C<isl_union_set> and C<isl_union_map>.
814 C<isl_basic_set> and C<isl_basic_map> represent sets and relations that
815 can be described as a conjunction of affine constraints, while
816 C<isl_set> and C<isl_map> represent unions of
817 C<isl_basic_set>s and C<isl_basic_map>s, respectively.
818 However, all C<isl_basic_set>s or C<isl_basic_map>s in the union need
819 to live in the same space. C<isl_union_set>s and C<isl_union_map>s
820 represent unions of C<isl_set>s or C<isl_map>s in I<different> spaces,
821 where spaces are considered different if they have a different number
822 of dimensions and/or different names (see L<"Spaces">).
823 The difference between sets and relations (maps) is that sets have
824 one set of variables, while relations have two sets of variables,
825 input variables and output variables.
827 =head2 Error Handling
829 C<isl> supports different ways to react in case a runtime error is triggered.
830 Runtime errors arise, e.g., if a function such as C<isl_map_intersect> is called
831 with two maps that have incompatible spaces. There are three possible ways
832 to react on error: to warn, to continue or to abort.
834 The default behavior is to warn. In this mode, C<isl> prints a warning, stores
835 the last error in the corresponding C<isl_ctx> and the function in which the
836 error was triggered returns a value indicating that some error has
837 occurred. In case of functions returning a pointer, this value is
838 C<NULL>. In case of functions returning an C<isl_bool> or an
839 C<isl_stat>, this valus is C<isl_bool_error> or C<isl_stat_error>.
840 An error does not corrupt internal state,
841 such that isl can continue to be used. C<isl> also provides functions to
842 read the last error and to reset the memory that stores the last error. The
843 last error is only stored for information purposes. Its presence does not
844 change the behavior of C<isl>. Hence, resetting an error is not required to
845 continue to use isl, but only to observe new errors.
848 enum isl_error isl_ctx_last_error(isl_ctx *ctx);
849 void isl_ctx_reset_error(isl_ctx *ctx);
851 Another option is to continue on error. This is similar to warn on error mode,
852 except that C<isl> does not print any warning. This allows a program to
853 implement its own error reporting.
855 The last option is to directly abort the execution of the program from within
856 the isl library. This makes it obviously impossible to recover from an error,
857 but it allows to directly spot the error location. By aborting on error,
858 debuggers break at the location the error occurred and can provide a stack
859 trace. Other tools that automatically provide stack traces on abort or that do
860 not want to continue execution after an error was triggered may also prefer to
863 The on error behavior of isl can be specified by calling
864 C<isl_options_set_on_error> or by setting the command line option
865 C<--isl-on-error>. Valid arguments for the function call are
866 C<ISL_ON_ERROR_WARN>, C<ISL_ON_ERROR_CONTINUE> and C<ISL_ON_ERROR_ABORT>. The
867 choices for the command line option are C<warn>, C<continue> and C<abort>.
868 It is also possible to query the current error mode.
870 #include <isl/options.h>
871 isl_stat isl_options_set_on_error(isl_ctx *ctx, int val);
872 int isl_options_get_on_error(isl_ctx *ctx);
876 Identifiers are used to identify both individual dimensions
877 and tuples of dimensions. They consist of an optional name and an optional
878 user pointer. The name and the user pointer cannot both be C<NULL>, however.
879 Identifiers with the same name but different pointer values
880 are considered to be distinct.
881 Similarly, identifiers with different names but the same pointer value
882 are also considered to be distinct.
883 Equal identifiers are represented using the same object.
884 Pairs of identifiers can therefore be tested for equality using the
886 Identifiers can be constructed, copied, freed, inspected and printed
887 using the following functions.
890 __isl_give isl_id *isl_id_alloc(isl_ctx *ctx,
891 __isl_keep const char *name, void *user);
892 __isl_give isl_id *isl_id_set_free_user(
893 __isl_take isl_id *id,
894 void (*free_user)(void *user));
895 __isl_give isl_id *isl_id_copy(isl_id *id);
896 __isl_null isl_id *isl_id_free(__isl_take isl_id *id);
898 void *isl_id_get_user(__isl_keep isl_id *id);
899 __isl_keep const char *isl_id_get_name(__isl_keep isl_id *id);
901 __isl_give isl_printer *isl_printer_print_id(
902 __isl_take isl_printer *p, __isl_keep isl_id *id);
904 The callback set by C<isl_id_set_free_user> is called on the user
905 pointer when the last reference to the C<isl_id> is freed.
906 Note that C<isl_id_get_name> returns a pointer to some internal
907 data structure, so the result can only be used while the
908 corresponding C<isl_id> is alive.
912 Whenever a new set, relation or similar object is created from scratch,
913 the space in which it lives needs to be specified using an C<isl_space>.
914 Each space involves zero or more parameters and zero, one or two
915 tuples of set or input/output dimensions. The parameters and dimensions
916 are identified by an C<isl_dim_type> and a position.
917 The type C<isl_dim_param> refers to parameters,
918 the type C<isl_dim_set> refers to set dimensions (for spaces
919 with a single tuple of dimensions) and the types C<isl_dim_in>
920 and C<isl_dim_out> refer to input and output dimensions
921 (for spaces with two tuples of dimensions).
922 Local spaces (see L</"Local Spaces">) also contain dimensions
923 of type C<isl_dim_div>.
924 Note that parameters are only identified by their position within
925 a given object. Across different objects, parameters are (usually)
926 identified by their names or identifiers. Only unnamed parameters
927 are identified by their positions across objects. The use of unnamed
928 parameters is discouraged.
930 #include <isl/space.h>
931 __isl_give isl_space *isl_space_alloc(isl_ctx *ctx,
932 unsigned nparam, unsigned n_in, unsigned n_out);
933 __isl_give isl_space *isl_space_params_alloc(isl_ctx *ctx,
935 __isl_give isl_space *isl_space_set_alloc(isl_ctx *ctx,
936 unsigned nparam, unsigned dim);
937 __isl_give isl_space *isl_space_copy(__isl_keep isl_space *space);
938 __isl_null isl_space *isl_space_free(__isl_take isl_space *space);
940 The space used for creating a parameter domain
941 needs to be created using C<isl_space_params_alloc>.
942 For other sets, the space
943 needs to be created using C<isl_space_set_alloc>, while
944 for a relation, the space
945 needs to be created using C<isl_space_alloc>.
947 To check whether a given space is that of a set or a map
948 or whether it is a parameter space, use these functions:
950 #include <isl/space.h>
951 isl_bool isl_space_is_params(__isl_keep isl_space *space);
952 isl_bool isl_space_is_set(__isl_keep isl_space *space);
953 isl_bool isl_space_is_map(__isl_keep isl_space *space);
955 Spaces can be compared using the following functions:
957 #include <isl/space.h>
958 isl_bool isl_space_is_equal(__isl_keep isl_space *space1,
959 __isl_keep isl_space *space2);
960 isl_bool isl_space_has_equal_params(
961 __isl_keep isl_space *space1,
962 __isl_keep isl_space *space2);
963 isl_bool isl_space_has_equal_tuples(
964 __isl_keep isl_space *space1,
965 __isl_keep isl_space *space2);
966 isl_bool isl_space_is_domain(__isl_keep isl_space *space1,
967 __isl_keep isl_space *space2);
968 isl_bool isl_space_is_range(__isl_keep isl_space *space1,
969 __isl_keep isl_space *space2);
970 isl_bool isl_space_tuple_is_equal(
971 __isl_keep isl_space *space1,
972 enum isl_dim_type type1,
973 __isl_keep isl_space *space2,
974 enum isl_dim_type type2);
976 C<isl_space_is_domain> checks whether the first argument is equal
977 to the domain of the second argument. This requires in particular that
978 the first argument is a set space and that the second argument
979 is a map space. C<isl_space_tuple_is_equal> checks whether the given
980 tuples (C<isl_dim_in>, C<isl_dim_out> or C<isl_dim_set>) of the given
981 spaces are the same. That is, it checks if they have the same
982 identifier (if any), the same dimension and the same internal structure
985 C<isl_space_has_equal_params> checks whether two spaces
986 have the same parameters in the same order.
987 C<isl_space_has_equal_tuples> check whether two spaces have
988 the same tuples. In contrast to C<isl_space_is_equal> below,
989 it does not check the
990 parameters. This is useful because many C<isl> functions align the
991 parameters before they perform their operations, such that equivalence
993 C<isl_space_is_equal> checks whether two spaces are identical,
994 meaning that they have the same parameters and the same tuples.
995 That is, it checks whether both C<isl_space_has_equal_params> and
996 C<isl_space_has_equal_tuples> hold.
998 It is often useful to create objects that live in the
999 same space as some other object. This can be accomplished
1000 by creating the new objects
1001 (see L</"Creating New Sets and Relations"> or
1002 L</"Functions">) based on the space
1003 of the original object.
1005 #include <isl/set.h>
1006 __isl_give isl_space *isl_basic_set_get_space(
1007 __isl_keep isl_basic_set *bset);
1008 __isl_give isl_space *isl_set_get_space(__isl_keep isl_set *set);
1010 #include <isl/union_set.h>
1011 __isl_give isl_space *isl_union_set_get_space(
1012 __isl_keep isl_union_set *uset);
1014 #include <isl/map.h>
1015 __isl_give isl_space *isl_basic_map_get_space(
1016 __isl_keep isl_basic_map *bmap);
1017 __isl_give isl_space *isl_map_get_space(__isl_keep isl_map *map);
1019 #include <isl/union_map.h>
1020 __isl_give isl_space *isl_union_map_get_space(
1021 __isl_keep isl_union_map *umap);
1023 #include <isl/constraint.h>
1024 __isl_give isl_space *isl_constraint_get_space(
1025 __isl_keep isl_constraint *constraint);
1027 #include <isl/polynomial.h>
1028 __isl_give isl_space *isl_qpolynomial_get_domain_space(
1029 __isl_keep isl_qpolynomial *qp);
1030 __isl_give isl_space *isl_qpolynomial_get_space(
1031 __isl_keep isl_qpolynomial *qp);
1032 __isl_give isl_space *
1033 isl_qpolynomial_fold_get_domain_space(
1034 __isl_keep isl_qpolynomial_fold *fold);
1035 __isl_give isl_space *isl_qpolynomial_fold_get_space(
1036 __isl_keep isl_qpolynomial_fold *fold);
1037 __isl_give isl_space *isl_pw_qpolynomial_get_domain_space(
1038 __isl_keep isl_pw_qpolynomial *pwqp);
1039 __isl_give isl_space *isl_pw_qpolynomial_get_space(
1040 __isl_keep isl_pw_qpolynomial *pwqp);
1041 __isl_give isl_space *isl_pw_qpolynomial_fold_get_domain_space(
1042 __isl_keep isl_pw_qpolynomial_fold *pwf);
1043 __isl_give isl_space *isl_pw_qpolynomial_fold_get_space(
1044 __isl_keep isl_pw_qpolynomial_fold *pwf);
1045 __isl_give isl_space *isl_union_pw_qpolynomial_get_space(
1046 __isl_keep isl_union_pw_qpolynomial *upwqp);
1047 __isl_give isl_space *isl_union_pw_qpolynomial_fold_get_space(
1048 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
1050 #include <isl/val.h>
1051 __isl_give isl_space *isl_multi_val_get_space(
1052 __isl_keep isl_multi_val *mv);
1054 #include <isl/aff.h>
1055 __isl_give isl_space *isl_aff_get_domain_space(
1056 __isl_keep isl_aff *aff);
1057 __isl_give isl_space *isl_aff_get_space(
1058 __isl_keep isl_aff *aff);
1059 __isl_give isl_space *isl_pw_aff_get_domain_space(
1060 __isl_keep isl_pw_aff *pwaff);
1061 __isl_give isl_space *isl_pw_aff_get_space(
1062 __isl_keep isl_pw_aff *pwaff);
1063 __isl_give isl_space *isl_multi_aff_get_domain_space(
1064 __isl_keep isl_multi_aff *maff);
1065 __isl_give isl_space *isl_multi_aff_get_space(
1066 __isl_keep isl_multi_aff *maff);
1067 __isl_give isl_space *isl_pw_multi_aff_get_domain_space(
1068 __isl_keep isl_pw_multi_aff *pma);
1069 __isl_give isl_space *isl_pw_multi_aff_get_space(
1070 __isl_keep isl_pw_multi_aff *pma);
1071 __isl_give isl_space *isl_union_pw_aff_get_space(
1072 __isl_keep isl_union_pw_aff *upa);
1073 __isl_give isl_space *isl_union_pw_multi_aff_get_space(
1074 __isl_keep isl_union_pw_multi_aff *upma);
1075 __isl_give isl_space *isl_multi_pw_aff_get_domain_space(
1076 __isl_keep isl_multi_pw_aff *mpa);
1077 __isl_give isl_space *isl_multi_pw_aff_get_space(
1078 __isl_keep isl_multi_pw_aff *mpa);
1079 __isl_give isl_space *
1080 isl_multi_union_pw_aff_get_domain_space(
1081 __isl_keep isl_multi_union_pw_aff *mupa);
1082 __isl_give isl_space *
1083 isl_multi_union_pw_aff_get_space(
1084 __isl_keep isl_multi_union_pw_aff *mupa);
1086 #include <isl/point.h>
1087 __isl_give isl_space *isl_point_get_space(
1088 __isl_keep isl_point *pnt);
1090 The number of dimensions of a given type of space
1091 may be read off from a space or an object that lives
1092 in a space using the following functions.
1093 In case of C<isl_space_dim>, type may be
1094 C<isl_dim_param>, C<isl_dim_in> (only for relations),
1095 C<isl_dim_out> (only for relations), C<isl_dim_set>
1096 (only for sets) or C<isl_dim_all>.
1098 #include <isl/space.h>
1099 unsigned isl_space_dim(__isl_keep isl_space *space,
1100 enum isl_dim_type type);
1102 #include <isl/local_space.h>
1103 int isl_local_space_dim(__isl_keep isl_local_space *ls,
1104 enum isl_dim_type type);
1106 #include <isl/set.h>
1107 unsigned isl_basic_set_dim(__isl_keep isl_basic_set *bset,
1108 enum isl_dim_type type);
1109 unsigned isl_set_dim(__isl_keep isl_set *set,
1110 enum isl_dim_type type);
1112 #include <isl/union_set.h>
1113 unsigned isl_union_set_dim(__isl_keep isl_union_set *uset,
1114 enum isl_dim_type type);
1116 #include <isl/map.h>
1117 unsigned isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
1118 enum isl_dim_type type);
1119 unsigned isl_map_dim(__isl_keep isl_map *map,
1120 enum isl_dim_type type);
1122 #include <isl/union_map.h>
1123 unsigned isl_union_map_dim(__isl_keep isl_union_map *umap,
1124 enum isl_dim_type type);
1126 #include <isl/val.h>
1127 unsigned isl_multi_val_dim(__isl_keep isl_multi_val *mv,
1128 enum isl_dim_type type);
1130 #include <isl/aff.h>
1131 int isl_aff_dim(__isl_keep isl_aff *aff,
1132 enum isl_dim_type type);
1133 unsigned isl_multi_aff_dim(__isl_keep isl_multi_aff *maff,
1134 enum isl_dim_type type);
1135 unsigned isl_pw_aff_dim(__isl_keep isl_pw_aff *pwaff,
1136 enum isl_dim_type type);
1137 unsigned isl_pw_multi_aff_dim(
1138 __isl_keep isl_pw_multi_aff *pma,
1139 enum isl_dim_type type);
1140 unsigned isl_multi_pw_aff_dim(
1141 __isl_keep isl_multi_pw_aff *mpa,
1142 enum isl_dim_type type);
1143 unsigned isl_union_pw_aff_dim(
1144 __isl_keep isl_union_pw_aff *upa,
1145 enum isl_dim_type type);
1146 unsigned isl_union_pw_multi_aff_dim(
1147 __isl_keep isl_union_pw_multi_aff *upma,
1148 enum isl_dim_type type);
1149 unsigned isl_multi_union_pw_aff_dim(
1150 __isl_keep isl_multi_union_pw_aff *mupa,
1151 enum isl_dim_type type);
1153 #include <isl/polynomial.h>
1154 unsigned isl_union_pw_qpolynomial_dim(
1155 __isl_keep isl_union_pw_qpolynomial *upwqp,
1156 enum isl_dim_type type);
1157 unsigned isl_union_pw_qpolynomial_fold_dim(
1158 __isl_keep isl_union_pw_qpolynomial_fold *upwf,
1159 enum isl_dim_type type);
1161 Note that an C<isl_union_set>, an C<isl_union_map>,
1162 an C<isl_union_pw_multi_aff>,
1163 an C<isl_union_pw_qpolynomial> and
1164 an C<isl_union_pw_qpolynomial_fold>
1165 only have parameters.
1167 The identifiers or names of the individual dimensions of spaces
1168 may be set or read off using the following functions on spaces
1169 or objects that live in spaces.
1170 These functions are mostly useful to obtain the identifiers, positions
1171 or names of the parameters. Identifiers of individual dimensions are
1172 essentially only useful for printing. They are ignored by all other
1173 operations and may not be preserved across those operations.
1175 #include <isl/space.h>
1176 __isl_give isl_space *isl_space_set_dim_id(
1177 __isl_take isl_space *space,
1178 enum isl_dim_type type, unsigned pos,
1179 __isl_take isl_id *id);
1180 isl_bool isl_space_has_dim_id(__isl_keep isl_space *space,
1181 enum isl_dim_type type, unsigned pos);
1182 __isl_give isl_id *isl_space_get_dim_id(
1183 __isl_keep isl_space *space,
1184 enum isl_dim_type type, unsigned pos);
1185 __isl_give isl_space *isl_space_set_dim_name(
1186 __isl_take isl_space *space,
1187 enum isl_dim_type type, unsigned pos,
1188 __isl_keep const char *name);
1189 isl_bool isl_space_has_dim_name(__isl_keep isl_space *space,
1190 enum isl_dim_type type, unsigned pos);
1191 __isl_keep const char *isl_space_get_dim_name(
1192 __isl_keep isl_space *space,
1193 enum isl_dim_type type, unsigned pos);
1195 #include <isl/local_space.h>
1196 __isl_give isl_local_space *isl_local_space_set_dim_id(
1197 __isl_take isl_local_space *ls,
1198 enum isl_dim_type type, unsigned pos,
1199 __isl_take isl_id *id);
1200 isl_bool isl_local_space_has_dim_id(
1201 __isl_keep isl_local_space *ls,
1202 enum isl_dim_type type, unsigned pos);
1203 __isl_give isl_id *isl_local_space_get_dim_id(
1204 __isl_keep isl_local_space *ls,
1205 enum isl_dim_type type, unsigned pos);
1206 __isl_give isl_local_space *isl_local_space_set_dim_name(
1207 __isl_take isl_local_space *ls,
1208 enum isl_dim_type type, unsigned pos, const char *s);
1209 isl_bool isl_local_space_has_dim_name(
1210 __isl_keep isl_local_space *ls,
1211 enum isl_dim_type type, unsigned pos)
1212 const char *isl_local_space_get_dim_name(
1213 __isl_keep isl_local_space *ls,
1214 enum isl_dim_type type, unsigned pos);
1216 #include <isl/constraint.h>
1217 const char *isl_constraint_get_dim_name(
1218 __isl_keep isl_constraint *constraint,
1219 enum isl_dim_type type, unsigned pos);
1221 #include <isl/set.h>
1222 __isl_give isl_id *isl_basic_set_get_dim_id(
1223 __isl_keep isl_basic_set *bset,
1224 enum isl_dim_type type, unsigned pos);
1225 __isl_give isl_set *isl_set_set_dim_id(
1226 __isl_take isl_set *set, enum isl_dim_type type,
1227 unsigned pos, __isl_take isl_id *id);
1228 isl_bool isl_set_has_dim_id(__isl_keep isl_set *set,
1229 enum isl_dim_type type, unsigned pos);
1230 __isl_give isl_id *isl_set_get_dim_id(
1231 __isl_keep isl_set *set, enum isl_dim_type type,
1233 const char *isl_basic_set_get_dim_name(
1234 __isl_keep isl_basic_set *bset,
1235 enum isl_dim_type type, unsigned pos);
1236 isl_bool isl_set_has_dim_name(__isl_keep isl_set *set,
1237 enum isl_dim_type type, unsigned pos);
1238 const char *isl_set_get_dim_name(
1239 __isl_keep isl_set *set,
1240 enum isl_dim_type type, unsigned pos);
1242 #include <isl/map.h>
1243 __isl_give isl_map *isl_map_set_dim_id(
1244 __isl_take isl_map *map, enum isl_dim_type type,
1245 unsigned pos, __isl_take isl_id *id);
1246 isl_bool isl_basic_map_has_dim_id(
1247 __isl_keep isl_basic_map *bmap,
1248 enum isl_dim_type type, unsigned pos);
1249 isl_bool isl_map_has_dim_id(__isl_keep isl_map *map,
1250 enum isl_dim_type type, unsigned pos);
1251 __isl_give isl_id *isl_map_get_dim_id(
1252 __isl_keep isl_map *map, enum isl_dim_type type,
1254 __isl_give isl_id *isl_union_map_get_dim_id(
1255 __isl_keep isl_union_map *umap,
1256 enum isl_dim_type type, unsigned pos);
1257 const char *isl_basic_map_get_dim_name(
1258 __isl_keep isl_basic_map *bmap,
1259 enum isl_dim_type type, unsigned pos);
1260 isl_bool isl_map_has_dim_name(__isl_keep isl_map *map,
1261 enum isl_dim_type type, unsigned pos);
1262 const char *isl_map_get_dim_name(
1263 __isl_keep isl_map *map,
1264 enum isl_dim_type type, unsigned pos);
1266 #include <isl/val.h>
1267 __isl_give isl_multi_val *isl_multi_val_set_dim_id(
1268 __isl_take isl_multi_val *mv,
1269 enum isl_dim_type type, unsigned pos,
1270 __isl_take isl_id *id);
1271 __isl_give isl_id *isl_multi_val_get_dim_id(
1272 __isl_keep isl_multi_val *mv,
1273 enum isl_dim_type type, unsigned pos);
1274 __isl_give isl_multi_val *isl_multi_val_set_dim_name(
1275 __isl_take isl_multi_val *mv,
1276 enum isl_dim_type type, unsigned pos, const char *s);
1278 #include <isl/aff.h>
1279 __isl_give isl_aff *isl_aff_set_dim_id(
1280 __isl_take isl_aff *aff, enum isl_dim_type type,
1281 unsigned pos, __isl_take isl_id *id);
1282 __isl_give isl_multi_aff *isl_multi_aff_set_dim_id(
1283 __isl_take isl_multi_aff *maff,
1284 enum isl_dim_type type, unsigned pos,
1285 __isl_take isl_id *id);
1286 __isl_give isl_pw_aff *isl_pw_aff_set_dim_id(
1287 __isl_take isl_pw_aff *pma,
1288 enum isl_dim_type type, unsigned pos,
1289 __isl_take isl_id *id);
1290 __isl_give isl_multi_pw_aff *
1291 isl_multi_pw_aff_set_dim_id(
1292 __isl_take isl_multi_pw_aff *mpa,
1293 enum isl_dim_type type, unsigned pos,
1294 __isl_take isl_id *id);
1295 __isl_give isl_multi_union_pw_aff *
1296 isl_multi_union_pw_aff_set_dim_id(
1297 __isl_take isl_multi_union_pw_aff *mupa,
1298 enum isl_dim_type type, unsigned pos,
1299 __isl_take isl_id *id);
1300 __isl_give isl_id *isl_multi_aff_get_dim_id(
1301 __isl_keep isl_multi_aff *ma,
1302 enum isl_dim_type type, unsigned pos);
1303 isl_bool isl_pw_aff_has_dim_id(__isl_keep isl_pw_aff *pa,
1304 enum isl_dim_type type, unsigned pos);
1305 __isl_give isl_id *isl_pw_aff_get_dim_id(
1306 __isl_keep isl_pw_aff *pa,
1307 enum isl_dim_type type, unsigned pos);
1308 __isl_give isl_id *isl_pw_multi_aff_get_dim_id(
1309 __isl_keep isl_pw_multi_aff *pma,
1310 enum isl_dim_type type, unsigned pos);
1311 __isl_give isl_id *isl_multi_pw_aff_get_dim_id(
1312 __isl_keep isl_multi_pw_aff *mpa,
1313 enum isl_dim_type type, unsigned pos);
1314 __isl_give isl_id *isl_multi_union_pw_aff_get_dim_id(
1315 __isl_keep isl_multi_union_pw_aff *mupa,
1316 enum isl_dim_type type, unsigned pos);
1317 __isl_give isl_aff *isl_aff_set_dim_name(
1318 __isl_take isl_aff *aff, enum isl_dim_type type,
1319 unsigned pos, const char *s);
1320 __isl_give isl_multi_aff *isl_multi_aff_set_dim_name(
1321 __isl_take isl_multi_aff *maff,
1322 enum isl_dim_type type, unsigned pos, const char *s);
1323 __isl_give isl_multi_pw_aff *
1324 isl_multi_pw_aff_set_dim_name(
1325 __isl_take isl_multi_pw_aff *mpa,
1326 enum isl_dim_type type, unsigned pos, const char *s);
1327 __isl_give isl_union_pw_aff *
1328 isl_union_pw_aff_set_dim_name(
1329 __isl_take isl_union_pw_aff *upa,
1330 enum isl_dim_type type, unsigned pos,
1332 __isl_give isl_union_pw_multi_aff *
1333 isl_union_pw_multi_aff_set_dim_name(
1334 __isl_take isl_union_pw_multi_aff *upma,
1335 enum isl_dim_type type, unsigned pos,
1337 __isl_give isl_multi_union_pw_aff *
1338 isl_multi_union_pw_aff_set_dim_name(
1339 __isl_take isl_multi_union_pw_aff *mupa,
1340 enum isl_dim_type type, unsigned pos,
1341 const char *isl_aff_get_dim_name(__isl_keep isl_aff *aff,
1342 enum isl_dim_type type, unsigned pos);
1343 const char *isl_pw_aff_get_dim_name(
1344 __isl_keep isl_pw_aff *pa,
1345 enum isl_dim_type type, unsigned pos);
1346 const char *isl_pw_multi_aff_get_dim_name(
1347 __isl_keep isl_pw_multi_aff *pma,
1348 enum isl_dim_type type, unsigned pos);
1350 #include <isl/polynomial.h>
1351 __isl_give isl_qpolynomial *isl_qpolynomial_set_dim_name(
1352 __isl_take isl_qpolynomial *qp,
1353 enum isl_dim_type type, unsigned pos,
1355 __isl_give isl_pw_qpolynomial *
1356 isl_pw_qpolynomial_set_dim_name(
1357 __isl_take isl_pw_qpolynomial *pwqp,
1358 enum isl_dim_type type, unsigned pos,
1360 __isl_give isl_pw_qpolynomial_fold *
1361 isl_pw_qpolynomial_fold_set_dim_name(
1362 __isl_take isl_pw_qpolynomial_fold *pwf,
1363 enum isl_dim_type type, unsigned pos,
1365 __isl_give isl_union_pw_qpolynomial *
1366 isl_union_pw_qpolynomial_set_dim_name(
1367 __isl_take isl_union_pw_qpolynomial *upwqp,
1368 enum isl_dim_type type, unsigned pos,
1370 __isl_give isl_union_pw_qpolynomial_fold *
1371 isl_union_pw_qpolynomial_fold_set_dim_name(
1372 __isl_take isl_union_pw_qpolynomial_fold *upwf,
1373 enum isl_dim_type type, unsigned pos,
1376 Note that C<isl_space_get_name> returns a pointer to some internal
1377 data structure, so the result can only be used while the
1378 corresponding C<isl_space> is alive.
1379 Also note that every function that operates on two sets or relations
1380 requires that both arguments have the same parameters. This also
1381 means that if one of the arguments has named parameters, then the
1382 other needs to have named parameters too and the names need to match.
1383 Pairs of C<isl_set>, C<isl_map>, C<isl_union_set> and/or C<isl_union_map>
1384 arguments may have different parameters (as long as they are named),
1385 in which case the result will have as parameters the union of the parameters of
1388 Given the identifier or name of a dimension (typically a parameter),
1389 its position can be obtained from the following functions.
1391 #include <isl/space.h>
1392 int isl_space_find_dim_by_id(__isl_keep isl_space *space,
1393 enum isl_dim_type type, __isl_keep isl_id *id);
1394 int isl_space_find_dim_by_name(__isl_keep isl_space *space,
1395 enum isl_dim_type type, const char *name);
1397 #include <isl/local_space.h>
1398 int isl_local_space_find_dim_by_name(
1399 __isl_keep isl_local_space *ls,
1400 enum isl_dim_type type, const char *name);
1402 #include <isl/val.h>
1403 int isl_multi_val_find_dim_by_id(
1404 __isl_keep isl_multi_val *mv,
1405 enum isl_dim_type type, __isl_keep isl_id *id);
1406 int isl_multi_val_find_dim_by_name(
1407 __isl_keep isl_multi_val *mv,
1408 enum isl_dim_type type, const char *name);
1410 #include <isl/set.h>
1411 int isl_set_find_dim_by_id(__isl_keep isl_set *set,
1412 enum isl_dim_type type, __isl_keep isl_id *id);
1413 int isl_set_find_dim_by_name(__isl_keep isl_set *set,
1414 enum isl_dim_type type, const char *name);
1416 #include <isl/map.h>
1417 int isl_map_find_dim_by_id(__isl_keep isl_map *map,
1418 enum isl_dim_type type, __isl_keep isl_id *id);
1419 int isl_basic_map_find_dim_by_name(
1420 __isl_keep isl_basic_map *bmap,
1421 enum isl_dim_type type, const char *name);
1422 int isl_map_find_dim_by_name(__isl_keep isl_map *map,
1423 enum isl_dim_type type, const char *name);
1424 int isl_union_map_find_dim_by_name(
1425 __isl_keep isl_union_map *umap,
1426 enum isl_dim_type type, const char *name);
1428 #include <isl/aff.h>
1429 int isl_multi_aff_find_dim_by_id(
1430 __isl_keep isl_multi_aff *ma,
1431 enum isl_dim_type type, __isl_keep isl_id *id);
1432 int isl_multi_pw_aff_find_dim_by_id(
1433 __isl_keep isl_multi_pw_aff *mpa,
1434 enum isl_dim_type type, __isl_keep isl_id *id);
1435 int isl_multi_union_pw_aff_find_dim_by_id(
1436 __isl_keep isl_union_multi_pw_aff *mupa,
1437 enum isl_dim_type type, __isl_keep isl_id *id);
1438 int isl_aff_find_dim_by_name(__isl_keep isl_aff *aff,
1439 enum isl_dim_type type, const char *name);
1440 int isl_multi_aff_find_dim_by_name(
1441 __isl_keep isl_multi_aff *ma,
1442 enum isl_dim_type type, const char *name);
1443 int isl_pw_aff_find_dim_by_name(__isl_keep isl_pw_aff *pa,
1444 enum isl_dim_type type, const char *name);
1445 int isl_multi_pw_aff_find_dim_by_name(
1446 __isl_keep isl_multi_pw_aff *mpa,
1447 enum isl_dim_type type, const char *name);
1448 int isl_pw_multi_aff_find_dim_by_name(
1449 __isl_keep isl_pw_multi_aff *pma,
1450 enum isl_dim_type type, const char *name);
1451 int isl_union_pw_aff_find_dim_by_name(
1452 __isl_keep isl_union_pw_aff *upa,
1453 enum isl_dim_type type, const char *name);
1454 int isl_union_pw_multi_aff_find_dim_by_name(
1455 __isl_keep isl_union_pw_multi_aff *upma,
1456 enum isl_dim_type type, const char *name);
1457 int isl_multi_union_pw_aff_find_dim_by_name(
1458 __isl_keep isl_multi_union_pw_aff *mupa,
1459 enum isl_dim_type type, const char *name);
1461 #include <isl/polynomial.h>
1462 int isl_pw_qpolynomial_find_dim_by_name(
1463 __isl_keep isl_pw_qpolynomial *pwqp,
1464 enum isl_dim_type type, const char *name);
1465 int isl_pw_qpolynomial_fold_find_dim_by_name(
1466 __isl_keep isl_pw_qpolynomial_fold *pwf,
1467 enum isl_dim_type type, const char *name);
1468 int isl_union_pw_qpolynomial_find_dim_by_name(
1469 __isl_keep isl_union_pw_qpolynomial *upwqp,
1470 enum isl_dim_type type, const char *name);
1471 int isl_union_pw_qpolynomial_fold_find_dim_by_name(
1472 __isl_keep isl_union_pw_qpolynomial_fold *upwf,
1473 enum isl_dim_type type, const char *name);
1475 The identifiers or names of entire spaces may be set or read off
1476 using the following functions.
1478 #include <isl/space.h>
1479 __isl_give isl_space *isl_space_set_tuple_id(
1480 __isl_take isl_space *space,
1481 enum isl_dim_type type, __isl_take isl_id *id);
1482 __isl_give isl_space *isl_space_reset_tuple_id(
1483 __isl_take isl_space *space, enum isl_dim_type type);
1484 isl_bool isl_space_has_tuple_id(
1485 __isl_keep isl_space *space,
1486 enum isl_dim_type type);
1487 __isl_give isl_id *isl_space_get_tuple_id(
1488 __isl_keep isl_space *space, enum isl_dim_type type);
1489 __isl_give isl_space *isl_space_set_tuple_name(
1490 __isl_take isl_space *space,
1491 enum isl_dim_type type, const char *s);
1492 isl_bool isl_space_has_tuple_name(
1493 __isl_keep isl_space *space,
1494 enum isl_dim_type type);
1495 __isl_keep const char *isl_space_get_tuple_name(
1496 __isl_keep isl_space *space,
1497 enum isl_dim_type type);
1499 #include <isl/local_space.h>
1500 __isl_give isl_local_space *isl_local_space_set_tuple_id(
1501 __isl_take isl_local_space *ls,
1502 enum isl_dim_type type, __isl_take isl_id *id);
1504 #include <isl/set.h>
1505 __isl_give isl_basic_set *isl_basic_set_set_tuple_id(
1506 __isl_take isl_basic_set *bset,
1507 __isl_take isl_id *id);
1508 __isl_give isl_set *isl_set_set_tuple_id(
1509 __isl_take isl_set *set, __isl_take isl_id *id);
1510 __isl_give isl_set *isl_set_reset_tuple_id(
1511 __isl_take isl_set *set);
1512 isl_bool isl_set_has_tuple_id(__isl_keep isl_set *set);
1513 __isl_give isl_id *isl_set_get_tuple_id(
1514 __isl_keep isl_set *set);
1515 __isl_give isl_basic_set *isl_basic_set_set_tuple_name(
1516 __isl_take isl_basic_set *set, const char *s);
1517 __isl_give isl_set *isl_set_set_tuple_name(
1518 __isl_take isl_set *set, const char *s);
1519 const char *isl_basic_set_get_tuple_name(
1520 __isl_keep isl_basic_set *bset);
1521 isl_bool isl_set_has_tuple_name(__isl_keep isl_set *set);
1522 const char *isl_set_get_tuple_name(
1523 __isl_keep isl_set *set);
1525 #include <isl/map.h>
1526 __isl_give isl_basic_map *isl_basic_map_set_tuple_id(
1527 __isl_take isl_basic_map *bmap,
1528 enum isl_dim_type type, __isl_take isl_id *id);
1529 __isl_give isl_map *isl_map_set_tuple_id(
1530 __isl_take isl_map *map, enum isl_dim_type type,
1531 __isl_take isl_id *id);
1532 __isl_give isl_map *isl_map_reset_tuple_id(
1533 __isl_take isl_map *map, enum isl_dim_type type);
1534 isl_bool isl_map_has_tuple_id(__isl_keep isl_map *map,
1535 enum isl_dim_type type);
1536 __isl_give isl_id *isl_map_get_tuple_id(
1537 __isl_keep isl_map *map, enum isl_dim_type type);
1538 __isl_give isl_map *isl_map_set_tuple_name(
1539 __isl_take isl_map *map,
1540 enum isl_dim_type type, const char *s);
1541 const char *isl_basic_map_get_tuple_name(
1542 __isl_keep isl_basic_map *bmap,
1543 enum isl_dim_type type);
1544 __isl_give isl_basic_map *isl_basic_map_set_tuple_name(
1545 __isl_take isl_basic_map *bmap,
1546 enum isl_dim_type type, const char *s);
1547 isl_bool isl_map_has_tuple_name(__isl_keep isl_map *map,
1548 enum isl_dim_type type);
1549 const char *isl_map_get_tuple_name(
1550 __isl_keep isl_map *map,
1551 enum isl_dim_type type);
1553 #include <isl/val.h>
1554 __isl_give isl_multi_val *isl_multi_val_set_tuple_id(
1555 __isl_take isl_multi_val *mv,
1556 enum isl_dim_type type, __isl_take isl_id *id);
1557 __isl_give isl_multi_val *isl_multi_val_reset_tuple_id(
1558 __isl_take isl_multi_val *mv,
1559 enum isl_dim_type type);
1560 isl_bool isl_multi_val_has_tuple_id(
1561 __isl_keep isl_multi_val *mv,
1562 enum isl_dim_type type);
1563 __isl_give isl_id *isl_multi_val_get_tuple_id(
1564 __isl_keep isl_multi_val *mv,
1565 enum isl_dim_type type);
1566 __isl_give isl_multi_val *isl_multi_val_set_tuple_name(
1567 __isl_take isl_multi_val *mv,
1568 enum isl_dim_type type, const char *s);
1569 const char *isl_multi_val_get_tuple_name(
1570 __isl_keep isl_multi_val *mv,
1571 enum isl_dim_type type);
1573 #include <isl/aff.h>
1574 __isl_give isl_aff *isl_aff_set_tuple_id(
1575 __isl_take isl_aff *aff,
1576 enum isl_dim_type type, __isl_take isl_id *id);
1577 __isl_give isl_multi_aff *isl_multi_aff_set_tuple_id(
1578 __isl_take isl_multi_aff *maff,
1579 enum isl_dim_type type, __isl_take isl_id *id);
1580 __isl_give isl_pw_aff *isl_pw_aff_set_tuple_id(
1581 __isl_take isl_pw_aff *pwaff,
1582 enum isl_dim_type type, __isl_take isl_id *id);
1583 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_tuple_id(
1584 __isl_take isl_pw_multi_aff *pma,
1585 enum isl_dim_type type, __isl_take isl_id *id);
1586 __isl_give isl_multi_union_pw_aff *
1587 isl_multi_union_pw_aff_set_tuple_id(
1588 __isl_take isl_multi_union_pw_aff *mupa,
1589 enum isl_dim_type type, __isl_take isl_id *id);
1590 __isl_give isl_multi_aff *isl_multi_aff_reset_tuple_id(
1591 __isl_take isl_multi_aff *ma,
1592 enum isl_dim_type type);
1593 __isl_give isl_pw_aff *isl_pw_aff_reset_tuple_id(
1594 __isl_take isl_pw_aff *pa,
1595 enum isl_dim_type type);
1596 __isl_give isl_multi_pw_aff *
1597 isl_multi_pw_aff_reset_tuple_id(
1598 __isl_take isl_multi_pw_aff *mpa,
1599 enum isl_dim_type type);
1600 __isl_give isl_pw_multi_aff *
1601 isl_pw_multi_aff_reset_tuple_id(
1602 __isl_take isl_pw_multi_aff *pma,
1603 enum isl_dim_type type);
1604 __isl_give isl_multi_union_pw_aff *
1605 isl_multi_union_pw_aff_reset_tuple_id(
1606 __isl_take isl_multi_union_pw_aff *mupa,
1607 enum isl_dim_type type);
1608 isl_bool isl_multi_aff_has_tuple_id(
1609 __isl_keep isl_multi_aff *ma,
1610 enum isl_dim_type type);
1611 __isl_give isl_id *isl_multi_aff_get_tuple_id(
1612 __isl_keep isl_multi_aff *ma,
1613 enum isl_dim_type type);
1614 isl_bool isl_pw_aff_has_tuple_id(__isl_keep isl_pw_aff *pa,
1615 enum isl_dim_type type);
1616 __isl_give isl_id *isl_pw_aff_get_tuple_id(
1617 __isl_keep isl_pw_aff *pa,
1618 enum isl_dim_type type);
1619 isl_bool isl_pw_multi_aff_has_tuple_id(
1620 __isl_keep isl_pw_multi_aff *pma,
1621 enum isl_dim_type type);
1622 __isl_give isl_id *isl_pw_multi_aff_get_tuple_id(
1623 __isl_keep isl_pw_multi_aff *pma,
1624 enum isl_dim_type type);
1625 isl_bool isl_multi_pw_aff_has_tuple_id(
1626 __isl_keep isl_multi_pw_aff *mpa,
1627 enum isl_dim_type type);
1628 __isl_give isl_id *isl_multi_pw_aff_get_tuple_id(
1629 __isl_keep isl_multi_pw_aff *mpa,
1630 enum isl_dim_type type);
1631 isl_bool isl_multi_union_pw_aff_has_tuple_id(
1632 __isl_keep isl_multi_union_pw_aff *mupa,
1633 enum isl_dim_type type);
1634 __isl_give isl_id *isl_multi_union_pw_aff_get_tuple_id(
1635 __isl_keep isl_multi_union_pw_aff *mupa,
1636 enum isl_dim_type type);
1637 __isl_give isl_multi_aff *isl_multi_aff_set_tuple_name(
1638 __isl_take isl_multi_aff *maff,
1639 enum isl_dim_type type, const char *s);
1640 __isl_give isl_multi_pw_aff *
1641 isl_multi_pw_aff_set_tuple_name(
1642 __isl_take isl_multi_pw_aff *mpa,
1643 enum isl_dim_type type, const char *s);
1644 __isl_give isl_multi_union_pw_aff *
1645 isl_multi_union_pw_aff_set_tuple_name(
1646 __isl_take isl_multi_union_pw_aff *mupa,
1647 enum isl_dim_type type, const char *s);
1648 const char *isl_multi_aff_get_tuple_name(
1649 __isl_keep isl_multi_aff *multi,
1650 enum isl_dim_type type);
1651 isl_bool isl_pw_multi_aff_has_tuple_name(
1652 __isl_keep isl_pw_multi_aff *pma,
1653 enum isl_dim_type type);
1654 const char *isl_pw_multi_aff_get_tuple_name(
1655 __isl_keep isl_pw_multi_aff *pma,
1656 enum isl_dim_type type);
1657 const char *isl_multi_union_pw_aff_get_tuple_name(
1658 __isl_keep isl_multi_union_pw_aff *mupa,
1659 enum isl_dim_type type);
1661 The C<type> argument needs to be one of C<isl_dim_in>, C<isl_dim_out>
1662 or C<isl_dim_set>. As with C<isl_space_get_name>,
1663 the C<isl_space_get_tuple_name> function returns a pointer to some internal
1665 Binary operations require the corresponding spaces of their arguments
1666 to have the same name.
1668 To keep the names of all parameters and tuples, but reset the user pointers
1669 of all the corresponding identifiers, use the following function.
1671 #include <isl/space.h>
1672 __isl_give isl_space *isl_space_reset_user(
1673 __isl_take isl_space *space);
1675 #include <isl/set.h>
1676 __isl_give isl_set *isl_set_reset_user(
1677 __isl_take isl_set *set);
1679 #include <isl/map.h>
1680 __isl_give isl_map *isl_map_reset_user(
1681 __isl_take isl_map *map);
1683 #include <isl/union_set.h>
1684 __isl_give isl_union_set *isl_union_set_reset_user(
1685 __isl_take isl_union_set *uset);
1687 #include <isl/union_map.h>
1688 __isl_give isl_union_map *isl_union_map_reset_user(
1689 __isl_take isl_union_map *umap);
1691 #include <isl/val.h>
1692 __isl_give isl_multi_val *isl_multi_val_reset_user(
1693 __isl_take isl_multi_val *mv);
1695 #include <isl/aff.h>
1696 __isl_give isl_multi_aff *isl_multi_aff_reset_user(
1697 __isl_take isl_multi_aff *ma);
1698 __isl_give isl_pw_aff *isl_pw_aff_reset_user(
1699 __isl_take isl_pw_aff *pa);
1700 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_reset_user(
1701 __isl_take isl_multi_pw_aff *mpa);
1702 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_reset_user(
1703 __isl_take isl_pw_multi_aff *pma);
1704 __isl_give isl_union_pw_aff *isl_union_pw_aff_reset_user(
1705 __isl_take isl_union_pw_aff *upa);
1706 __isl_give isl_multi_union_pw_aff *
1707 isl_multi_union_pw_aff_reset_user(
1708 __isl_take isl_multi_union_pw_aff *mupa);
1709 __isl_give isl_union_pw_multi_aff *
1710 isl_union_pw_multi_aff_reset_user(
1711 __isl_take isl_union_pw_multi_aff *upma);
1713 #include <isl/polynomial.h>
1714 __isl_give isl_pw_qpolynomial *
1715 isl_pw_qpolynomial_reset_user(
1716 __isl_take isl_pw_qpolynomial *pwqp);
1717 __isl_give isl_union_pw_qpolynomial *
1718 isl_union_pw_qpolynomial_reset_user(
1719 __isl_take isl_union_pw_qpolynomial *upwqp);
1720 __isl_give isl_pw_qpolynomial_fold *
1721 isl_pw_qpolynomial_fold_reset_user(
1722 __isl_take isl_pw_qpolynomial_fold *pwf);
1723 __isl_give isl_union_pw_qpolynomial_fold *
1724 isl_union_pw_qpolynomial_fold_reset_user(
1725 __isl_take isl_union_pw_qpolynomial_fold *upwf);
1727 Spaces can be nested. In particular, the domain of a set or
1728 the domain or range of a relation can be a nested relation.
1729 This process is also called I<wrapping>.
1730 The functions for detecting, constructing and deconstructing
1731 such nested spaces can be found in the wrapping properties
1732 of L</"Unary Properties">, the wrapping operations
1733 of L</"Unary Operations"> and the Cartesian product operations
1734 of L</"Basic Operations">.
1736 Spaces can be created from other spaces
1737 using the functions described in L</"Unary Operations">
1738 and L</"Binary Operations">.
1742 A local space is essentially a space with
1743 zero or more existentially quantified variables.
1744 The local space of various objects can be obtained
1745 using the following functions.
1747 #include <isl/constraint.h>
1748 __isl_give isl_local_space *isl_constraint_get_local_space(
1749 __isl_keep isl_constraint *constraint);
1751 #include <isl/set.h>
1752 __isl_give isl_local_space *isl_basic_set_get_local_space(
1753 __isl_keep isl_basic_set *bset);
1755 #include <isl/map.h>
1756 __isl_give isl_local_space *isl_basic_map_get_local_space(
1757 __isl_keep isl_basic_map *bmap);
1759 #include <isl/aff.h>
1760 __isl_give isl_local_space *isl_aff_get_domain_local_space(
1761 __isl_keep isl_aff *aff);
1762 __isl_give isl_local_space *isl_aff_get_local_space(
1763 __isl_keep isl_aff *aff);
1765 A new local space can be created from a space using
1767 #include <isl/local_space.h>
1768 __isl_give isl_local_space *isl_local_space_from_space(
1769 __isl_take isl_space *space);
1771 They can be inspected, modified, copied and freed using the following functions.
1773 #include <isl/local_space.h>
1774 isl_bool isl_local_space_is_params(
1775 __isl_keep isl_local_space *ls);
1776 isl_bool isl_local_space_is_set(
1777 __isl_keep isl_local_space *ls);
1778 __isl_give isl_space *isl_local_space_get_space(
1779 __isl_keep isl_local_space *ls);
1780 __isl_give isl_aff *isl_local_space_get_div(
1781 __isl_keep isl_local_space *ls, int pos);
1782 __isl_give isl_local_space *isl_local_space_copy(
1783 __isl_keep isl_local_space *ls);
1784 __isl_null isl_local_space *isl_local_space_free(
1785 __isl_take isl_local_space *ls);
1787 Note that C<isl_local_space_get_div> can only be used on local spaces
1790 Two local spaces can be compared using
1792 isl_bool isl_local_space_is_equal(
1793 __isl_keep isl_local_space *ls1,
1794 __isl_keep isl_local_space *ls2);
1796 Local spaces can be created from other local spaces
1797 using the functions described in L</"Unary Operations">
1798 and L</"Binary Operations">.
1800 =head2 Creating New Sets and Relations
1802 C<isl> has functions for creating some standard sets and relations.
1806 =item * Empty sets and relations
1808 __isl_give isl_basic_set *isl_basic_set_empty(
1809 __isl_take isl_space *space);
1810 __isl_give isl_basic_map *isl_basic_map_empty(
1811 __isl_take isl_space *space);
1812 __isl_give isl_set *isl_set_empty(
1813 __isl_take isl_space *space);
1814 __isl_give isl_map *isl_map_empty(
1815 __isl_take isl_space *space);
1816 __isl_give isl_union_set *isl_union_set_empty(
1817 __isl_take isl_space *space);
1818 __isl_give isl_union_map *isl_union_map_empty(
1819 __isl_take isl_space *space);
1821 For C<isl_union_set>s and C<isl_union_map>s, the space
1822 is only used to specify the parameters.
1824 =item * Universe sets and relations
1826 __isl_give isl_basic_set *isl_basic_set_universe(
1827 __isl_take isl_space *space);
1828 __isl_give isl_basic_map *isl_basic_map_universe(
1829 __isl_take isl_space *space);
1830 __isl_give isl_set *isl_set_universe(
1831 __isl_take isl_space *space);
1832 __isl_give isl_map *isl_map_universe(
1833 __isl_take isl_space *space);
1834 __isl_give isl_union_set *isl_union_set_universe(
1835 __isl_take isl_union_set *uset);
1836 __isl_give isl_union_map *isl_union_map_universe(
1837 __isl_take isl_union_map *umap);
1839 The sets and relations constructed by the functions above
1840 contain all integer values, while those constructed by the
1841 functions below only contain non-negative values.
1843 __isl_give isl_basic_set *isl_basic_set_nat_universe(
1844 __isl_take isl_space *space);
1845 __isl_give isl_basic_map *isl_basic_map_nat_universe(
1846 __isl_take isl_space *space);
1847 __isl_give isl_set *isl_set_nat_universe(
1848 __isl_take isl_space *space);
1849 __isl_give isl_map *isl_map_nat_universe(
1850 __isl_take isl_space *space);
1852 =item * Identity relations
1854 __isl_give isl_basic_map *isl_basic_map_identity(
1855 __isl_take isl_space *space);
1856 __isl_give isl_map *isl_map_identity(
1857 __isl_take isl_space *space);
1859 The number of input and output dimensions in C<space> needs
1862 =item * Lexicographic order
1864 __isl_give isl_map *isl_map_lex_lt(
1865 __isl_take isl_space *set_space);
1866 __isl_give isl_map *isl_map_lex_le(
1867 __isl_take isl_space *set_space);
1868 __isl_give isl_map *isl_map_lex_gt(
1869 __isl_take isl_space *set_space);
1870 __isl_give isl_map *isl_map_lex_ge(
1871 __isl_take isl_space *set_space);
1872 __isl_give isl_map *isl_map_lex_lt_first(
1873 __isl_take isl_space *space, unsigned n);
1874 __isl_give isl_map *isl_map_lex_le_first(
1875 __isl_take isl_space *space, unsigned n);
1876 __isl_give isl_map *isl_map_lex_gt_first(
1877 __isl_take isl_space *space, unsigned n);
1878 __isl_give isl_map *isl_map_lex_ge_first(
1879 __isl_take isl_space *space, unsigned n);
1881 The first four functions take a space for a B<set>
1882 and return relations that express that the elements in the domain
1883 are lexicographically less
1884 (C<isl_map_lex_lt>), less or equal (C<isl_map_lex_le>),
1885 greater (C<isl_map_lex_gt>) or greater or equal (C<isl_map_lex_ge>)
1886 than the elements in the range.
1887 The last four functions take a space for a map
1888 and return relations that express that the first C<n> dimensions
1889 in the domain are lexicographically less
1890 (C<isl_map_lex_lt_first>), less or equal (C<isl_map_lex_le_first>),
1891 greater (C<isl_map_lex_gt_first>) or greater or equal (C<isl_map_lex_ge_first>)
1892 than the first C<n> dimensions in the range.
1896 A basic set or relation can be converted to a set or relation
1897 using the following functions.
1899 __isl_give isl_set *isl_set_from_basic_set(
1900 __isl_take isl_basic_set *bset);
1901 __isl_give isl_map *isl_map_from_basic_map(
1902 __isl_take isl_basic_map *bmap);
1904 Sets and relations can be converted to union sets and relations
1905 using the following functions.
1907 __isl_give isl_union_set *isl_union_set_from_basic_set(
1908 __isl_take isl_basic_set *bset);
1909 __isl_give isl_union_map *isl_union_map_from_basic_map(
1910 __isl_take isl_basic_map *bmap);
1911 __isl_give isl_union_set *isl_union_set_from_set(
1912 __isl_take isl_set *set);
1913 __isl_give isl_union_map *isl_union_map_from_map(
1914 __isl_take isl_map *map);
1916 The inverse conversions below can only be used if the input
1917 union set or relation is known to contain elements in exactly one
1920 __isl_give isl_set *isl_set_from_union_set(
1921 __isl_take isl_union_set *uset);
1922 __isl_give isl_map *isl_map_from_union_map(
1923 __isl_take isl_union_map *umap);
1925 Sets and relations can be copied and freed again using the following
1928 __isl_give isl_basic_set *isl_basic_set_copy(
1929 __isl_keep isl_basic_set *bset);
1930 __isl_give isl_set *isl_set_copy(__isl_keep isl_set *set);
1931 __isl_give isl_union_set *isl_union_set_copy(
1932 __isl_keep isl_union_set *uset);
1933 __isl_give isl_basic_map *isl_basic_map_copy(
1934 __isl_keep isl_basic_map *bmap);
1935 __isl_give isl_map *isl_map_copy(__isl_keep isl_map *map);
1936 __isl_give isl_union_map *isl_union_map_copy(
1937 __isl_keep isl_union_map *umap);
1938 __isl_null isl_basic_set *isl_basic_set_free(
1939 __isl_take isl_basic_set *bset);
1940 __isl_null isl_set *isl_set_free(__isl_take isl_set *set);
1941 __isl_null isl_union_set *isl_union_set_free(
1942 __isl_take isl_union_set *uset);
1943 __isl_null isl_basic_map *isl_basic_map_free(
1944 __isl_take isl_basic_map *bmap);
1945 __isl_null isl_map *isl_map_free(__isl_take isl_map *map);
1946 __isl_null isl_union_map *isl_union_map_free(
1947 __isl_take isl_union_map *umap);
1949 Other sets and relations can be constructed by starting
1950 from a universe set or relation, adding equality and/or
1951 inequality constraints and then projecting out the
1952 existentially quantified variables, if any.
1953 Constraints can be constructed, manipulated and
1954 added to (or removed from) (basic) sets and relations
1955 using the following functions.
1957 #include <isl/constraint.h>
1958 __isl_give isl_constraint *isl_constraint_alloc_equality(
1959 __isl_take isl_local_space *ls);
1960 __isl_give isl_constraint *isl_constraint_alloc_inequality(
1961 __isl_take isl_local_space *ls);
1962 __isl_give isl_constraint *isl_constraint_set_constant_si(
1963 __isl_take isl_constraint *constraint, int v);
1964 __isl_give isl_constraint *isl_constraint_set_constant_val(
1965 __isl_take isl_constraint *constraint,
1966 __isl_take isl_val *v);
1967 __isl_give isl_constraint *isl_constraint_set_coefficient_si(
1968 __isl_take isl_constraint *constraint,
1969 enum isl_dim_type type, int pos, int v);
1970 __isl_give isl_constraint *
1971 isl_constraint_set_coefficient_val(
1972 __isl_take isl_constraint *constraint,
1973 enum isl_dim_type type, int pos,
1974 __isl_take isl_val *v);
1975 __isl_give isl_basic_map *isl_basic_map_add_constraint(
1976 __isl_take isl_basic_map *bmap,
1977 __isl_take isl_constraint *constraint);
1978 __isl_give isl_basic_set *isl_basic_set_add_constraint(
1979 __isl_take isl_basic_set *bset,
1980 __isl_take isl_constraint *constraint);
1981 __isl_give isl_map *isl_map_add_constraint(
1982 __isl_take isl_map *map,
1983 __isl_take isl_constraint *constraint);
1984 __isl_give isl_set *isl_set_add_constraint(
1985 __isl_take isl_set *set,
1986 __isl_take isl_constraint *constraint);
1988 For example, to create a set containing the even integers
1989 between 10 and 42, you would use the following code.
1992 isl_local_space *ls;
1994 isl_basic_set *bset;
1996 space = isl_space_set_alloc(ctx, 0, 2);
1997 bset = isl_basic_set_universe(isl_space_copy(space));
1998 ls = isl_local_space_from_space(space);
2000 c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
2001 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
2002 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 2);
2003 bset = isl_basic_set_add_constraint(bset, c);
2005 c = isl_constraint_alloc_inequality(isl_local_space_copy(ls));
2006 c = isl_constraint_set_constant_si(c, -10);
2007 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
2008 bset = isl_basic_set_add_constraint(bset, c);
2010 c = isl_constraint_alloc_inequality(ls);
2011 c = isl_constraint_set_constant_si(c, 42);
2012 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
2013 bset = isl_basic_set_add_constraint(bset, c);
2015 bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 1);
2019 isl_basic_set *bset;
2020 bset = isl_basic_set_read_from_str(ctx,
2021 "{[i] : exists (a : i = 2a and i >= 10 and i <= 42)}");
2023 A basic set or relation can also be constructed from two matrices
2024 describing the equalities and the inequalities.
2026 __isl_give isl_basic_set *isl_basic_set_from_constraint_matrices(
2027 __isl_take isl_space *space,
2028 __isl_take isl_mat *eq, __isl_take isl_mat *ineq,
2029 enum isl_dim_type c1,
2030 enum isl_dim_type c2, enum isl_dim_type c3,
2031 enum isl_dim_type c4);
2032 __isl_give isl_basic_map *isl_basic_map_from_constraint_matrices(
2033 __isl_take isl_space *space,
2034 __isl_take isl_mat *eq, __isl_take isl_mat *ineq,
2035 enum isl_dim_type c1,
2036 enum isl_dim_type c2, enum isl_dim_type c3,
2037 enum isl_dim_type c4, enum isl_dim_type c5);
2039 The C<isl_dim_type> arguments indicate the order in which
2040 different kinds of variables appear in the input matrices
2041 and should be a permutation of C<isl_dim_cst>, C<isl_dim_param>,
2042 C<isl_dim_set> and C<isl_dim_div> for sets and
2043 of C<isl_dim_cst>, C<isl_dim_param>,
2044 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div> for relations.
2046 A (basic or union) set or relation can also be constructed from a
2047 (union) (piecewise) (multiple) affine expression
2048 or a list of affine expressions
2049 (See L</"Functions">), provided these affine expressions do not
2052 __isl_give isl_basic_map *isl_basic_map_from_aff(
2053 __isl_take isl_aff *aff);
2054 __isl_give isl_map *isl_map_from_aff(
2055 __isl_take isl_aff *aff);
2056 __isl_give isl_set *isl_set_from_pw_aff(
2057 __isl_take isl_pw_aff *pwaff);
2058 __isl_give isl_map *isl_map_from_pw_aff(
2059 __isl_take isl_pw_aff *pwaff);
2060 __isl_give isl_basic_map *isl_basic_map_from_aff_list(
2061 __isl_take isl_space *domain_space,
2062 __isl_take isl_aff_list *list);
2063 __isl_give isl_basic_map *isl_basic_map_from_multi_aff(
2064 __isl_take isl_multi_aff *maff)
2065 __isl_give isl_map *isl_map_from_multi_aff(
2066 __isl_take isl_multi_aff *maff)
2067 __isl_give isl_set *isl_set_from_pw_multi_aff(
2068 __isl_take isl_pw_multi_aff *pma);
2069 __isl_give isl_map *isl_map_from_pw_multi_aff(
2070 __isl_take isl_pw_multi_aff *pma);
2071 __isl_give isl_set *isl_set_from_multi_pw_aff(
2072 __isl_take isl_multi_pw_aff *mpa);
2073 __isl_give isl_map *isl_map_from_multi_pw_aff(
2074 __isl_take isl_multi_pw_aff *mpa);
2075 __isl_give isl_union_map *isl_union_map_from_union_pw_aff(
2076 __isl_take isl_union_pw_aff *upa);
2077 __isl_give isl_union_map *
2078 isl_union_map_from_union_pw_multi_aff(
2079 __isl_take isl_union_pw_multi_aff *upma);
2080 __isl_give isl_union_map *
2081 isl_union_map_from_multi_union_pw_aff(
2082 __isl_take isl_multi_union_pw_aff *mupa);
2084 The C<domain_space> argument describes the domain of the resulting
2085 basic relation. It is required because the C<list> may consist
2086 of zero affine expressions.
2087 The C<mupa> passed to C<isl_union_map_from_multi_union_pw_aff>
2088 is not allowed to be zero-dimensional. The domain of the result
2089 is the shared domain of the union piecewise affine elements.
2091 =head2 Inspecting Sets and Relations
2093 Usually, the user should not have to care about the actual constraints
2094 of the sets and maps, but should instead apply the abstract operations
2095 explained in the following sections.
2096 Occasionally, however, it may be required to inspect the individual
2097 coefficients of the constraints. This section explains how to do so.
2098 In these cases, it may also be useful to have C<isl> compute
2099 an explicit representation of the existentially quantified variables.
2101 __isl_give isl_set *isl_set_compute_divs(
2102 __isl_take isl_set *set);
2103 __isl_give isl_map *isl_map_compute_divs(
2104 __isl_take isl_map *map);
2105 __isl_give isl_union_set *isl_union_set_compute_divs(
2106 __isl_take isl_union_set *uset);
2107 __isl_give isl_union_map *isl_union_map_compute_divs(
2108 __isl_take isl_union_map *umap);
2110 This explicit representation defines the existentially quantified
2111 variables as integer divisions of the other variables, possibly
2112 including earlier existentially quantified variables.
2113 An explicitly represented existentially quantified variable therefore
2114 has a unique value when the values of the other variables are known.
2116 Alternatively, the existentially quantified variables can be removed
2117 using the following functions, which compute an overapproximation.
2119 #include <isl/set.h>
2120 __isl_give isl_basic_set *isl_basic_set_remove_divs(
2121 __isl_take isl_basic_set *bset);
2122 __isl_give isl_set *isl_set_remove_divs(
2123 __isl_take isl_set *set);
2125 #include <isl/map.h>
2126 __isl_give isl_basic_map *isl_basic_map_remove_divs(
2127 __isl_take isl_basic_map *bmap);
2128 __isl_give isl_map *isl_map_remove_divs(
2129 __isl_take isl_map *map);
2131 #include <isl/union_set.h>
2132 __isl_give isl_union_set *isl_union_set_remove_divs(
2133 __isl_take isl_union_set *bset);
2135 #include <isl/union_map.h>
2136 __isl_give isl_union_map *isl_union_map_remove_divs(
2137 __isl_take isl_union_map *bmap);
2139 It is also possible to only remove those divs that are defined
2140 in terms of a given range of dimensions or only those for which
2141 no explicit representation is known.
2143 __isl_give isl_basic_set *
2144 isl_basic_set_remove_divs_involving_dims(
2145 __isl_take isl_basic_set *bset,
2146 enum isl_dim_type type,
2147 unsigned first, unsigned n);
2148 __isl_give isl_basic_map *
2149 isl_basic_map_remove_divs_involving_dims(
2150 __isl_take isl_basic_map *bmap,
2151 enum isl_dim_type type,
2152 unsigned first, unsigned n);
2153 __isl_give isl_set *isl_set_remove_divs_involving_dims(
2154 __isl_take isl_set *set, enum isl_dim_type type,
2155 unsigned first, unsigned n);
2156 __isl_give isl_map *isl_map_remove_divs_involving_dims(
2157 __isl_take isl_map *map, enum isl_dim_type type,
2158 unsigned first, unsigned n);
2160 __isl_give isl_basic_set *
2161 isl_basic_set_remove_unknown_divs(
2162 __isl_take isl_basic_set *bset);
2163 __isl_give isl_set *isl_set_remove_unknown_divs(
2164 __isl_take isl_set *set);
2165 __isl_give isl_map *isl_map_remove_unknown_divs(
2166 __isl_take isl_map *map);
2168 To iterate over all the sets or maps in a union set or map, use
2170 isl_stat isl_union_set_foreach_set(
2171 __isl_keep isl_union_set *uset,
2172 isl_stat (*fn)(__isl_take isl_set *set, void *user),
2174 isl_stat isl_union_map_foreach_map(
2175 __isl_keep isl_union_map *umap,
2176 isl_stat (*fn)(__isl_take isl_map *map, void *user),
2179 These functions call the callback function once for each
2180 (pair of) space(s) for which there are elements in the input.
2181 The argument to the callback contains all elements in the input
2182 with that (pair of) space(s).
2184 The number of sets or maps in a union set or map can be obtained
2187 int isl_union_set_n_set(__isl_keep isl_union_set *uset);
2188 int isl_union_map_n_map(__isl_keep isl_union_map *umap);
2190 To extract the set or map in a given space from a union, use
2192 __isl_give isl_set *isl_union_set_extract_set(
2193 __isl_keep isl_union_set *uset,
2194 __isl_take isl_space *space);
2195 __isl_give isl_map *isl_union_map_extract_map(
2196 __isl_keep isl_union_map *umap,
2197 __isl_take isl_space *space);
2199 To iterate over all the basic sets or maps in a set or map, use
2201 isl_stat isl_set_foreach_basic_set(__isl_keep isl_set *set,
2202 isl_stat (*fn)(__isl_take isl_basic_set *bset,
2205 isl_stat isl_map_foreach_basic_map(__isl_keep isl_map *map,
2206 isl_stat (*fn)(__isl_take isl_basic_map *bmap,
2210 The callback function C<fn> should return 0 if successful and
2211 -1 if an error occurs. In the latter case, or if any other error
2212 occurs, the above functions will return -1.
2214 It should be noted that C<isl> does not guarantee that
2215 the basic sets or maps passed to C<fn> are disjoint.
2216 If this is required, then the user should call one of
2217 the following functions first.
2219 __isl_give isl_set *isl_set_make_disjoint(
2220 __isl_take isl_set *set);
2221 __isl_give isl_map *isl_map_make_disjoint(
2222 __isl_take isl_map *map);
2224 The number of basic sets in a set can be obtained
2225 or the number of basic maps in a map can be obtained
2228 #include <isl/set.h>
2229 int isl_set_n_basic_set(__isl_keep isl_set *set);
2231 #include <isl/map.h>
2232 int isl_map_n_basic_map(__isl_keep isl_map *map);
2234 It is also possible to obtain a list of basic sets from a set
2237 #include <isl/set.h>
2238 __isl_give isl_basic_set_list *isl_set_get_basic_set_list(
2239 __isl_keep isl_set *set);
2241 #include <isl/union_set.h>
2242 __isl_give isl_basic_set_list *
2243 isl_union_set_get_basic_set_list(
2244 __isl_keep isl_union_set *uset);
2246 The returned list can be manipulated using the functions in L<"Lists">.
2248 To iterate over the constraints of a basic set or map, use
2250 #include <isl/constraint.h>
2252 int isl_basic_set_n_constraint(
2253 __isl_keep isl_basic_set *bset);
2254 isl_stat isl_basic_set_foreach_constraint(
2255 __isl_keep isl_basic_set *bset,
2256 isl_stat (*fn)(__isl_take isl_constraint *c,
2259 int isl_basic_map_n_constraint(
2260 __isl_keep isl_basic_map *bmap);
2261 isl_stat isl_basic_map_foreach_constraint(
2262 __isl_keep isl_basic_map *bmap,
2263 isl_stat (*fn)(__isl_take isl_constraint *c,
2266 __isl_null isl_constraint *isl_constraint_free(
2267 __isl_take isl_constraint *c);
2269 Again, the callback function C<fn> should return 0 if successful and
2270 -1 if an error occurs. In the latter case, or if any other error
2271 occurs, the above functions will return -1.
2272 The constraint C<c> represents either an equality or an inequality.
2273 Use the following function to find out whether a constraint
2274 represents an equality. If not, it represents an inequality.
2276 isl_bool isl_constraint_is_equality(
2277 __isl_keep isl_constraint *constraint);
2279 It is also possible to obtain a list of constraints from a basic
2282 #include <isl/constraint.h>
2283 __isl_give isl_constraint_list *
2284 isl_basic_map_get_constraint_list(
2285 __isl_keep isl_basic_map *bmap);
2286 __isl_give isl_constraint_list *
2287 isl_basic_set_get_constraint_list(
2288 __isl_keep isl_basic_set *bset);
2290 These functions require that all existentially quantified variables
2291 have an explicit representation.
2292 The returned list can be manipulated using the functions in L<"Lists">.
2294 The coefficients of the constraints can be inspected using
2295 the following functions.
2297 isl_bool isl_constraint_is_lower_bound(
2298 __isl_keep isl_constraint *constraint,
2299 enum isl_dim_type type, unsigned pos);
2300 isl_bool isl_constraint_is_upper_bound(
2301 __isl_keep isl_constraint *constraint,
2302 enum isl_dim_type type, unsigned pos);
2303 __isl_give isl_val *isl_constraint_get_constant_val(
2304 __isl_keep isl_constraint *constraint);
2305 __isl_give isl_val *isl_constraint_get_coefficient_val(
2306 __isl_keep isl_constraint *constraint,
2307 enum isl_dim_type type, int pos);
2309 The explicit representations of the existentially quantified
2310 variables can be inspected using the following function.
2311 Note that the user is only allowed to use this function
2312 if the inspected set or map is the result of a call
2313 to C<isl_set_compute_divs> or C<isl_map_compute_divs>.
2314 The existentially quantified variable is equal to the floor
2315 of the returned affine expression. The affine expression
2316 itself can be inspected using the functions in
2319 __isl_give isl_aff *isl_constraint_get_div(
2320 __isl_keep isl_constraint *constraint, int pos);
2322 To obtain the constraints of a basic set or map in matrix
2323 form, use the following functions.
2325 __isl_give isl_mat *isl_basic_set_equalities_matrix(
2326 __isl_keep isl_basic_set *bset,
2327 enum isl_dim_type c1, enum isl_dim_type c2,
2328 enum isl_dim_type c3, enum isl_dim_type c4);
2329 __isl_give isl_mat *isl_basic_set_inequalities_matrix(
2330 __isl_keep isl_basic_set *bset,
2331 enum isl_dim_type c1, enum isl_dim_type c2,
2332 enum isl_dim_type c3, enum isl_dim_type c4);
2333 __isl_give isl_mat *isl_basic_map_equalities_matrix(
2334 __isl_keep isl_basic_map *bmap,
2335 enum isl_dim_type c1,
2336 enum isl_dim_type c2, enum isl_dim_type c3,
2337 enum isl_dim_type c4, enum isl_dim_type c5);
2338 __isl_give isl_mat *isl_basic_map_inequalities_matrix(
2339 __isl_keep isl_basic_map *bmap,
2340 enum isl_dim_type c1,
2341 enum isl_dim_type c2, enum isl_dim_type c3,
2342 enum isl_dim_type c4, enum isl_dim_type c5);
2344 The C<isl_dim_type> arguments dictate the order in which
2345 different kinds of variables appear in the resulting matrix.
2346 For set inputs, they should be a permutation of
2347 C<isl_dim_cst>, C<isl_dim_param>, C<isl_dim_set> and C<isl_dim_div>.
2348 For map inputs, they should be a permutation of
2349 C<isl_dim_cst>, C<isl_dim_param>,
2350 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div>.
2354 Points are elements of a set. They can be used to construct
2355 simple sets (boxes) or they can be used to represent the
2356 individual elements of a set.
2357 The zero point (the origin) can be created using
2359 __isl_give isl_point *isl_point_zero(__isl_take isl_space *space);
2361 The coordinates of a point can be inspected, set and changed
2364 __isl_give isl_val *isl_point_get_coordinate_val(
2365 __isl_keep isl_point *pnt,
2366 enum isl_dim_type type, int pos);
2367 __isl_give isl_point *isl_point_set_coordinate_val(
2368 __isl_take isl_point *pnt,
2369 enum isl_dim_type type, int pos,
2370 __isl_take isl_val *v);
2372 __isl_give isl_point *isl_point_add_ui(
2373 __isl_take isl_point *pnt,
2374 enum isl_dim_type type, int pos, unsigned val);
2375 __isl_give isl_point *isl_point_sub_ui(
2376 __isl_take isl_point *pnt,
2377 enum isl_dim_type type, int pos, unsigned val);
2379 Points can be copied or freed using
2381 __isl_give isl_point *isl_point_copy(
2382 __isl_keep isl_point *pnt);
2383 __isl_null isl_point *isl_point_free(
2384 __isl_take isl_point *pnt);
2386 A singleton set can be created from a point using
2388 __isl_give isl_basic_set *isl_basic_set_from_point(
2389 __isl_take isl_point *pnt);
2390 __isl_give isl_set *isl_set_from_point(
2391 __isl_take isl_point *pnt);
2392 __isl_give isl_union_set *isl_union_set_from_point(
2393 __isl_take isl_point *pnt);
2395 and a box can be created from two opposite extremal points using
2397 __isl_give isl_basic_set *isl_basic_set_box_from_points(
2398 __isl_take isl_point *pnt1,
2399 __isl_take isl_point *pnt2);
2400 __isl_give isl_set *isl_set_box_from_points(
2401 __isl_take isl_point *pnt1,
2402 __isl_take isl_point *pnt2);
2404 All elements of a B<bounded> (union) set can be enumerated using
2405 the following functions.
2407 isl_stat isl_set_foreach_point(__isl_keep isl_set *set,
2408 isl_stat (*fn)(__isl_take isl_point *pnt,
2411 isl_stat isl_union_set_foreach_point(
2412 __isl_keep isl_union_set *uset,
2413 isl_stat (*fn)(__isl_take isl_point *pnt,
2417 The function C<fn> is called for each integer point in
2418 C<set> with as second argument the last argument of
2419 the C<isl_set_foreach_point> call. The function C<fn>
2420 should return C<0> on success and C<-1> on failure.
2421 In the latter case, C<isl_set_foreach_point> will stop
2422 enumerating and return C<-1> as well.
2423 If the enumeration is performed successfully and to completion,
2424 then C<isl_set_foreach_point> returns C<0>.
2426 To obtain a single point of a (basic or union) set, use
2428 __isl_give isl_point *isl_basic_set_sample_point(
2429 __isl_take isl_basic_set *bset);
2430 __isl_give isl_point *isl_set_sample_point(
2431 __isl_take isl_set *set);
2432 __isl_give isl_point *isl_union_set_sample_point(
2433 __isl_take isl_union_set *uset);
2435 If C<set> does not contain any (integer) points, then the
2436 resulting point will be ``void'', a property that can be
2439 isl_bool isl_point_is_void(__isl_keep isl_point *pnt);
2443 Besides sets and relation, C<isl> also supports various types of functions.
2444 Each of these types is derived from the value type (see L</"Values">)
2445 or from one of two primitive function types
2446 through the application of zero or more type constructors.
2447 We first describe the primitive type and then we describe
2448 the types derived from these primitive types.
2450 =head3 Primitive Functions
2452 C<isl> support two primitive function types, quasi-affine
2453 expressions and quasipolynomials.
2454 A quasi-affine expression is defined either over a parameter
2455 space or over a set and is composed of integer constants,
2456 parameters and set variables, addition, subtraction and
2457 integer division by an integer constant.
2458 For example, the quasi-affine expression
2460 [n] -> { [x] -> [2*floor((4 n + x)/9] }
2462 maps C<x> to C<2*floor((4 n + x)/9>.
2463 A quasipolynomial is a polynomial expression in quasi-affine
2464 expression. That is, it additionally allows for multiplication.
2465 Note, though, that it is not allowed to construct an integer
2466 division of an expression involving multiplications.
2467 Here is an example of a quasipolynomial that is not
2468 quasi-affine expression
2470 [n] -> { [x] -> (n*floor((4 n + x)/9) }
2472 Note that the external representations of quasi-affine expressions
2473 and quasipolynomials are different. Quasi-affine expressions
2474 use a notation with square brackets just like binary relations,
2475 while quasipolynomials do not. This might change at some point.
2477 If a primitive function is defined over a parameter space,
2478 then the space of the function itself is that of a set.
2479 If it is defined over a set, then the space of the function
2480 is that of a relation. In both cases, the set space (or
2481 the output space) is single-dimensional, anonymous and unstructured.
2482 To create functions with multiple dimensions or with other kinds
2483 of set or output spaces, use multiple expressions
2484 (see L</"Multiple Expressions">).
2488 =item * Quasi-affine Expressions
2490 Besides the expressions described above, a quasi-affine
2491 expression can also be set to NaN. Such expressions
2492 typically represent a failure to represent a result
2493 as a quasi-affine expression.
2495 The zero quasi affine expression or the quasi affine expression
2496 that is equal to a given value or
2497 a specified dimension on a given domain can be created using
2499 #include <isl/aff.h>
2500 __isl_give isl_aff *isl_aff_zero_on_domain(
2501 __isl_take isl_local_space *ls);
2502 __isl_give isl_aff *isl_aff_val_on_domain(
2503 __isl_take isl_local_space *ls,
2504 __isl_take isl_val *val);
2505 __isl_give isl_aff *isl_aff_var_on_domain(
2506 __isl_take isl_local_space *ls,
2507 enum isl_dim_type type, unsigned pos);
2508 __isl_give isl_aff *isl_aff_nan_on_domain(
2509 __isl_take isl_local_space *ls);
2511 Quasi affine expressions can be copied and freed using
2513 #include <isl/aff.h>
2514 __isl_give isl_aff *isl_aff_copy(
2515 __isl_keep isl_aff *aff);
2516 __isl_null isl_aff *isl_aff_free(
2517 __isl_take isl_aff *aff);
2519 A (rational) bound on a dimension can be extracted from an C<isl_constraint>
2520 using the following function. The constraint is required to have
2521 a non-zero coefficient for the specified dimension.
2523 #include <isl/constraint.h>
2524 __isl_give isl_aff *isl_constraint_get_bound(
2525 __isl_keep isl_constraint *constraint,
2526 enum isl_dim_type type, int pos);
2528 The entire affine expression of the constraint can also be extracted
2529 using the following function.
2531 #include <isl/constraint.h>
2532 __isl_give isl_aff *isl_constraint_get_aff(
2533 __isl_keep isl_constraint *constraint);
2535 Conversely, an equality constraint equating
2536 the affine expression to zero or an inequality constraint enforcing
2537 the affine expression to be non-negative, can be constructed using
2539 __isl_give isl_constraint *isl_equality_from_aff(
2540 __isl_take isl_aff *aff);
2541 __isl_give isl_constraint *isl_inequality_from_aff(
2542 __isl_take isl_aff *aff);
2544 The coefficients and the integer divisions of an affine expression
2545 can be inspected using the following functions.
2547 #include <isl/aff.h>
2548 __isl_give isl_val *isl_aff_get_constant_val(
2549 __isl_keep isl_aff *aff);
2550 __isl_give isl_val *isl_aff_get_coefficient_val(
2551 __isl_keep isl_aff *aff,
2552 enum isl_dim_type type, int pos);
2553 int isl_aff_coefficient_sgn(__isl_keep isl_aff *aff,
2554 enum isl_dim_type type, int pos);
2555 __isl_give isl_val *isl_aff_get_denominator_val(
2556 __isl_keep isl_aff *aff);
2557 __isl_give isl_aff *isl_aff_get_div(
2558 __isl_keep isl_aff *aff, int pos);
2560 They can be modified using the following functions.
2562 #include <isl/aff.h>
2563 __isl_give isl_aff *isl_aff_set_constant_si(
2564 __isl_take isl_aff *aff, int v);
2565 __isl_give isl_aff *isl_aff_set_constant_val(
2566 __isl_take isl_aff *aff, __isl_take isl_val *v);
2567 __isl_give isl_aff *isl_aff_set_coefficient_si(
2568 __isl_take isl_aff *aff,
2569 enum isl_dim_type type, int pos, int v);
2570 __isl_give isl_aff *isl_aff_set_coefficient_val(
2571 __isl_take isl_aff *aff,
2572 enum isl_dim_type type, int pos,
2573 __isl_take isl_val *v);
2575 __isl_give isl_aff *isl_aff_add_constant_si(
2576 __isl_take isl_aff *aff, int v);
2577 __isl_give isl_aff *isl_aff_add_constant_val(
2578 __isl_take isl_aff *aff, __isl_take isl_val *v);
2579 __isl_give isl_aff *isl_aff_add_constant_num_si(
2580 __isl_take isl_aff *aff, int v);
2581 __isl_give isl_aff *isl_aff_add_coefficient_si(
2582 __isl_take isl_aff *aff,
2583 enum isl_dim_type type, int pos, int v);
2584 __isl_give isl_aff *isl_aff_add_coefficient_val(
2585 __isl_take isl_aff *aff,
2586 enum isl_dim_type type, int pos,
2587 __isl_take isl_val *v);
2589 Note that C<isl_aff_set_constant_si> and C<isl_aff_set_coefficient_si>
2590 set the I<numerator> of the constant or coefficient, while
2591 C<isl_aff_set_constant_val> and C<isl_aff_set_coefficient_val> set
2592 the constant or coefficient as a whole.
2593 The C<add_constant> and C<add_coefficient> functions add an integer
2594 or rational value to
2595 the possibly rational constant or coefficient.
2596 The C<add_constant_num> functions add an integer value to
2599 =item * Quasipolynomials
2601 Some simple quasipolynomials can be created using the following functions.
2603 #include <isl/polynomial.h>
2604 __isl_give isl_qpolynomial *isl_qpolynomial_zero_on_domain(
2605 __isl_take isl_space *domain);
2606 __isl_give isl_qpolynomial *isl_qpolynomial_one_on_domain(
2607 __isl_take isl_space *domain);
2608 __isl_give isl_qpolynomial *isl_qpolynomial_infty_on_domain(
2609 __isl_take isl_space *domain);
2610 __isl_give isl_qpolynomial *isl_qpolynomial_neginfty_on_domain(
2611 __isl_take isl_space *domain);
2612 __isl_give isl_qpolynomial *isl_qpolynomial_nan_on_domain(
2613 __isl_take isl_space *domain);
2614 __isl_give isl_qpolynomial *isl_qpolynomial_val_on_domain(
2615 __isl_take isl_space *domain,
2616 __isl_take isl_val *val);
2617 __isl_give isl_qpolynomial *isl_qpolynomial_var_on_domain(
2618 __isl_take isl_space *domain,
2619 enum isl_dim_type type, unsigned pos);
2620 __isl_give isl_qpolynomial *isl_qpolynomial_from_aff(
2621 __isl_take isl_aff *aff);
2623 Recall that the space in which a quasipolynomial lives is a map space
2624 with a one-dimensional range. The C<domain> argument in some of
2625 the functions above corresponds to the domain of this map space.
2627 Quasipolynomials can be copied and freed again using the following
2630 #include <isl/polynomial.h>
2631 __isl_give isl_qpolynomial *isl_qpolynomial_copy(
2632 __isl_keep isl_qpolynomial *qp);
2633 __isl_null isl_qpolynomial *isl_qpolynomial_free(
2634 __isl_take isl_qpolynomial *qp);
2636 The constant term of a quasipolynomial can be extracted using
2638 __isl_give isl_val *isl_qpolynomial_get_constant_val(
2639 __isl_keep isl_qpolynomial *qp);
2641 To iterate over all terms in a quasipolynomial,
2644 isl_stat isl_qpolynomial_foreach_term(
2645 __isl_keep isl_qpolynomial *qp,
2646 isl_stat (*fn)(__isl_take isl_term *term,
2647 void *user), void *user);
2649 The terms themselves can be inspected and freed using
2652 unsigned isl_term_dim(__isl_keep isl_term *term,
2653 enum isl_dim_type type);
2654 __isl_give isl_val *isl_term_get_coefficient_val(
2655 __isl_keep isl_term *term);
2656 int isl_term_get_exp(__isl_keep isl_term *term,
2657 enum isl_dim_type type, unsigned pos);
2658 __isl_give isl_aff *isl_term_get_div(
2659 __isl_keep isl_term *term, unsigned pos);
2660 void isl_term_free(__isl_take isl_term *term);
2662 Each term is a product of parameters, set variables and
2663 integer divisions. The function C<isl_term_get_exp>
2664 returns the exponent of a given dimensions in the given term.
2670 A reduction represents a maximum or a minimum of its
2672 The only reduction type defined by C<isl> is
2673 C<isl_qpolynomial_fold>.
2675 There are currently no functions to directly create such
2676 objects, but they do appear in the piecewise quasipolynomial
2677 reductions returned by the C<isl_pw_qpolynomial_bound> function.
2679 L</"Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions">.
2681 Reductions can be copied and freed using
2682 the following functions.
2684 #include <isl/polynomial.h>
2685 __isl_give isl_qpolynomial_fold *
2686 isl_qpolynomial_fold_copy(
2687 __isl_keep isl_qpolynomial_fold *fold);
2688 void isl_qpolynomial_fold_free(
2689 __isl_take isl_qpolynomial_fold *fold);
2691 To iterate over all quasipolynomials in a reduction, use
2693 isl_stat isl_qpolynomial_fold_foreach_qpolynomial(
2694 __isl_keep isl_qpolynomial_fold *fold,
2695 isl_stat (*fn)(__isl_take isl_qpolynomial *qp,
2696 void *user), void *user);
2698 =head3 Multiple Expressions
2700 A multiple expression represents a sequence of zero or
2701 more base expressions, all defined on the same domain space.
2702 The domain space of the multiple expression is the same
2703 as that of the base expressions, but the range space
2704 can be any space. In case the base expressions have
2705 a set space, the corresponding multiple expression
2706 also has a set space.
2707 Objects of the value type do not have an associated space.
2708 The space of a multiple value is therefore always a set space.
2709 Similarly, the space of a multiple union piecewise
2710 affine expression is always a set space.
2712 The multiple expression types defined by C<isl>
2713 are C<isl_multi_val>, C<isl_multi_aff>, C<isl_multi_pw_aff>,
2714 C<isl_multi_union_pw_aff>.
2716 A multiple expression with the value zero for
2717 each output (or set) dimension can be created
2718 using the following functions.
2720 #include <isl/val.h>
2721 __isl_give isl_multi_val *isl_multi_val_zero(
2722 __isl_take isl_space *space);
2724 #include <isl/aff.h>
2725 __isl_give isl_multi_aff *isl_multi_aff_zero(
2726 __isl_take isl_space *space);
2727 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_zero(
2728 __isl_take isl_space *space);
2729 __isl_give isl_multi_union_pw_aff *
2730 isl_multi_union_pw_aff_zero(
2731 __isl_take isl_space *space);
2733 Since there is no canonical way of representing a zero
2734 value of type C<isl_union_pw_aff>, the space passed
2735 to C<isl_multi_union_pw_aff_zero> needs to be zero-dimensional.
2737 An identity function can be created using the following
2738 functions. The space needs to be that of a relation
2739 with the same number of input and output dimensions.
2741 #include <isl/aff.h>
2742 __isl_give isl_multi_aff *isl_multi_aff_identity(
2743 __isl_take isl_space *space);
2744 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_identity(
2745 __isl_take isl_space *space);
2747 A function that performs a projection on a universe
2748 relation or set can be created using the following functions.
2749 See also the corresponding
2750 projection operations in L</"Unary Operations">.
2752 #include <isl/aff.h>
2753 __isl_give isl_multi_aff *isl_multi_aff_domain_map(
2754 __isl_take isl_space *space);
2755 __isl_give isl_multi_aff *isl_multi_aff_range_map(
2756 __isl_take isl_space *space);
2757 __isl_give isl_multi_aff *isl_multi_aff_project_out_map(
2758 __isl_take isl_space *space,
2759 enum isl_dim_type type,
2760 unsigned first, unsigned n);
2762 A multiple expression can be created from a single
2763 base expression using the following functions.
2764 The space of the created multiple expression is the same
2765 as that of the base expression, except for
2766 C<isl_multi_union_pw_aff_from_union_pw_aff> where the input
2767 lives in a parameter space and the output lives
2768 in a single-dimensional set space.
2770 #include <isl/aff.h>
2771 __isl_give isl_multi_aff *isl_multi_aff_from_aff(
2772 __isl_take isl_aff *aff);
2773 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_pw_aff(
2774 __isl_take isl_pw_aff *pa);
2775 __isl_give isl_multi_union_pw_aff *
2776 isl_multi_union_pw_aff_from_union_pw_aff(
2777 __isl_take isl_union_pw_aff *upa);
2779 A multiple expression can be created from a list
2780 of base expression in a specified space.
2781 The domain of this space needs to be the same
2782 as the domains of the base expressions in the list.
2783 If the base expressions have a set space (or no associated space),
2784 then this space also needs to be a set space.
2786 #include <isl/val.h>
2787 __isl_give isl_multi_val *isl_multi_val_from_val_list(
2788 __isl_take isl_space *space,
2789 __isl_take isl_val_list *list);
2791 #include <isl/aff.h>
2792 __isl_give isl_multi_aff *isl_multi_aff_from_aff_list(
2793 __isl_take isl_space *space,
2794 __isl_take isl_aff_list *list);
2795 __isl_give isl_multi_pw_aff *
2796 isl_multi_pw_aff_from_pw_aff_list(
2797 __isl_take isl_space *space,
2798 __isl_take isl_pw_aff_list *list);
2799 __isl_give isl_multi_union_pw_aff *
2800 isl_multi_union_pw_aff_from_union_pw_aff_list(
2801 __isl_take isl_space *space,
2802 __isl_take isl_union_pw_aff_list *list);
2804 As a convenience, a multiple piecewise expression can
2805 also be created from a multiple expression.
2806 Each piecewise expression in the result has a single
2809 #include <isl/aff.h>
2810 __isl_give isl_multi_pw_aff *
2811 isl_multi_pw_aff_from_multi_aff(
2812 __isl_take isl_multi_aff *ma);
2814 Similarly, a multiple union expression can be
2815 created from a multiple expression.
2817 #include <isl/aff.h>
2818 __isl_give isl_multi_union_pw_aff *
2819 isl_multi_union_pw_aff_from_multi_aff(
2820 __isl_take isl_multi_aff *ma);
2821 __isl_give isl_multi_union_pw_aff *
2822 isl_multi_union_pw_aff_from_multi_pw_aff(
2823 __isl_take isl_multi_pw_aff *mpa);
2825 A multiple quasi-affine expression can be created from
2826 a multiple value with a given domain space using the following
2829 #include <isl/aff.h>
2830 __isl_give isl_multi_aff *
2831 isl_multi_aff_multi_val_on_space(
2832 __isl_take isl_space *space,
2833 __isl_take isl_multi_val *mv);
2836 a multiple union piecewise affine expression can be created from
2837 a multiple value with a given domain or
2838 a multiple affine expression with a given domain
2839 using the following functions.
2841 #include <isl/aff.h>
2842 __isl_give isl_multi_union_pw_aff *
2843 isl_multi_union_pw_aff_multi_val_on_domain(
2844 __isl_take isl_union_set *domain,
2845 __isl_take isl_multi_val *mv);
2846 __isl_give isl_multi_union_pw_aff *
2847 isl_multi_union_pw_aff_multi_aff_on_domain(
2848 __isl_take isl_union_set *domain,
2849 __isl_take isl_multi_aff *ma);
2851 Multiple expressions can be copied and freed using
2852 the following functions.
2854 #include <isl/val.h>
2855 __isl_give isl_multi_val *isl_multi_val_copy(
2856 __isl_keep isl_multi_val *mv);
2857 __isl_null isl_multi_val *isl_multi_val_free(
2858 __isl_take isl_multi_val *mv);
2860 #include <isl/aff.h>
2861 __isl_give isl_multi_aff *isl_multi_aff_copy(
2862 __isl_keep isl_multi_aff *maff);
2863 __isl_null isl_multi_aff *isl_multi_aff_free(
2864 __isl_take isl_multi_aff *maff);
2865 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_copy(
2866 __isl_keep isl_multi_pw_aff *mpa);
2867 __isl_null isl_multi_pw_aff *isl_multi_pw_aff_free(
2868 __isl_take isl_multi_pw_aff *mpa);
2869 __isl_give isl_multi_union_pw_aff *
2870 isl_multi_union_pw_aff_copy(
2871 __isl_keep isl_multi_union_pw_aff *mupa);
2872 __isl_null isl_multi_union_pw_aff *
2873 isl_multi_union_pw_aff_free(
2874 __isl_take isl_multi_union_pw_aff *mupa);
2876 The base expression at a given position of a multiple
2877 expression can be extracted using the following functions.
2879 #include <isl/val.h>
2880 __isl_give isl_val *isl_multi_val_get_val(
2881 __isl_keep isl_multi_val *mv, int pos);
2883 #include <isl/aff.h>
2884 __isl_give isl_aff *isl_multi_aff_get_aff(
2885 __isl_keep isl_multi_aff *multi, int pos);
2886 __isl_give isl_pw_aff *isl_multi_pw_aff_get_pw_aff(
2887 __isl_keep isl_multi_pw_aff *mpa, int pos);
2888 __isl_give isl_union_pw_aff *
2889 isl_multi_union_pw_aff_get_union_pw_aff(
2890 __isl_keep isl_multi_union_pw_aff *mupa, int pos);
2892 It can be replaced using the following functions.
2894 #include <isl/val.h>
2895 __isl_give isl_multi_val *isl_multi_val_set_val(
2896 __isl_take isl_multi_val *mv, int pos,
2897 __isl_take isl_val *val);
2899 #include <isl/aff.h>
2900 __isl_give isl_multi_aff *isl_multi_aff_set_aff(
2901 __isl_take isl_multi_aff *multi, int pos,
2902 __isl_take isl_aff *aff);
2903 __isl_give isl_multi_union_pw_aff *
2904 isl_multi_union_pw_aff_set_union_pw_aff(
2905 __isl_take isl_multi_union_pw_aff *mupa, int pos,
2906 __isl_take isl_union_pw_aff *upa);
2908 As a convenience, a sequence of base expressions that have
2909 their domains in a given space can be extracted from a sequence
2910 of union expressions using the following function.
2912 #include <isl/aff.h>
2913 __isl_give isl_multi_pw_aff *
2914 isl_multi_union_pw_aff_extract_multi_pw_aff(
2915 __isl_keep isl_multi_union_pw_aff *mupa,
2916 __isl_take isl_space *space);
2918 Note that there is a difference between C<isl_multi_union_pw_aff>
2919 and C<isl_union_pw_multi_aff> objects. The first is a sequence
2920 of unions of piecewise expressions, while the second is a union
2921 of piecewise sequences. In particular, multiple affine expressions
2922 in an C<isl_union_pw_multi_aff> may live in different spaces,
2923 while there is only a single multiple expression in
2924 an C<isl_multi_union_pw_aff>, which can therefore only live
2925 in a single space. This means that not every
2926 C<isl_union_pw_multi_aff> can be converted to
2927 an C<isl_multi_union_pw_aff>. Conversely, a zero-dimensional
2928 C<isl_multi_union_pw_aff> carries no information
2929 about any possible domain and therefore cannot be converted
2930 to an C<isl_union_pw_multi_aff>. Moreover, the elements
2931 of an C<isl_multi_union_pw_aff> may be defined over different domains,
2932 while each multiple expression inside an C<isl_union_pw_multi_aff>
2933 has a single domain. The conversion of an C<isl_union_pw_multi_aff>
2934 of dimension greater than one may therefore not be exact.
2935 The following functions can
2936 be used to perform these conversions when they are possible.
2938 #include <isl/aff.h>
2939 __isl_give isl_multi_union_pw_aff *
2940 isl_multi_union_pw_aff_from_union_pw_multi_aff(
2941 __isl_take isl_union_pw_multi_aff *upma);
2942 __isl_give isl_union_pw_multi_aff *
2943 isl_union_pw_multi_aff_from_multi_union_pw_aff(
2944 __isl_take isl_multi_union_pw_aff *mupa);
2946 =head3 Piecewise Expressions
2948 A piecewise expression is an expression that is described
2949 using zero or more base expression defined over the same
2950 number of cells in the domain space of the base expressions.
2951 All base expressions are defined over the same
2952 domain space and the cells are disjoint.
2953 The space of a piecewise expression is the same as
2954 that of the base expressions.
2955 If the union of the cells is a strict subset of the domain
2956 space, then the value of the piecewise expression outside
2957 this union is different for types derived from quasi-affine
2958 expressions and those derived from quasipolynomials.
2959 Piecewise expressions derived from quasi-affine expressions
2960 are considered to be undefined outside the union of their cells.
2961 Piecewise expressions derived from quasipolynomials
2962 are considered to be zero outside the union of their cells.
2964 Piecewise quasipolynomials are mainly used by the C<barvinok>
2965 library for representing the number of elements in a parametric set or map.
2966 For example, the piecewise quasipolynomial
2968 [n] -> { [x] -> ((1 + n) - x) : x <= n and x >= 0 }
2970 represents the number of points in the map
2972 [n] -> { [x] -> [y] : x,y >= 0 and 0 <= x + y <= n }
2974 The piecewise expression types defined by C<isl>
2975 are C<isl_pw_aff>, C<isl_pw_multi_aff>,
2976 C<isl_pw_qpolynomial> and C<isl_pw_qpolynomial_fold>.
2978 A piecewise expression with no cells can be created using
2979 the following functions.
2981 #include <isl/aff.h>
2982 __isl_give isl_pw_aff *isl_pw_aff_empty(
2983 __isl_take isl_space *space);
2984 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_empty(
2985 __isl_take isl_space *space);
2987 A piecewise expression with a single universe cell can be
2988 created using the following functions.
2990 #include <isl/aff.h>
2991 __isl_give isl_pw_aff *isl_pw_aff_from_aff(
2992 __isl_take isl_aff *aff);
2993 __isl_give isl_pw_multi_aff *
2994 isl_pw_multi_aff_from_multi_aff(
2995 __isl_take isl_multi_aff *ma);
2997 #include <isl/polynomial.h>
2998 __isl_give isl_pw_qpolynomial *
2999 isl_pw_qpolynomial_from_qpolynomial(
3000 __isl_take isl_qpolynomial *qp);
3002 A piecewise expression with a single specified cell can be
3003 created using the following functions.
3005 #include <isl/aff.h>
3006 __isl_give isl_pw_aff *isl_pw_aff_alloc(
3007 __isl_take isl_set *set, __isl_take isl_aff *aff);
3008 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_alloc(
3009 __isl_take isl_set *set,
3010 __isl_take isl_multi_aff *maff);
3012 #include <isl/polynomial.h>
3013 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_alloc(
3014 __isl_take isl_set *set,
3015 __isl_take isl_qpolynomial *qp);
3017 The following convenience functions first create a base expression and
3018 then create a piecewise expression over a universe domain.
3020 #include <isl/aff.h>
3021 __isl_give isl_pw_aff *isl_pw_aff_zero_on_domain(
3022 __isl_take isl_local_space *ls);
3023 __isl_give isl_pw_aff *isl_pw_aff_var_on_domain(
3024 __isl_take isl_local_space *ls,
3025 enum isl_dim_type type, unsigned pos);
3026 __isl_give isl_pw_aff *isl_pw_aff_nan_on_domain(
3027 __isl_take isl_local_space *ls);
3028 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_zero(
3029 __isl_take isl_space *space);
3030 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_identity(
3031 __isl_take isl_space *space);
3032 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_map(
3033 __isl_take isl_space *space);
3034 __isl_give isl_pw_multi_aff *
3035 isl_pw_multi_aff_project_out_map(
3036 __isl_take isl_space *space,
3037 enum isl_dim_type type,
3038 unsigned first, unsigned n);
3040 #include <isl/polynomial.h>
3041 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_zero(
3042 __isl_take isl_space *space);
3044 The following convenience functions first create a base expression and
3045 then create a piecewise expression over a given domain.
3047 #include <isl/aff.h>
3048 __isl_give isl_pw_aff *isl_pw_aff_val_on_domain(
3049 __isl_take isl_set *domain,
3050 __isl_take isl_val *v);
3051 __isl_give isl_pw_multi_aff *
3052 isl_pw_multi_aff_multi_val_on_domain(
3053 __isl_take isl_set *domain,
3054 __isl_take isl_multi_val *mv);
3056 As a convenience, a piecewise multiple expression can
3057 also be created from a piecewise expression.
3058 Each multiple expression in the result is derived
3059 from the corresponding base expression.
3061 #include <isl/aff.h>
3062 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_pw_aff(
3063 __isl_take isl_pw_aff *pa);
3065 Similarly, a piecewise quasipolynomial can be
3066 created from a piecewise quasi-affine expression using
3067 the following function.
3069 #include <isl/polynomial.h>
3070 __isl_give isl_pw_qpolynomial *
3071 isl_pw_qpolynomial_from_pw_aff(
3072 __isl_take isl_pw_aff *pwaff);
3074 Piecewise expressions can be copied and freed using the following functions.
3076 #include <isl/aff.h>
3077 __isl_give isl_pw_aff *isl_pw_aff_copy(
3078 __isl_keep isl_pw_aff *pwaff);
3079 __isl_null isl_pw_aff *isl_pw_aff_free(
3080 __isl_take isl_pw_aff *pwaff);
3081 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_copy(
3082 __isl_keep isl_pw_multi_aff *pma);
3083 __isl_null isl_pw_multi_aff *isl_pw_multi_aff_free(
3084 __isl_take isl_pw_multi_aff *pma);
3086 #include <isl/polynomial.h>
3087 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_copy(
3088 __isl_keep isl_pw_qpolynomial *pwqp);
3089 __isl_null isl_pw_qpolynomial *isl_pw_qpolynomial_free(
3090 __isl_take isl_pw_qpolynomial *pwqp);
3091 __isl_give isl_pw_qpolynomial_fold *
3092 isl_pw_qpolynomial_fold_copy(
3093 __isl_keep isl_pw_qpolynomial_fold *pwf);
3094 __isl_null isl_pw_qpolynomial_fold *
3095 isl_pw_qpolynomial_fold_free(
3096 __isl_take isl_pw_qpolynomial_fold *pwf);
3098 To iterate over the different cells of a piecewise expression,
3099 use the following functions.
3101 #include <isl/aff.h>
3102 isl_bool isl_pw_aff_is_empty(__isl_keep isl_pw_aff *pwaff);
3103 int isl_pw_aff_n_piece(__isl_keep isl_pw_aff *pwaff);
3104 isl_stat isl_pw_aff_foreach_piece(
3105 __isl_keep isl_pw_aff *pwaff,
3106 isl_stat (*fn)(__isl_take isl_set *set,
3107 __isl_take isl_aff *aff,
3108 void *user), void *user);
3109 int isl_pw_multi_aff_n_piece(
3110 __isl_keep isl_pw_multi_aff *pma);
3111 isl_stat isl_pw_multi_aff_foreach_piece(
3112 __isl_keep isl_pw_multi_aff *pma,
3113 isl_stat (*fn)(__isl_take isl_set *set,
3114 __isl_take isl_multi_aff *maff,
3115 void *user), void *user);
3117 #include <isl/polynomial.h>
3118 int isl_pw_qpolynomial_n_piece(
3119 __isl_keep isl_pw_qpolynomial *pwqp);
3120 isl_stat isl_pw_qpolynomial_foreach_piece(
3121 __isl_keep isl_pw_qpolynomial *pwqp,
3122 isl_stat (*fn)(__isl_take isl_set *set,
3123 __isl_take isl_qpolynomial *qp,
3124 void *user), void *user);
3125 isl_stat isl_pw_qpolynomial_foreach_lifted_piece(
3126 __isl_keep isl_pw_qpolynomial *pwqp,
3127 isl_stat (*fn)(__isl_take isl_set *set,
3128 __isl_take isl_qpolynomial *qp,
3129 void *user), void *user);
3130 int isl_pw_qpolynomial_fold_n_piece(
3131 __isl_keep isl_pw_qpolynomial_fold *pwf);
3132 isl_stat isl_pw_qpolynomial_fold_foreach_piece(
3133 __isl_keep isl_pw_qpolynomial_fold *pwf,
3134 isl_stat (*fn)(__isl_take isl_set *set,
3135 __isl_take isl_qpolynomial_fold *fold,
3136 void *user), void *user);
3137 isl_stat isl_pw_qpolynomial_fold_foreach_lifted_piece(
3138 __isl_keep isl_pw_qpolynomial_fold *pwf,
3139 isl_stat (*fn)(__isl_take isl_set *set,
3140 __isl_take isl_qpolynomial_fold *fold,
3141 void *user), void *user);
3143 As usual, the function C<fn> should return C<0> on success
3144 and C<-1> on failure. The difference between
3145 C<isl_pw_qpolynomial_foreach_piece> and
3146 C<isl_pw_qpolynomial_foreach_lifted_piece> is that
3147 C<isl_pw_qpolynomial_foreach_lifted_piece> will first
3148 compute unique representations for all existentially quantified
3149 variables and then turn these existentially quantified variables
3150 into extra set variables, adapting the associated quasipolynomial
3151 accordingly. This means that the C<set> passed to C<fn>
3152 will not have any existentially quantified variables, but that
3153 the dimensions of the sets may be different for different
3154 invocations of C<fn>.
3155 Similarly for C<isl_pw_qpolynomial_fold_foreach_piece>
3156 and C<isl_pw_qpolynomial_fold_foreach_lifted_piece>.
3158 A piecewise expression consisting of the expressions at a given
3159 position of a piecewise multiple expression can be extracted
3160 using the following function.
3162 #include <isl/aff.h>
3163 __isl_give isl_pw_aff *isl_pw_multi_aff_get_pw_aff(
3164 __isl_keep isl_pw_multi_aff *pma, int pos);
3166 These expressions can be replaced using the following function.
3168 #include <isl/aff.h>
3169 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_pw_aff(
3170 __isl_take isl_pw_multi_aff *pma, unsigned pos,
3171 __isl_take isl_pw_aff *pa);
3173 Note that there is a difference between C<isl_multi_pw_aff> and
3174 C<isl_pw_multi_aff> objects. The first is a sequence of piecewise
3175 affine expressions, while the second is a piecewise sequence
3176 of affine expressions. In particular, each of the piecewise
3177 affine expressions in an C<isl_multi_pw_aff> may have a different
3178 domain, while all multiple expressions associated to a cell
3179 in an C<isl_pw_multi_aff> have the same domain.
3180 It is possible to convert between the two, but when converting
3181 an C<isl_multi_pw_aff> to an C<isl_pw_multi_aff>, the domain
3182 of the result is the intersection of the domains of the input.
3183 The reverse conversion is exact.
3185 #include <isl/aff.h>
3186 __isl_give isl_pw_multi_aff *
3187 isl_pw_multi_aff_from_multi_pw_aff(
3188 __isl_take isl_multi_pw_aff *mpa);
3189 __isl_give isl_multi_pw_aff *
3190 isl_multi_pw_aff_from_pw_multi_aff(
3191 __isl_take isl_pw_multi_aff *pma);
3193 =head3 Union Expressions
3195 A union expression collects base expressions defined
3196 over different domains. The space of a union expression
3197 is that of the shared parameter space.
3199 The union expression types defined by C<isl>
3200 are C<isl_union_pw_aff>, C<isl_union_pw_multi_aff>,
3201 C<isl_union_pw_qpolynomial> and C<isl_union_pw_qpolynomial_fold>.
3203 C<isl_union_pw_aff>,
3204 C<isl_union_pw_qpolynomial> and C<isl_union_pw_qpolynomial_fold>,
3205 there can be at most one base expression for a given domain space.
3207 C<isl_union_pw_multi_aff>,
3208 there can be multiple such expressions for a given domain space,
3209 but the domains of these expressions need to be disjoint.
3211 An empty union expression can be created using the following functions.
3213 #include <isl/aff.h>
3214 __isl_give isl_union_pw_aff *isl_union_pw_aff_empty(
3215 __isl_take isl_space *space);
3216 __isl_give isl_union_pw_multi_aff *
3217 isl_union_pw_multi_aff_empty(
3218 __isl_take isl_space *space);
3220 #include <isl/polynomial.h>
3221 __isl_give isl_union_pw_qpolynomial *
3222 isl_union_pw_qpolynomial_zero(
3223 __isl_take isl_space *space);
3225 A union expression containing a single base expression
3226 can be created using the following functions.
3228 #include <isl/aff.h>
3229 __isl_give isl_union_pw_aff *
3230 isl_union_pw_aff_from_pw_aff(
3231 __isl_take isl_pw_aff *pa);
3232 __isl_give isl_union_pw_multi_aff *
3233 isl_union_pw_multi_aff_from_aff(
3234 __isl_take isl_aff *aff);
3235 __isl_give isl_union_pw_multi_aff *
3236 isl_union_pw_multi_aff_from_pw_multi_aff(
3237 __isl_take isl_pw_multi_aff *pma);
3239 #include <isl/polynomial.h>
3240 __isl_give isl_union_pw_qpolynomial *
3241 isl_union_pw_qpolynomial_from_pw_qpolynomial(
3242 __isl_take isl_pw_qpolynomial *pwqp);
3244 The following functions create a base expression on each
3245 of the sets in the union set and collect the results.
3247 #include <isl/aff.h>
3248 __isl_give isl_union_pw_multi_aff *
3249 isl_union_pw_multi_aff_from_union_pw_aff(
3250 __isl_take isl_union_pw_aff *upa);
3251 __isl_give isl_union_pw_aff *
3252 isl_union_pw_multi_aff_get_union_pw_aff(
3253 __isl_keep isl_union_pw_multi_aff *upma, int pos);
3254 __isl_give isl_union_pw_aff *
3255 isl_union_pw_aff_val_on_domain(
3256 __isl_take isl_union_set *domain,
3257 __isl_take isl_val *v);
3258 __isl_give isl_union_pw_multi_aff *
3259 isl_union_pw_multi_aff_multi_val_on_domain(
3260 __isl_take isl_union_set *domain,
3261 __isl_take isl_multi_val *mv);
3263 An C<isl_union_pw_aff> that is equal to a (parametric) affine
3264 expression on a given domain can be created using the following
3267 #include <isl/aff.h>
3268 __isl_give isl_union_pw_aff *
3269 isl_union_pw_aff_aff_on_domain(
3270 __isl_take isl_union_set *domain,
3271 __isl_take isl_aff *aff);
3273 A base expression can be added to a union expression using
3274 the following functions.
3276 #include <isl/aff.h>
3277 __isl_give isl_union_pw_aff *
3278 isl_union_pw_aff_add_pw_aff(
3279 __isl_take isl_union_pw_aff *upa,
3280 __isl_take isl_pw_aff *pa);
3281 __isl_give isl_union_pw_multi_aff *
3282 isl_union_pw_multi_aff_add_pw_multi_aff(
3283 __isl_take isl_union_pw_multi_aff *upma,
3284 __isl_take isl_pw_multi_aff *pma);
3286 #include <isl/polynomial.h>
3287 __isl_give isl_union_pw_qpolynomial *
3288 isl_union_pw_qpolynomial_add_pw_qpolynomial(
3289 __isl_take isl_union_pw_qpolynomial *upwqp,
3290 __isl_take isl_pw_qpolynomial *pwqp);
3292 Union expressions can be copied and freed using
3293 the following functions.
3295 #include <isl/aff.h>
3296 __isl_give isl_union_pw_aff *isl_union_pw_aff_copy(
3297 __isl_keep isl_union_pw_aff *upa);
3298 __isl_null isl_union_pw_aff *isl_union_pw_aff_free(
3299 __isl_take isl_union_pw_aff *upa);
3300 __isl_give isl_union_pw_multi_aff *
3301 isl_union_pw_multi_aff_copy(
3302 __isl_keep isl_union_pw_multi_aff *upma);
3303 __isl_null isl_union_pw_multi_aff *
3304 isl_union_pw_multi_aff_free(
3305 __isl_take isl_union_pw_multi_aff *upma);
3307 #include <isl/polynomial.h>
3308 __isl_give isl_union_pw_qpolynomial *
3309 isl_union_pw_qpolynomial_copy(
3310 __isl_keep isl_union_pw_qpolynomial *upwqp);
3311 __isl_null isl_union_pw_qpolynomial *
3312 isl_union_pw_qpolynomial_free(
3313 __isl_take isl_union_pw_qpolynomial *upwqp);
3314 __isl_give isl_union_pw_qpolynomial_fold *
3315 isl_union_pw_qpolynomial_fold_copy(
3316 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
3317 __isl_null isl_union_pw_qpolynomial_fold *
3318 isl_union_pw_qpolynomial_fold_free(
3319 __isl_take isl_union_pw_qpolynomial_fold *upwf);
3321 To iterate over the base expressions in a union expression,
3322 use the following functions.
3324 #include <isl/aff.h>
3325 int isl_union_pw_aff_n_pw_aff(
3326 __isl_keep isl_union_pw_aff *upa);
3327 isl_stat isl_union_pw_aff_foreach_pw_aff(
3328 __isl_keep isl_union_pw_aff *upa,
3329 isl_stat (*fn)(__isl_take isl_pw_aff *pa,
3330 void *user), void *user);
3331 int isl_union_pw_multi_aff_n_pw_multi_aff(
3332 __isl_keep isl_union_pw_multi_aff *upma);
3333 isl_stat isl_union_pw_multi_aff_foreach_pw_multi_aff(
3334 __isl_keep isl_union_pw_multi_aff *upma,
3335 isl_stat (*fn)(__isl_take isl_pw_multi_aff *pma,
3336 void *user), void *user);
3338 #include <isl/polynomial.h>
3339 int isl_union_pw_qpolynomial_n_pw_qpolynomial(
3340 __isl_keep isl_union_pw_qpolynomial *upwqp);
3341 isl_stat isl_union_pw_qpolynomial_foreach_pw_qpolynomial(
3342 __isl_keep isl_union_pw_qpolynomial *upwqp,
3343 isl_stat (*fn)(__isl_take isl_pw_qpolynomial *pwqp,
3344 void *user), void *user);
3345 int isl_union_pw_qpolynomial_fold_n_pw_qpolynomial_fold(
3346 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
3347 isl_stat isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(
3348 __isl_keep isl_union_pw_qpolynomial_fold *upwf,
3349 isl_stat (*fn)(__isl_take isl_pw_qpolynomial_fold *pwf,
3350 void *user), void *user);
3352 To extract the base expression in a given space from a union, use
3353 the following functions.
3355 #include <isl/aff.h>
3356 __isl_give isl_pw_aff *isl_union_pw_aff_extract_pw_aff(
3357 __isl_keep isl_union_pw_aff *upa,
3358 __isl_take isl_space *space);
3359 __isl_give isl_pw_multi_aff *
3360 isl_union_pw_multi_aff_extract_pw_multi_aff(
3361 __isl_keep isl_union_pw_multi_aff *upma,
3362 __isl_take isl_space *space);
3364 #include <isl/polynomial.h>
3365 __isl_give isl_pw_qpolynomial *
3366 isl_union_pw_qpolynomial_extract_pw_qpolynomial(
3367 __isl_keep isl_union_pw_qpolynomial *upwqp,
3368 __isl_take isl_space *space);
3370 =head2 Input and Output
3372 For set and relation,
3373 C<isl> supports its own input/output format, which is similar
3374 to the C<Omega> format, but also supports the C<PolyLib> format
3376 For other object types, typically only an C<isl> format is supported.
3378 =head3 C<isl> format
3380 The C<isl> format is similar to that of C<Omega>, but has a different
3381 syntax for describing the parameters and allows for the definition
3382 of an existentially quantified variable as the integer division
3383 of an affine expression.
3384 For example, the set of integers C<i> between C<0> and C<n>
3385 such that C<i % 10 <= 6> can be described as
3387 [n] -> { [i] : exists (a = [i/10] : 0 <= i and i <= n and
3390 A set or relation can have several disjuncts, separated
3391 by the keyword C<or>. Each disjunct is either a conjunction
3392 of constraints or a projection (C<exists>) of a conjunction
3393 of constraints. The constraints are separated by the keyword
3396 =head3 C<PolyLib> format
3398 If the represented set is a union, then the first line
3399 contains a single number representing the number of disjuncts.
3400 Otherwise, a line containing the number C<1> is optional.
3402 Each disjunct is represented by a matrix of constraints.
3403 The first line contains two numbers representing
3404 the number of rows and columns,
3405 where the number of rows is equal to the number of constraints
3406 and the number of columns is equal to two plus the number of variables.
3407 The following lines contain the actual rows of the constraint matrix.
3408 In each row, the first column indicates whether the constraint
3409 is an equality (C<0>) or inequality (C<1>). The final column
3410 corresponds to the constant term.
3412 If the set is parametric, then the coefficients of the parameters
3413 appear in the last columns before the constant column.
3414 The coefficients of any existentially quantified variables appear
3415 between those of the set variables and those of the parameters.
3417 =head3 Extended C<PolyLib> format
3419 The extended C<PolyLib> format is nearly identical to the
3420 C<PolyLib> format. The only difference is that the line
3421 containing the number of rows and columns of a constraint matrix
3422 also contains four additional numbers:
3423 the number of output dimensions, the number of input dimensions,
3424 the number of local dimensions (i.e., the number of existentially
3425 quantified variables) and the number of parameters.
3426 For sets, the number of ``output'' dimensions is equal
3427 to the number of set dimensions, while the number of ``input''
3432 Objects can be read from input using the following functions.
3434 #include <isl/val.h>
3435 __isl_give isl_val *isl_val_read_from_str(isl_ctx *ctx,
3437 __isl_give isl_multi_val *isl_multi_val_read_from_str(
3438 isl_ctx *ctx, const char *str);
3440 #include <isl/set.h>
3441 __isl_give isl_basic_set *isl_basic_set_read_from_file(
3442 isl_ctx *ctx, FILE *input);
3443 __isl_give isl_basic_set *isl_basic_set_read_from_str(
3444 isl_ctx *ctx, const char *str);
3445 __isl_give isl_set *isl_set_read_from_file(isl_ctx *ctx,
3447 __isl_give isl_set *isl_set_read_from_str(isl_ctx *ctx,
3450 #include <isl/map.h>
3451 __isl_give isl_basic_map *isl_basic_map_read_from_file(
3452 isl_ctx *ctx, FILE *input);
3453 __isl_give isl_basic_map *isl_basic_map_read_from_str(
3454 isl_ctx *ctx, const char *str);
3455 __isl_give isl_map *isl_map_read_from_file(
3456 isl_ctx *ctx, FILE *input);
3457 __isl_give isl_map *isl_map_read_from_str(isl_ctx *ctx,
3460 #include <isl/union_set.h>
3461 __isl_give isl_union_set *isl_union_set_read_from_file(
3462 isl_ctx *ctx, FILE *input);
3463 __isl_give isl_union_set *isl_union_set_read_from_str(
3464 isl_ctx *ctx, const char *str);
3466 #include <isl/union_map.h>
3467 __isl_give isl_union_map *isl_union_map_read_from_file(
3468 isl_ctx *ctx, FILE *input);
3469 __isl_give isl_union_map *isl_union_map_read_from_str(
3470 isl_ctx *ctx, const char *str);
3472 #include <isl/aff.h>
3473 __isl_give isl_aff *isl_aff_read_from_str(
3474 isl_ctx *ctx, const char *str);
3475 __isl_give isl_multi_aff *isl_multi_aff_read_from_str(
3476 isl_ctx *ctx, const char *str);
3477 __isl_give isl_pw_aff *isl_pw_aff_read_from_str(
3478 isl_ctx *ctx, const char *str);
3479 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_read_from_str(
3480 isl_ctx *ctx, const char *str);
3481 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_read_from_str(
3482 isl_ctx *ctx, const char *str);
3483 __isl_give isl_union_pw_aff *
3484 isl_union_pw_aff_read_from_str(
3485 isl_ctx *ctx, const char *str);
3486 __isl_give isl_union_pw_multi_aff *
3487 isl_union_pw_multi_aff_read_from_str(
3488 isl_ctx *ctx, const char *str);
3489 __isl_give isl_multi_union_pw_aff *
3490 isl_multi_union_pw_aff_read_from_str(
3491 isl_ctx *ctx, const char *str);
3493 #include <isl/polynomial.h>
3494 __isl_give isl_union_pw_qpolynomial *
3495 isl_union_pw_qpolynomial_read_from_str(
3496 isl_ctx *ctx, const char *str);
3498 For sets and relations,
3499 the input format is autodetected and may be either the C<PolyLib> format
3500 or the C<isl> format.
3504 Before anything can be printed, an C<isl_printer> needs to
3507 __isl_give isl_printer *isl_printer_to_file(isl_ctx *ctx,
3509 __isl_give isl_printer *isl_printer_to_str(isl_ctx *ctx);
3510 __isl_null isl_printer *isl_printer_free(
3511 __isl_take isl_printer *printer);
3513 C<isl_printer_to_file> prints to the given file, while
3514 C<isl_printer_to_str> prints to a string that can be extracted
3515 using the following function.
3517 #include <isl/printer.h>
3518 __isl_give char *isl_printer_get_str(
3519 __isl_keep isl_printer *printer);
3521 The printer can be inspected using the following functions.
3523 FILE *isl_printer_get_file(
3524 __isl_keep isl_printer *printer);
3525 int isl_printer_get_output_format(
3526 __isl_keep isl_printer *p);
3527 int isl_printer_get_yaml_style(__isl_keep isl_printer *p);
3529 The behavior of the printer can be modified in various ways
3531 __isl_give isl_printer *isl_printer_set_output_format(
3532 __isl_take isl_printer *p, int output_format);
3533 __isl_give isl_printer *isl_printer_set_indent(
3534 __isl_take isl_printer *p, int indent);
3535 __isl_give isl_printer *isl_printer_set_indent_prefix(
3536 __isl_take isl_printer *p, const char *prefix);
3537 __isl_give isl_printer *isl_printer_indent(
3538 __isl_take isl_printer *p, int indent);
3539 __isl_give isl_printer *isl_printer_set_prefix(
3540 __isl_take isl_printer *p, const char *prefix);
3541 __isl_give isl_printer *isl_printer_set_suffix(
3542 __isl_take isl_printer *p, const char *suffix);
3543 __isl_give isl_printer *isl_printer_set_yaml_style(
3544 __isl_take isl_printer *p, int yaml_style);
3546 The C<output_format> may be either C<ISL_FORMAT_ISL>, C<ISL_FORMAT_OMEGA>,
3547 C<ISL_FORMAT_POLYLIB>, C<ISL_FORMAT_EXT_POLYLIB> or C<ISL_FORMAT_LATEX>
3548 and defaults to C<ISL_FORMAT_ISL>.
3549 Each line in the output is prefixed by C<indent_prefix>,
3550 indented by C<indent> (set by C<isl_printer_set_indent>) spaces
3551 (default: 0), prefixed by C<prefix> and suffixed by C<suffix>.
3552 In the C<PolyLib> format output,
3553 the coefficients of the existentially quantified variables
3554 appear between those of the set variables and those
3556 The function C<isl_printer_indent> increases the indentation
3557 by the specified amount (which may be negative).
3558 The YAML style may be either C<ISL_YAML_STYLE_BLOCK> or
3559 C<ISL_YAML_STYLE_FLOW> and when we are printing something
3562 To actually print something, use
3564 #include <isl/printer.h>
3565 __isl_give isl_printer *isl_printer_print_double(
3566 __isl_take isl_printer *p, double d);
3568 #include <isl/val.h>
3569 __isl_give isl_printer *isl_printer_print_val(
3570 __isl_take isl_printer *p, __isl_keep isl_val *v);
3572 #include <isl/set.h>
3573 __isl_give isl_printer *isl_printer_print_basic_set(
3574 __isl_take isl_printer *printer,
3575 __isl_keep isl_basic_set *bset);
3576 __isl_give isl_printer *isl_printer_print_set(
3577 __isl_take isl_printer *printer,
3578 __isl_keep isl_set *set);
3580 #include <isl/map.h>
3581 __isl_give isl_printer *isl_printer_print_basic_map(
3582 __isl_take isl_printer *printer,
3583 __isl_keep isl_basic_map *bmap);
3584 __isl_give isl_printer *isl_printer_print_map(
3585 __isl_take isl_printer *printer,
3586 __isl_keep isl_map *map);
3588 #include <isl/union_set.h>
3589 __isl_give isl_printer *isl_printer_print_union_set(
3590 __isl_take isl_printer *p,
3591 __isl_keep isl_union_set *uset);
3593 #include <isl/union_map.h>
3594 __isl_give isl_printer *isl_printer_print_union_map(
3595 __isl_take isl_printer *p,
3596 __isl_keep isl_union_map *umap);
3598 #include <isl/val.h>
3599 __isl_give isl_printer *isl_printer_print_multi_val(
3600 __isl_take isl_printer *p,
3601 __isl_keep isl_multi_val *mv);
3603 #include <isl/aff.h>
3604 __isl_give isl_printer *isl_printer_print_aff(
3605 __isl_take isl_printer *p, __isl_keep isl_aff *aff);
3606 __isl_give isl_printer *isl_printer_print_multi_aff(
3607 __isl_take isl_printer *p,
3608 __isl_keep isl_multi_aff *maff);
3609 __isl_give isl_printer *isl_printer_print_pw_aff(
3610 __isl_take isl_printer *p,
3611 __isl_keep isl_pw_aff *pwaff);
3612 __isl_give isl_printer *isl_printer_print_pw_multi_aff(
3613 __isl_take isl_printer *p,
3614 __isl_keep isl_pw_multi_aff *pma);
3615 __isl_give isl_printer *isl_printer_print_multi_pw_aff(
3616 __isl_take isl_printer *p,
3617 __isl_keep isl_multi_pw_aff *mpa);
3618 __isl_give isl_printer *isl_printer_print_union_pw_aff(
3619 __isl_take isl_printer *p,
3620 __isl_keep isl_union_pw_aff *upa);
3621 __isl_give isl_printer *isl_printer_print_union_pw_multi_aff(
3622 __isl_take isl_printer *p,
3623 __isl_keep isl_union_pw_multi_aff *upma);
3624 __isl_give isl_printer *
3625 isl_printer_print_multi_union_pw_aff(
3626 __isl_take isl_printer *p,
3627 __isl_keep isl_multi_union_pw_aff *mupa);
3629 #include <isl/polynomial.h>
3630 __isl_give isl_printer *isl_printer_print_qpolynomial(
3631 __isl_take isl_printer *p,
3632 __isl_keep isl_qpolynomial *qp);
3633 __isl_give isl_printer *isl_printer_print_pw_qpolynomial(
3634 __isl_take isl_printer *p,
3635 __isl_keep isl_pw_qpolynomial *pwqp);
3636 __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial(
3637 __isl_take isl_printer *p,
3638 __isl_keep isl_union_pw_qpolynomial *upwqp);
3640 __isl_give isl_printer *
3641 isl_printer_print_pw_qpolynomial_fold(
3642 __isl_take isl_printer *p,
3643 __isl_keep isl_pw_qpolynomial_fold *pwf);
3644 __isl_give isl_printer *
3645 isl_printer_print_union_pw_qpolynomial_fold(
3646 __isl_take isl_printer *p,
3647 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
3649 For C<isl_printer_print_qpolynomial>,
3650 C<isl_printer_print_pw_qpolynomial> and
3651 C<isl_printer_print_pw_qpolynomial_fold>,
3652 the output format of the printer
3653 needs to be set to either C<ISL_FORMAT_ISL> or C<ISL_FORMAT_C>.
3654 For C<isl_printer_print_union_pw_qpolynomial> and
3655 C<isl_printer_print_union_pw_qpolynomial_fold>, only C<ISL_FORMAT_ISL>
3657 In case of printing in C<ISL_FORMAT_C>, the user may want
3658 to set the names of all dimensions first.
3660 C<isl> also provides limited support for printing YAML documents,
3661 just enough for the internal use for printing such documents.
3663 #include <isl/printer.h>
3664 __isl_give isl_printer *isl_printer_yaml_start_mapping(
3665 __isl_take isl_printer *p);
3666 __isl_give isl_printer *isl_printer_yaml_end_mapping(
3667 __isl_take isl_printer *p);
3668 __isl_give isl_printer *isl_printer_yaml_start_sequence(
3669 __isl_take isl_printer *p);
3670 __isl_give isl_printer *isl_printer_yaml_end_sequence(
3671 __isl_take isl_printer *p);
3672 __isl_give isl_printer *isl_printer_yaml_next(
3673 __isl_take isl_printer *p);
3675 A document is started by a call to either
3676 C<isl_printer_yaml_start_mapping> or C<isl_printer_yaml_start_sequence>.
3677 Anything printed to the printer after such a call belong to the
3678 first key of the mapping or the first element in the sequence.
3679 The function C<isl_printer_yaml_next> moves to the value if
3680 we are currently printing a mapping key, the next key if we
3681 are printing a value or the next element if we are printing
3682 an element in a sequence.
3683 Nested mappings and sequences are initiated by the same
3684 C<isl_printer_yaml_start_mapping> or C<isl_printer_yaml_start_sequence>.
3685 Each call to these functions needs to have a corresponding call to
3686 C<isl_printer_yaml_end_mapping> or C<isl_printer_yaml_end_sequence>.
3688 When called on a file printer, the following function flushes
3689 the file. When called on a string printer, the buffer is cleared.
3691 __isl_give isl_printer *isl_printer_flush(
3692 __isl_take isl_printer *p);
3694 The following functions allow the user to attach
3695 notes to a printer in order to keep track of additional state.
3697 #include <isl/printer.h>
3698 isl_bool isl_printer_has_note(__isl_keep isl_printer *p,
3699 __isl_keep isl_id *id);
3700 __isl_give isl_id *isl_printer_get_note(
3701 __isl_keep isl_printer *p, __isl_take isl_id *id);
3702 __isl_give isl_printer *isl_printer_set_note(
3703 __isl_take isl_printer *p,
3704 __isl_take isl_id *id, __isl_take isl_id *note);
3706 C<isl_printer_set_note> associates the given note to the given
3707 identifier in the printer.
3708 C<isl_printer_get_note> retrieves a note associated to an
3710 C<isl_printer_has_note> checks if there is such a note.
3711 C<isl_printer_get_note> fails if the requested note does not exist.
3713 Alternatively, a string representation can be obtained
3714 directly using the following functions, which always print
3718 __isl_give char *isl_id_to_str(
3719 __isl_keep isl_id *id);
3721 #include <isl/space.h>
3722 __isl_give char *isl_space_to_str(
3723 __isl_keep isl_space *space);
3725 #include <isl/val.h>
3726 __isl_give char *isl_val_to_str(__isl_keep isl_val *v);
3727 __isl_give char *isl_multi_val_to_str(
3728 __isl_keep isl_multi_val *mv);
3730 #include <isl/set.h>
3731 __isl_give char *isl_basic_set_to_str(
3732 __isl_keep isl_basic_set *bset);
3733 __isl_give char *isl_set_to_str(
3734 __isl_keep isl_set *set);
3736 #include <isl/union_set.h>
3737 __isl_give char *isl_union_set_to_str(
3738 __isl_keep isl_union_set *uset);
3740 #include <isl/map.h>
3741 __isl_give char *isl_basic_map_to_str(
3742 __isl_keep isl_basic_map *bmap);
3743 __isl_give char *isl_map_to_str(
3744 __isl_keep isl_map *map);
3746 #include <isl/union_map.h>
3747 __isl_give char *isl_union_map_to_str(
3748 __isl_keep isl_union_map *umap);
3750 #include <isl/aff.h>
3751 __isl_give char *isl_aff_to_str(__isl_keep isl_aff *aff);
3752 __isl_give char *isl_pw_aff_to_str(
3753 __isl_keep isl_pw_aff *pa);
3754 __isl_give char *isl_multi_aff_to_str(
3755 __isl_keep isl_multi_aff *ma);
3756 __isl_give char *isl_pw_multi_aff_to_str(
3757 __isl_keep isl_pw_multi_aff *pma);
3758 __isl_give char *isl_multi_pw_aff_to_str(
3759 __isl_keep isl_multi_pw_aff *mpa);
3760 __isl_give char *isl_union_pw_aff_to_str(
3761 __isl_keep isl_union_pw_aff *upa);
3762 __isl_give char *isl_union_pw_multi_aff_to_str(
3763 __isl_keep isl_union_pw_multi_aff *upma);
3764 __isl_give char *isl_multi_union_pw_aff_to_str(
3765 __isl_keep isl_multi_union_pw_aff *mupa);
3767 #include <isl/point.h>
3768 __isl_give char *isl_point_to_str(
3769 __isl_keep isl_point *pnt);
3771 #include <isl/polynomial.h>
3772 __isl_give char *isl_pw_qpolynomial_to_str(
3773 __isl_keep isl_pw_qpolynomial *pwqp);
3774 __isl_give char *isl_union_pw_qpolynomial_to_str(
3775 __isl_keep isl_union_pw_qpolynomial *upwqp);
3779 =head3 Unary Properties
3785 The following functions test whether the given set or relation
3786 contains any integer points. The ``plain'' variants do not perform
3787 any computations, but simply check if the given set or relation
3788 is already known to be empty.
3790 isl_bool isl_basic_set_plain_is_empty(
3791 __isl_keep isl_basic_set *bset);
3792 isl_bool isl_basic_set_is_empty(
3793 __isl_keep isl_basic_set *bset);
3794 isl_bool isl_set_plain_is_empty(
3795 __isl_keep isl_set *set);
3796 isl_bool isl_set_is_empty(__isl_keep isl_set *set);
3797 isl_bool isl_union_set_is_empty(
3798 __isl_keep isl_union_set *uset);
3799 isl_bool isl_basic_map_plain_is_empty(
3800 __isl_keep isl_basic_map *bmap);
3801 isl_bool isl_basic_map_is_empty(
3802 __isl_keep isl_basic_map *bmap);
3803 isl_bool isl_map_plain_is_empty(
3804 __isl_keep isl_map *map);
3805 isl_bool isl_map_is_empty(__isl_keep isl_map *map);
3806 isl_bool isl_union_map_is_empty(
3807 __isl_keep isl_union_map *umap);
3809 =item * Universality
3811 isl_bool isl_basic_set_plain_is_universe(
3812 __isl_keep isl_basic_set *bset);
3813 isl_bool isl_basic_set_is_universe(
3814 __isl_keep isl_basic_set *bset);
3815 isl_bool isl_basic_map_plain_is_universe(
3816 __isl_keep isl_basic_map *bmap);
3817 isl_bool isl_basic_map_is_universe(
3818 __isl_keep isl_basic_map *bmap);
3819 isl_bool isl_set_plain_is_universe(
3820 __isl_keep isl_set *set);
3821 isl_bool isl_map_plain_is_universe(
3822 __isl_keep isl_map *map);
3824 =item * Single-valuedness
3826 #include <isl/set.h>
3827 isl_bool isl_set_is_singleton(__isl_keep isl_set *set);
3829 #include <isl/map.h>
3830 isl_bool isl_basic_map_is_single_valued(
3831 __isl_keep isl_basic_map *bmap);
3832 isl_bool isl_map_plain_is_single_valued(
3833 __isl_keep isl_map *map);
3834 isl_bool isl_map_is_single_valued(__isl_keep isl_map *map);
3836 #include <isl/union_map.h>
3837 isl_bool isl_union_map_is_single_valued(
3838 __isl_keep isl_union_map *umap);
3842 isl_bool isl_map_plain_is_injective(
3843 __isl_keep isl_map *map);
3844 isl_bool isl_map_is_injective(
3845 __isl_keep isl_map *map);
3846 isl_bool isl_union_map_plain_is_injective(
3847 __isl_keep isl_union_map *umap);
3848 isl_bool isl_union_map_is_injective(
3849 __isl_keep isl_union_map *umap);
3853 isl_bool isl_map_is_bijective(
3854 __isl_keep isl_map *map);
3855 isl_bool isl_union_map_is_bijective(
3856 __isl_keep isl_union_map *umap);
3860 The following functions test whether the given relation
3861 only maps elements to themselves.
3863 #include <isl/map.h>
3864 isl_bool isl_map_is_identity(
3865 __isl_keep isl_map *map);
3867 #include <isl/union_map.h>
3868 isl_bool isl_union_map_is_identity(
3869 __isl_keep isl_union_map *umap);
3873 __isl_give isl_val *
3874 isl_basic_map_plain_get_val_if_fixed(
3875 __isl_keep isl_basic_map *bmap,
3876 enum isl_dim_type type, unsigned pos);
3877 __isl_give isl_val *isl_set_plain_get_val_if_fixed(
3878 __isl_keep isl_set *set,
3879 enum isl_dim_type type, unsigned pos);
3880 __isl_give isl_val *isl_map_plain_get_val_if_fixed(
3881 __isl_keep isl_map *map,
3882 enum isl_dim_type type, unsigned pos);
3884 If the set or relation obviously lies on a hyperplane where the given dimension
3885 has a fixed value, then return that value.
3886 Otherwise return NaN.
3890 isl_stat isl_set_dim_residue_class_val(
3891 __isl_keep isl_set *set,
3892 int pos, __isl_give isl_val **modulo,
3893 __isl_give isl_val **residue);
3895 Check if the values of the given set dimension are equal to a fixed
3896 value modulo some integer value. If so, assign the modulo to C<*modulo>
3897 and the fixed value to C<*residue>. If the given dimension attains only
3898 a single value, then assign C<0> to C<*modulo> and the fixed value to
3900 If the dimension does not attain only a single value and if no modulo
3901 can be found then assign C<1> to C<*modulo> and C<1> to C<*residue>.
3905 To check whether the description of a set, relation or function depends
3906 on one or more given dimensions,
3907 the following functions can be used.
3909 #include <isl/constraint.h>
3910 isl_bool isl_constraint_involves_dims(
3911 __isl_keep isl_constraint *constraint,
3912 enum isl_dim_type type, unsigned first, unsigned n);
3914 #include <isl/set.h>
3915 isl_bool isl_basic_set_involves_dims(
3916 __isl_keep isl_basic_set *bset,
3917 enum isl_dim_type type, unsigned first, unsigned n);
3918 isl_bool isl_set_involves_dims(__isl_keep isl_set *set,
3919 enum isl_dim_type type, unsigned first, unsigned n);
3921 #include <isl/map.h>
3922 isl_bool isl_basic_map_involves_dims(
3923 __isl_keep isl_basic_map *bmap,
3924 enum isl_dim_type type, unsigned first, unsigned n);
3925 isl_bool isl_map_involves_dims(__isl_keep isl_map *map,
3926 enum isl_dim_type type, unsigned first, unsigned n);
3928 #include <isl/union_map.h>
3929 isl_bool isl_union_map_involves_dims(
3930 __isl_keep isl_union_map *umap,
3931 enum isl_dim_type type, unsigned first, unsigned n);
3933 #include <isl/aff.h>
3934 isl_bool isl_aff_involves_dims(__isl_keep isl_aff *aff,
3935 enum isl_dim_type type, unsigned first, unsigned n);
3936 isl_bool isl_pw_aff_involves_dims(
3937 __isl_keep isl_pw_aff *pwaff,
3938 enum isl_dim_type type, unsigned first, unsigned n);
3939 isl_bool isl_multi_aff_involves_dims(
3940 __isl_keep isl_multi_aff *ma,
3941 enum isl_dim_type type, unsigned first, unsigned n);
3942 isl_bool isl_multi_pw_aff_involves_dims(
3943 __isl_keep isl_multi_pw_aff *mpa,
3944 enum isl_dim_type type, unsigned first, unsigned n);
3946 #include <isl/polynomial.h>
3947 isl_bool isl_qpolynomial_involves_dims(
3948 __isl_keep isl_qpolynomial *qp,
3949 enum isl_dim_type type, unsigned first, unsigned n);
3951 Similarly, the following functions can be used to check whether
3952 a given dimension is involved in any lower or upper bound.
3954 #include <isl/set.h>
3955 isl_bool isl_set_dim_has_any_lower_bound(
3956 __isl_keep isl_set *set,
3957 enum isl_dim_type type, unsigned pos);
3958 isl_bool isl_set_dim_has_any_upper_bound(
3959 __isl_keep isl_set *set,
3960 enum isl_dim_type type, unsigned pos);
3962 Note that these functions return true even if there is a bound on
3963 the dimension on only some of the basic sets of C<set>.
3964 To check if they have a bound for all of the basic sets in C<set>,
3965 use the following functions instead.
3967 #include <isl/set.h>
3968 isl_bool isl_set_dim_has_lower_bound(
3969 __isl_keep isl_set *set,
3970 enum isl_dim_type type, unsigned pos);
3971 isl_bool isl_set_dim_has_upper_bound(
3972 __isl_keep isl_set *set,
3973 enum isl_dim_type type, unsigned pos);
3977 To check whether a set is a parameter domain, use this function:
3979 isl_bool isl_set_is_params(__isl_keep isl_set *set);
3980 isl_bool isl_union_set_is_params(
3981 __isl_keep isl_union_set *uset);
3985 The following functions check whether the space of the given
3986 (basic) set or relation domain and/or range is a wrapped relation.
3988 #include <isl/space.h>
3989 isl_bool isl_space_is_wrapping(
3990 __isl_keep isl_space *space);
3991 isl_bool isl_space_domain_is_wrapping(
3992 __isl_keep isl_space *space);
3993 isl_bool isl_space_range_is_wrapping(
3994 __isl_keep isl_space *space);
3995 isl_bool isl_space_is_product(
3996 __isl_keep isl_space *space);
3998 #include <isl/set.h>
3999 isl_bool isl_basic_set_is_wrapping(
4000 __isl_keep isl_basic_set *bset);
4001 isl_bool isl_set_is_wrapping(__isl_keep isl_set *set);
4003 #include <isl/map.h>
4004 isl_bool isl_map_domain_is_wrapping(
4005 __isl_keep isl_map *map);
4006 isl_bool isl_map_range_is_wrapping(
4007 __isl_keep isl_map *map);
4008 isl_bool isl_map_is_product(__isl_keep isl_map *map);
4010 #include <isl/val.h>
4011 isl_bool isl_multi_val_range_is_wrapping(
4012 __isl_keep isl_multi_val *mv);
4014 #include <isl/aff.h>
4015 isl_bool isl_multi_aff_range_is_wrapping(
4016 __isl_keep isl_multi_aff *ma);
4017 isl_bool isl_multi_pw_aff_range_is_wrapping(
4018 __isl_keep isl_multi_pw_aff *mpa);
4019 isl_bool isl_multi_union_pw_aff_range_is_wrapping(
4020 __isl_keep isl_multi_union_pw_aff *mupa);
4022 The input to C<isl_space_is_wrapping> should
4023 be the space of a set, while that of
4024 C<isl_space_domain_is_wrapping> and
4025 C<isl_space_range_is_wrapping> should be the space of a relation.
4026 The input to C<isl_space_is_product> can be either the space
4027 of a set or that of a binary relation.
4028 In case the input is the space of a binary relation, it checks
4029 whether both domain and range are wrapping.
4031 =item * Internal Product
4033 isl_bool isl_basic_map_can_zip(
4034 __isl_keep isl_basic_map *bmap);
4035 isl_bool isl_map_can_zip(__isl_keep isl_map *map);
4037 Check whether the product of domain and range of the given relation
4039 i.e., whether both domain and range are nested relations.
4043 #include <isl/space.h>
4044 isl_bool isl_space_can_curry(
4045 __isl_keep isl_space *space);
4047 #include <isl/map.h>
4048 isl_bool isl_basic_map_can_curry(
4049 __isl_keep isl_basic_map *bmap);
4050 isl_bool isl_map_can_curry(__isl_keep isl_map *map);
4052 Check whether the domain of the (basic) relation is a wrapped relation.
4054 #include <isl/space.h>
4055 __isl_give isl_space *isl_space_uncurry(
4056 __isl_take isl_space *space);
4058 #include <isl/map.h>
4059 isl_bool isl_basic_map_can_uncurry(
4060 __isl_keep isl_basic_map *bmap);
4061 isl_bool isl_map_can_uncurry(__isl_keep isl_map *map);
4063 Check whether the range of the (basic) relation is a wrapped relation.
4065 #include <isl/space.h>
4066 isl_bool isl_space_can_range_curry(
4067 __isl_keep isl_space *space);
4069 #include <isl/map.h>
4070 isl_bool isl_map_can_range_curry(
4071 __isl_keep isl_map *map);
4073 Check whether the domain of the relation wrapped in the range of
4074 the input is itself a wrapped relation.
4076 =item * Special Values
4078 #include <isl/aff.h>
4079 isl_bool isl_aff_is_cst(__isl_keep isl_aff *aff);
4080 isl_bool isl_pw_aff_is_cst(__isl_keep isl_pw_aff *pwaff);
4081 isl_bool isl_multi_pw_aff_is_cst(
4082 __isl_keep isl_multi_pw_aff *mpa);
4084 Check whether the given expression is a constant.
4086 #include <isl/val.h>
4087 isl_bool isl_multi_val_involves_nan(
4088 __isl_keep isl_multi_val *mv);
4090 #include <isl/aff.h>
4091 isl_bool isl_aff_is_nan(__isl_keep isl_aff *aff);
4092 isl_bool isl_multi_aff_involves_nan(
4093 __isl_keep isl_multi_aff *ma);
4094 isl_bool isl_pw_aff_involves_nan(
4095 __isl_keep isl_pw_aff *pa);
4096 isl_bool isl_pw_multi_aff_involves_nan(
4097 __isl_keep isl_pw_multi_aff *pma);
4098 isl_bool isl_multi_pw_aff_involves_nan(
4099 __isl_keep isl_multi_pw_aff *mpa);
4100 isl_bool isl_union_pw_aff_involves_nan(
4101 __isl_keep isl_union_pw_aff *upa);
4102 isl_bool isl_union_pw_multi_aff_involves_nan(
4103 __isl_keep isl_union_pw_multi_aff *upma);
4104 isl_bool isl_multi_union_pw_aff_involves_nan(
4105 __isl_keep isl_multi_union_pw_aff *mupa);
4107 #include <isl/polynomial.h>
4108 isl_bool isl_qpolynomial_is_nan(
4109 __isl_keep isl_qpolynomial *qp);
4110 isl_bool isl_qpolynomial_fold_is_nan(
4111 __isl_keep isl_qpolynomial_fold *fold);
4112 isl_bool isl_pw_qpolynomial_involves_nan(
4113 __isl_keep isl_pw_qpolynomial *pwqp);
4114 isl_bool isl_pw_qpolynomial_fold_involves_nan(
4115 __isl_keep isl_pw_qpolynomial_fold *pwf);
4116 isl_bool isl_union_pw_qpolynomial_involves_nan(
4117 __isl_keep isl_union_pw_qpolynomial *upwqp);
4118 isl_bool isl_union_pw_qpolynomial_fold_involves_nan(
4119 __isl_keep isl_union_pw_qpolynomial_fold *upwf);
4121 Check whether the given expression is equal to or involves NaN.
4123 #include <isl/aff.h>
4124 isl_bool isl_aff_plain_is_zero(
4125 __isl_keep isl_aff *aff);
4127 Check whether the affine expression is obviously zero.
4131 =head3 Binary Properties
4137 The following functions check whether two objects
4138 represent the same set, relation or function.
4139 The C<plain> variants only return true if the objects
4140 are obviously the same. That is, they may return false
4141 even if the objects are the same, but they will never
4142 return true if the objects are not the same.
4144 #include <isl/set.h>
4145 isl_bool isl_basic_set_plain_is_equal(
4146 __isl_keep isl_basic_set *bset1,
4147 __isl_keep isl_basic_set *bset2);
4148 isl_bool isl_basic_set_is_equal(
4149 __isl_keep isl_basic_set *bset1,
4150 __isl_keep isl_basic_set *bset2);
4151 isl_bool isl_set_plain_is_equal(
4152 __isl_keep isl_set *set1,
4153 __isl_keep isl_set *set2);
4154 isl_bool isl_set_is_equal(__isl_keep isl_set *set1,
4155 __isl_keep isl_set *set2);
4157 #include <isl/map.h>
4158 isl_bool isl_basic_map_is_equal(
4159 __isl_keep isl_basic_map *bmap1,
4160 __isl_keep isl_basic_map *bmap2);
4161 isl_bool isl_map_is_equal(__isl_keep isl_map *map1,
4162 __isl_keep isl_map *map2);
4163 isl_bool isl_map_plain_is_equal(
4164 __isl_keep isl_map *map1,
4165 __isl_keep isl_map *map2);
4167 #include <isl/union_set.h>
4168 isl_bool isl_union_set_is_equal(
4169 __isl_keep isl_union_set *uset1,
4170 __isl_keep isl_union_set *uset2);
4172 #include <isl/union_map.h>
4173 isl_bool isl_union_map_is_equal(
4174 __isl_keep isl_union_map *umap1,
4175 __isl_keep isl_union_map *umap2);
4177 #include <isl/aff.h>
4178 isl_bool isl_aff_plain_is_equal(
4179 __isl_keep isl_aff *aff1,
4180 __isl_keep isl_aff *aff2);
4181 isl_bool isl_multi_aff_plain_is_equal(
4182 __isl_keep isl_multi_aff *maff1,
4183 __isl_keep isl_multi_aff *maff2);
4184 isl_bool isl_pw_aff_plain_is_equal(
4185 __isl_keep isl_pw_aff *pwaff1,
4186 __isl_keep isl_pw_aff *pwaff2);
4187 isl_bool isl_pw_aff_is_equal(
4188 __isl_keep isl_pw_aff *pa1,
4189 __isl_keep isl_pw_aff *pa2);
4190 isl_bool isl_pw_multi_aff_plain_is_equal(
4191 __isl_keep isl_pw_multi_aff *pma1,
4192 __isl_keep isl_pw_multi_aff *pma2);
4193 isl_bool isl_pw_multi_aff_is_equal(
4194 __isl_keep isl_pw_multi_aff *pma1,
4195 __isl_keep isl_pw_multi_aff *pma2);
4196 isl_bool isl_multi_pw_aff_plain_is_equal(
4197 __isl_keep isl_multi_pw_aff *mpa1,
4198 __isl_keep isl_multi_pw_aff *mpa2);
4199 isl_bool isl_multi_pw_aff_is_equal(
4200 __isl_keep isl_multi_pw_aff *mpa1,
4201 __isl_keep isl_multi_pw_aff *mpa2);
4202 isl_bool isl_union_pw_aff_plain_is_equal(
4203 __isl_keep isl_union_pw_aff *upa1,
4204 __isl_keep isl_union_pw_aff *upa2);
4205 isl_bool isl_union_pw_multi_aff_plain_is_equal(
4206 __isl_keep isl_union_pw_multi_aff *upma1,
4207 __isl_keep isl_union_pw_multi_aff *upma2);
4208 isl_bool isl_multi_union_pw_aff_plain_is_equal(
4209 __isl_keep isl_multi_union_pw_aff *mupa1,
4210 __isl_keep isl_multi_union_pw_aff *mupa2);
4212 #include <isl/polynomial.h>
4213 isl_bool isl_union_pw_qpolynomial_plain_is_equal(
4214 __isl_keep isl_union_pw_qpolynomial *upwqp1,
4215 __isl_keep isl_union_pw_qpolynomial *upwqp2);
4216 isl_bool isl_union_pw_qpolynomial_fold_plain_is_equal(
4217 __isl_keep isl_union_pw_qpolynomial_fold *upwf1,
4218 __isl_keep isl_union_pw_qpolynomial_fold *upwf2);
4220 =item * Disjointness
4222 #include <isl/set.h>
4223 isl_bool isl_basic_set_is_disjoint(
4224 __isl_keep isl_basic_set *bset1,
4225 __isl_keep isl_basic_set *bset2);
4226 isl_bool isl_set_plain_is_disjoint(
4227 __isl_keep isl_set *set1,
4228 __isl_keep isl_set *set2);
4229 isl_bool isl_set_is_disjoint(__isl_keep isl_set *set1,
4230 __isl_keep isl_set *set2);
4232 #include <isl/map.h>
4233 isl_bool isl_basic_map_is_disjoint(
4234 __isl_keep isl_basic_map *bmap1,
4235 __isl_keep isl_basic_map *bmap2);
4236 isl_bool isl_map_is_disjoint(__isl_keep isl_map *map1,
4237 __isl_keep isl_map *map2);
4239 #include <isl/union_set.h>
4240 isl_bool isl_union_set_is_disjoint(
4241 __isl_keep isl_union_set *uset1,
4242 __isl_keep isl_union_set *uset2);
4244 #include <isl/union_map.h>
4245 isl_bool isl_union_map_is_disjoint(
4246 __isl_keep isl_union_map *umap1,
4247 __isl_keep isl_union_map *umap2);
4251 isl_bool isl_basic_set_is_subset(
4252 __isl_keep isl_basic_set *bset1,
4253 __isl_keep isl_basic_set *bset2);
4254 isl_bool isl_set_is_subset(__isl_keep isl_set *set1,
4255 __isl_keep isl_set *set2);
4256 isl_bool isl_set_is_strict_subset(
4257 __isl_keep isl_set *set1,
4258 __isl_keep isl_set *set2);
4259 isl_bool isl_union_set_is_subset(
4260 __isl_keep isl_union_set *uset1,
4261 __isl_keep isl_union_set *uset2);
4262 isl_bool isl_union_set_is_strict_subset(
4263 __isl_keep isl_union_set *uset1,
4264 __isl_keep isl_union_set *uset2);
4265 isl_bool isl_basic_map_is_subset(
4266 __isl_keep isl_basic_map *bmap1,
4267 __isl_keep isl_basic_map *bmap2);
4268 isl_bool isl_basic_map_is_strict_subset(
4269 __isl_keep isl_basic_map *bmap1,
4270 __isl_keep isl_basic_map *bmap2);
4271 isl_bool isl_map_is_subset(
4272 __isl_keep isl_map *map1,
4273 __isl_keep isl_map *map2);
4274 isl_bool isl_map_is_strict_subset(
4275 __isl_keep isl_map *map1,
4276 __isl_keep isl_map *map2);
4277 isl_bool isl_union_map_is_subset(
4278 __isl_keep isl_union_map *umap1,
4279 __isl_keep isl_union_map *umap2);
4280 isl_bool isl_union_map_is_strict_subset(
4281 __isl_keep isl_union_map *umap1,
4282 __isl_keep isl_union_map *umap2);
4284 Check whether the first argument is a (strict) subset of the
4289 Every comparison function returns a negative value if the first
4290 argument is considered smaller than the second, a positive value
4291 if the first argument is considered greater and zero if the two
4292 constraints are considered the same by the comparison criterion.
4294 #include <isl/constraint.h>
4295 int isl_constraint_plain_cmp(
4296 __isl_keep isl_constraint *c1,
4297 __isl_keep isl_constraint *c2);
4299 This function is useful for sorting C<isl_constraint>s.
4300 The order depends on the internal representation of the inputs.
4301 The order is fixed over different calls to the function (assuming
4302 the internal representation of the inputs has not changed), but may
4303 change over different versions of C<isl>.
4305 #include <isl/constraint.h>
4306 int isl_constraint_cmp_last_non_zero(
4307 __isl_keep isl_constraint *c1,
4308 __isl_keep isl_constraint *c2);
4310 This function can be used to sort constraints that live in the same
4311 local space. Constraints that involve ``earlier'' dimensions or
4312 that have a smaller coefficient for the shared latest dimension
4313 are considered smaller than other constraints.
4314 This function only defines a B<partial> order.
4316 #include <isl/set.h>
4317 int isl_set_plain_cmp(__isl_keep isl_set *set1,
4318 __isl_keep isl_set *set2);
4320 This function is useful for sorting C<isl_set>s.
4321 The order depends on the internal representation of the inputs.
4322 The order is fixed over different calls to the function (assuming
4323 the internal representation of the inputs has not changed), but may
4324 change over different versions of C<isl>.
4326 #include <isl/aff.h>
4327 int isl_multi_aff_plain_cmp(
4328 __isl_keep isl_multi_aff *ma1,
4329 __isl_keep isl_multi_aff *ma2);
4330 int isl_pw_aff_plain_cmp(__isl_keep isl_pw_aff *pa1,
4331 __isl_keep isl_pw_aff *pa2);
4333 The functions C<isl_multi_aff_plain_cmp> and
4334 C<isl_pw_aff_plain_cmp> can be used to sort C<isl_multi_aff>s and
4335 C<isl_pw_aff>s. The order is not strictly defined.
4336 The current order sorts expressions that only involve
4337 earlier dimensions before those that involve later dimensions.
4341 =head2 Unary Operations
4347 __isl_give isl_set *isl_set_complement(
4348 __isl_take isl_set *set);
4349 __isl_give isl_map *isl_map_complement(
4350 __isl_take isl_map *map);
4354 #include <isl/space.h>
4355 __isl_give isl_space *isl_space_reverse(
4356 __isl_take isl_space *space);
4358 #include <isl/map.h>
4359 __isl_give isl_basic_map *isl_basic_map_reverse(
4360 __isl_take isl_basic_map *bmap);
4361 __isl_give isl_map *isl_map_reverse(
4362 __isl_take isl_map *map);
4364 #include <isl/union_map.h>
4365 __isl_give isl_union_map *isl_union_map_reverse(
4366 __isl_take isl_union_map *umap);
4370 #include <isl/space.h>
4371 __isl_give isl_space *isl_space_domain(
4372 __isl_take isl_space *space);
4373 __isl_give isl_space *isl_space_range(
4374 __isl_take isl_space *space);
4375 __isl_give isl_space *isl_space_params(
4376 __isl_take isl_space *space);
4378 #include <isl/local_space.h>
4379 __isl_give isl_local_space *isl_local_space_domain(
4380 __isl_take isl_local_space *ls);
4381 __isl_give isl_local_space *isl_local_space_range(
4382 __isl_take isl_local_space *ls);
4384 #include <isl/set.h>
4385 __isl_give isl_basic_set *isl_basic_set_project_out(
4386 __isl_take isl_basic_set *bset,
4387 enum isl_dim_type type, unsigned first, unsigned n);
4388 __isl_give isl_set *isl_set_project_out(__isl_take isl_set *set,
4389 enum isl_dim_type type, unsigned first, unsigned n);
4390 __isl_give isl_map *isl_set_project_onto_map(
4391 __isl_take isl_set *set,
4392 enum isl_dim_type type, unsigned first,
4394 __isl_give isl_basic_set *isl_basic_set_params(
4395 __isl_take isl_basic_set *bset);
4396 __isl_give isl_set *isl_set_params(__isl_take isl_set *set);
4398 The function C<isl_set_project_onto_map> returns a relation
4399 that projects the input set onto the given set dimensions.
4401 #include <isl/map.h>
4402 __isl_give isl_basic_map *isl_basic_map_project_out(
4403 __isl_take isl_basic_map *bmap,
4404 enum isl_dim_type type, unsigned first, unsigned n);
4405 __isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
4406 enum isl_dim_type type, unsigned first, unsigned n);
4407 __isl_give isl_basic_set *isl_basic_map_domain(
4408 __isl_take isl_basic_map *bmap);
4409 __isl_give isl_basic_set *isl_basic_map_range(
4410 __isl_take isl_basic_map *bmap);
4411 __isl_give isl_set *isl_map_params(__isl_take isl_map *map);
4412 __isl_give isl_set *isl_map_domain(
4413 __isl_take isl_map *bmap);
4414 __isl_give isl_set *isl_map_range(
4415 __isl_take isl_map *map);
4417 #include <isl/union_set.h>
4418 __isl_give isl_union_set *isl_union_set_project_out(
4419 __isl_take isl_union_set *uset,
4420 enum isl_dim_type type,
4421 unsigned first, unsigned n);
4422 __isl_give isl_set *isl_union_set_params(
4423 __isl_take isl_union_set *uset);
4425 The function C<isl_union_set_project_out> can only project out
4428 #include <isl/union_map.h>
4429 __isl_give isl_union_map *isl_union_map_project_out(
4430 __isl_take isl_union_map *umap,
4431 enum isl_dim_type type, unsigned first, unsigned n);
4432 __isl_give isl_set *isl_union_map_params(
4433 __isl_take isl_union_map *umap);
4434 __isl_give isl_union_set *isl_union_map_domain(
4435 __isl_take isl_union_map *umap);
4436 __isl_give isl_union_set *isl_union_map_range(
4437 __isl_take isl_union_map *umap);
4439 The function C<isl_union_map_project_out> can only project out
4442 #include <isl/aff.h>
4443 __isl_give isl_aff *isl_aff_project_domain_on_params(
4444 __isl_take isl_aff *aff);
4445 __isl_give isl_pw_aff *
4446 isl_pw_aff_project_domain_on_params(
4447 __isl_take isl_pw_aff *pa);
4448 __isl_give isl_pw_multi_aff *
4449 isl_pw_multi_aff_project_domain_on_params(
4450 __isl_take isl_pw_multi_aff *pma);
4451 __isl_give isl_set *isl_pw_aff_domain(
4452 __isl_take isl_pw_aff *pwaff);
4453 __isl_give isl_set *isl_pw_multi_aff_domain(
4454 __isl_take isl_pw_multi_aff *pma);
4455 __isl_give isl_set *isl_multi_pw_aff_domain(
4456 __isl_take isl_multi_pw_aff *mpa);
4457 __isl_give isl_union_set *isl_union_pw_aff_domain(
4458 __isl_take isl_union_pw_aff *upa);
4459 __isl_give isl_union_set *isl_union_pw_multi_aff_domain(
4460 __isl_take isl_union_pw_multi_aff *upma);
4461 __isl_give isl_union_set *
4462 isl_multi_union_pw_aff_domain(
4463 __isl_take isl_multi_union_pw_aff *mupa);
4464 __isl_give isl_set *isl_pw_aff_params(
4465 __isl_take isl_pw_aff *pwa);
4467 The function C<isl_multi_union_pw_aff_domain> requires its
4468 input to have at least one set dimension.
4470 #include <isl/polynomial.h>
4471 __isl_give isl_qpolynomial *
4472 isl_qpolynomial_project_domain_on_params(
4473 __isl_take isl_qpolynomial *qp);
4474 __isl_give isl_pw_qpolynomial *
4475 isl_pw_qpolynomial_project_domain_on_params(
4476 __isl_take isl_pw_qpolynomial *pwqp);
4477 __isl_give isl_pw_qpolynomial_fold *
4478 isl_pw_qpolynomial_fold_project_domain_on_params(
4479 __isl_take isl_pw_qpolynomial_fold *pwf);
4480 __isl_give isl_set *isl_pw_qpolynomial_domain(
4481 __isl_take isl_pw_qpolynomial *pwqp);
4482 __isl_give isl_union_set *isl_union_pw_qpolynomial_fold_domain(
4483 __isl_take isl_union_pw_qpolynomial_fold *upwf);
4484 __isl_give isl_union_set *isl_union_pw_qpolynomial_domain(
4485 __isl_take isl_union_pw_qpolynomial *upwqp);
4487 #include <isl/space.h>
4488 __isl_give isl_space *isl_space_domain_map(
4489 __isl_take isl_space *space);
4490 __isl_give isl_space *isl_space_range_map(
4491 __isl_take isl_space *space);
4493 #include <isl/map.h>
4494 __isl_give isl_map *isl_set_wrapped_domain_map(
4495 __isl_take isl_set *set);
4496 __isl_give isl_basic_map *isl_basic_map_domain_map(
4497 __isl_take isl_basic_map *bmap);
4498 __isl_give isl_basic_map *isl_basic_map_range_map(
4499 __isl_take isl_basic_map *bmap);
4500 __isl_give isl_map *isl_map_domain_map(__isl_take isl_map *map);
4501 __isl_give isl_map *isl_map_range_map(__isl_take isl_map *map);
4503 #include <isl/union_map.h>
4504 __isl_give isl_union_map *isl_union_map_domain_map(
4505 __isl_take isl_union_map *umap);
4506 __isl_give isl_union_pw_multi_aff *
4507 isl_union_map_domain_map_union_pw_multi_aff(
4508 __isl_take isl_union_map *umap);
4509 __isl_give isl_union_map *isl_union_map_range_map(
4510 __isl_take isl_union_map *umap);
4511 __isl_give isl_union_map *
4512 isl_union_set_wrapped_domain_map(
4513 __isl_take isl_union_set *uset);
4515 The functions above construct a (basic, regular or union) relation
4516 that maps (a wrapped version of) the input relation to its domain or range.
4517 C<isl_set_wrapped_domain_map> maps the input set to the domain
4518 of its wrapped relation.
4522 __isl_give isl_basic_set *isl_basic_set_eliminate(
4523 __isl_take isl_basic_set *bset,
4524 enum isl_dim_type type,
4525 unsigned first, unsigned n);
4526 __isl_give isl_set *isl_set_eliminate(
4527 __isl_take isl_set *set, enum isl_dim_type type,
4528 unsigned first, unsigned n);
4529 __isl_give isl_basic_map *isl_basic_map_eliminate(
4530 __isl_take isl_basic_map *bmap,
4531 enum isl_dim_type type,
4532 unsigned first, unsigned n);
4533 __isl_give isl_map *isl_map_eliminate(
4534 __isl_take isl_map *map, enum isl_dim_type type,
4535 unsigned first, unsigned n);
4537 Eliminate the coefficients for the given dimensions from the constraints,
4538 without removing the dimensions.
4540 =item * Constructing a set from a parameter domain
4542 A zero-dimensional space or (basic) set can be constructed
4543 on a given parameter domain using the following functions.
4545 #include <isl/space.h>
4546 __isl_give isl_space *isl_space_set_from_params(
4547 __isl_take isl_space *space);
4549 #include <isl/set.h>
4550 __isl_give isl_basic_set *isl_basic_set_from_params(
4551 __isl_take isl_basic_set *bset);
4552 __isl_give isl_set *isl_set_from_params(
4553 __isl_take isl_set *set);
4555 =item * Constructing a relation from one or two sets
4557 Create a relation with the given set(s) as domain and/or range.
4558 If only the domain or the range is specified, then
4559 the range or domain of the created relation is a zero-dimensional
4560 flat anonymous space.
4562 #include <isl/space.h>
4563 __isl_give isl_space *isl_space_from_domain(
4564 __isl_take isl_space *space);
4565 __isl_give isl_space *isl_space_from_range(
4566 __isl_take isl_space *space);
4567 __isl_give isl_space *isl_space_map_from_set(
4568 __isl_take isl_space *space);
4569 __isl_give isl_space *isl_space_map_from_domain_and_range(
4570 __isl_take isl_space *domain,
4571 __isl_take isl_space *range);
4573 #include <isl/local_space.h>
4574 __isl_give isl_local_space *isl_local_space_from_domain(
4575 __isl_take isl_local_space *ls);
4577 #include <isl/map.h>
4578 __isl_give isl_map *isl_map_from_domain(
4579 __isl_take isl_set *set);
4580 __isl_give isl_map *isl_map_from_range(
4581 __isl_take isl_set *set);
4583 #include <isl/union_map.h>
4584 __isl_give isl_union_map *
4585 isl_union_map_from_domain_and_range(
4586 __isl_take isl_union_set *domain,
4587 __isl_take isl_union_set *range);
4589 #include <isl/val.h>
4590 __isl_give isl_multi_val *isl_multi_val_from_range(
4591 __isl_take isl_multi_val *mv);
4593 #include <isl/aff.h>
4594 __isl_give isl_multi_aff *isl_multi_aff_from_range(
4595 __isl_take isl_multi_aff *ma);
4596 __isl_give isl_pw_aff *isl_pw_aff_from_range(
4597 __isl_take isl_pw_aff *pwa);
4598 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_range(
4599 __isl_take isl_multi_pw_aff *mpa);
4600 __isl_give isl_multi_union_pw_aff *
4601 isl_multi_union_pw_aff_from_range(
4602 __isl_take isl_multi_union_pw_aff *mupa);
4603 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_domain(
4604 __isl_take isl_set *set);
4605 __isl_give isl_union_pw_multi_aff *
4606 isl_union_pw_multi_aff_from_domain(
4607 __isl_take isl_union_set *uset);
4609 #include <isl/polynomial.h>
4610 __isl_give isl_pw_qpolynomial *
4611 isl_pw_qpolynomial_from_range(
4612 __isl_take isl_pw_qpolynomial *pwqp);
4613 __isl_give isl_pw_qpolynomial_fold *
4614 isl_pw_qpolynomial_fold_from_range(
4615 __isl_take isl_pw_qpolynomial_fold *pwf);
4619 #include <isl/set.h>
4620 __isl_give isl_basic_set *isl_basic_set_fix_si(
4621 __isl_take isl_basic_set *bset,
4622 enum isl_dim_type type, unsigned pos, int value);
4623 __isl_give isl_basic_set *isl_basic_set_fix_val(
4624 __isl_take isl_basic_set *bset,
4625 enum isl_dim_type type, unsigned pos,
4626 __isl_take isl_val *v);
4627 __isl_give isl_set *isl_set_fix_si(__isl_take isl_set *set,
4628 enum isl_dim_type type, unsigned pos, int value);
4629 __isl_give isl_set *isl_set_fix_val(
4630 __isl_take isl_set *set,
4631 enum isl_dim_type type, unsigned pos,
4632 __isl_take isl_val *v);
4634 #include <isl/map.h>
4635 __isl_give isl_basic_map *isl_basic_map_fix_si(
4636 __isl_take isl_basic_map *bmap,
4637 enum isl_dim_type type, unsigned pos, int value);
4638 __isl_give isl_basic_map *isl_basic_map_fix_val(
4639 __isl_take isl_basic_map *bmap,
4640 enum isl_dim_type type, unsigned pos,
4641 __isl_take isl_val *v);
4642 __isl_give isl_map *isl_map_fix_si(__isl_take isl_map *map,
4643 enum isl_dim_type type, unsigned pos, int value);
4644 __isl_give isl_map *isl_map_fix_val(
4645 __isl_take isl_map *map,
4646 enum isl_dim_type type, unsigned pos,
4647 __isl_take isl_val *v);
4649 #include <isl/aff.h>
4650 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_fix_si(
4651 __isl_take isl_pw_multi_aff *pma,
4652 enum isl_dim_type type, unsigned pos, int value);
4654 #include <isl/polynomial.h>
4655 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_fix_val(
4656 __isl_take isl_pw_qpolynomial *pwqp,
4657 enum isl_dim_type type, unsigned n,
4658 __isl_take isl_val *v);
4660 Intersect the set, relation or function domain
4661 with the hyperplane where the given
4662 dimension has the fixed given value.
4664 __isl_give isl_basic_map *isl_basic_map_lower_bound_si(
4665 __isl_take isl_basic_map *bmap,
4666 enum isl_dim_type type, unsigned pos, int value);
4667 __isl_give isl_basic_map *isl_basic_map_upper_bound_si(
4668 __isl_take isl_basic_map *bmap,
4669 enum isl_dim_type type, unsigned pos, int value);
4670 __isl_give isl_set *isl_set_lower_bound_si(
4671 __isl_take isl_set *set,
4672 enum isl_dim_type type, unsigned pos, int value);
4673 __isl_give isl_set *isl_set_lower_bound_val(
4674 __isl_take isl_set *set,
4675 enum isl_dim_type type, unsigned pos,
4676 __isl_take isl_val *value);
4677 __isl_give isl_map *isl_map_lower_bound_si(
4678 __isl_take isl_map *map,
4679 enum isl_dim_type type, unsigned pos, int value);
4680 __isl_give isl_set *isl_set_upper_bound_si(
4681 __isl_take isl_set *set,
4682 enum isl_dim_type type, unsigned pos, int value);
4683 __isl_give isl_set *isl_set_upper_bound_val(
4684 __isl_take isl_set *set,
4685 enum isl_dim_type type, unsigned pos,
4686 __isl_take isl_val *value);
4687 __isl_give isl_map *isl_map_upper_bound_si(
4688 __isl_take isl_map *map,
4689 enum isl_dim_type type, unsigned pos, int value);
4691 Intersect the set or relation with the half-space where the given
4692 dimension has a value bounded by the fixed given integer value.
4694 __isl_give isl_set *isl_set_equate(__isl_take isl_set *set,
4695 enum isl_dim_type type1, int pos1,
4696 enum isl_dim_type type2, int pos2);
4697 __isl_give isl_basic_map *isl_basic_map_equate(
4698 __isl_take isl_basic_map *bmap,
4699 enum isl_dim_type type1, int pos1,
4700 enum isl_dim_type type2, int pos2);
4701 __isl_give isl_map *isl_map_equate(__isl_take isl_map *map,
4702 enum isl_dim_type type1, int pos1,
4703 enum isl_dim_type type2, int pos2);
4705 Intersect the set or relation with the hyperplane where the given
4706 dimensions are equal to each other.
4708 __isl_give isl_map *isl_map_oppose(__isl_take isl_map *map,
4709 enum isl_dim_type type1, int pos1,
4710 enum isl_dim_type type2, int pos2);
4712 Intersect the relation with the hyperplane where the given
4713 dimensions have opposite values.
4715 __isl_give isl_map *isl_map_order_le(
4716 __isl_take isl_map *map,
4717 enum isl_dim_type type1, int pos1,
4718 enum isl_dim_type type2, int pos2);
4719 __isl_give isl_basic_map *isl_basic_map_order_ge(
4720 __isl_take isl_basic_map *bmap,
4721 enum isl_dim_type type1, int pos1,
4722 enum isl_dim_type type2, int pos2);
4723 __isl_give isl_map *isl_map_order_ge(
4724 __isl_take isl_map *map,
4725 enum isl_dim_type type1, int pos1,
4726 enum isl_dim_type type2, int pos2);
4727 __isl_give isl_map *isl_map_order_lt(__isl_take isl_map *map,
4728 enum isl_dim_type type1, int pos1,
4729 enum isl_dim_type type2, int pos2);
4730 __isl_give isl_basic_map *isl_basic_map_order_gt(
4731 __isl_take isl_basic_map *bmap,
4732 enum isl_dim_type type1, int pos1,
4733 enum isl_dim_type type2, int pos2);
4734 __isl_give isl_map *isl_map_order_gt(__isl_take isl_map *map,
4735 enum isl_dim_type type1, int pos1,
4736 enum isl_dim_type type2, int pos2);
4738 Intersect the relation with the half-space where the given
4739 dimensions satisfy the given ordering.
4743 #include <isl/aff.h>
4744 __isl_give isl_basic_set *isl_aff_zero_basic_set(
4745 __isl_take isl_aff *aff);
4746 __isl_give isl_basic_set *isl_aff_neg_basic_set(
4747 __isl_take isl_aff *aff);
4748 __isl_give isl_set *isl_pw_aff_pos_set(
4749 __isl_take isl_pw_aff *pa);
4750 __isl_give isl_set *isl_pw_aff_nonneg_set(
4751 __isl_take isl_pw_aff *pwaff);
4752 __isl_give isl_set *isl_pw_aff_zero_set(
4753 __isl_take isl_pw_aff *pwaff);
4754 __isl_give isl_set *isl_pw_aff_non_zero_set(
4755 __isl_take isl_pw_aff *pwaff);
4756 __isl_give isl_union_set *
4757 isl_union_pw_aff_zero_union_set(
4758 __isl_take isl_union_pw_aff *upa);
4759 __isl_give isl_union_set *
4760 isl_multi_union_pw_aff_zero_union_set(
4761 __isl_take isl_multi_union_pw_aff *mupa);
4763 The function C<isl_aff_neg_basic_set> returns a basic set
4764 containing those elements in the domain space
4765 of C<aff> where C<aff> is negative.
4766 The function C<isl_pw_aff_nonneg_set> returns a set
4767 containing those elements in the domain
4768 of C<pwaff> where C<pwaff> is non-negative.
4769 The function C<isl_multi_union_pw_aff_zero_union_set>
4770 returns a union set containing those elements
4771 in the domains of its elements where they are all zero.
4775 __isl_give isl_map *isl_set_identity(
4776 __isl_take isl_set *set);
4777 __isl_give isl_union_map *isl_union_set_identity(
4778 __isl_take isl_union_set *uset);
4779 __isl_give isl_union_pw_multi_aff *
4780 isl_union_set_identity_union_pw_multi_aff(
4781 __isl_take isl_union_set *uset);
4783 Construct an identity relation on the given (union) set.
4785 =item * Function Extraction
4787 A piecewise quasi affine expression that is equal to 1 on a set
4788 and 0 outside the set can be created using the following function.
4790 #include <isl/aff.h>
4791 __isl_give isl_pw_aff *isl_set_indicator_function(
4792 __isl_take isl_set *set);
4794 A piecewise multiple quasi affine expression can be extracted
4795 from an C<isl_set> or C<isl_map>, provided the C<isl_set> is a singleton
4796 and the C<isl_map> is single-valued.
4797 In case of a conversion from an C<isl_union_map>
4798 to an C<isl_union_pw_multi_aff>, these properties need to hold
4799 in each domain space.
4800 A conversion to a C<isl_multi_union_pw_aff> additionally
4801 requires that the input is non-empty and involves only a single
4804 #include <isl/aff.h>
4805 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_set(
4806 __isl_take isl_set *set);
4807 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_map(
4808 __isl_take isl_map *map);
4810 __isl_give isl_union_pw_multi_aff *
4811 isl_union_pw_multi_aff_from_union_set(
4812 __isl_take isl_union_set *uset);
4813 __isl_give isl_union_pw_multi_aff *
4814 isl_union_pw_multi_aff_from_union_map(
4815 __isl_take isl_union_map *umap);
4817 __isl_give isl_multi_union_pw_aff *
4818 isl_multi_union_pw_aff_from_union_map(
4819 __isl_take isl_union_map *umap);
4823 __isl_give isl_basic_set *isl_basic_map_deltas(
4824 __isl_take isl_basic_map *bmap);
4825 __isl_give isl_set *isl_map_deltas(__isl_take isl_map *map);
4826 __isl_give isl_union_set *isl_union_map_deltas(
4827 __isl_take isl_union_map *umap);
4829 These functions return a (basic) set containing the differences
4830 between image elements and corresponding domain elements in the input.
4832 __isl_give isl_basic_map *isl_basic_map_deltas_map(
4833 __isl_take isl_basic_map *bmap);
4834 __isl_give isl_map *isl_map_deltas_map(
4835 __isl_take isl_map *map);
4836 __isl_give isl_union_map *isl_union_map_deltas_map(
4837 __isl_take isl_union_map *umap);
4839 The functions above construct a (basic, regular or union) relation
4840 that maps (a wrapped version of) the input relation to its delta set.
4844 Simplify the representation of a set, relation or functions by trying
4845 to combine pairs of basic sets or relations into a single
4846 basic set or relation.
4848 #include <isl/set.h>
4849 __isl_give isl_set *isl_set_coalesce(__isl_take isl_set *set);
4851 #include <isl/map.h>
4852 __isl_give isl_map *isl_map_coalesce(__isl_take isl_map *map);
4854 #include <isl/union_set.h>
4855 __isl_give isl_union_set *isl_union_set_coalesce(
4856 __isl_take isl_union_set *uset);
4858 #include <isl/union_map.h>
4859 __isl_give isl_union_map *isl_union_map_coalesce(
4860 __isl_take isl_union_map *umap);
4862 #include <isl/aff.h>
4863 __isl_give isl_pw_aff *isl_pw_aff_coalesce(
4864 __isl_take isl_pw_aff *pwqp);
4865 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_coalesce(
4866 __isl_take isl_pw_multi_aff *pma);
4867 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_coalesce(
4868 __isl_take isl_multi_pw_aff *mpa);
4869 __isl_give isl_union_pw_aff *isl_union_pw_aff_coalesce(
4870 __isl_take isl_union_pw_aff *upa);
4871 __isl_give isl_union_pw_multi_aff *
4872 isl_union_pw_multi_aff_coalesce(
4873 __isl_take isl_union_pw_multi_aff *upma);
4874 __isl_give isl_multi_union_pw_aff *
4875 isl_multi_union_pw_aff_coalesce(
4876 __isl_take isl_multi_union_pw_aff *aff);
4878 #include <isl/polynomial.h>
4879 __isl_give isl_pw_qpolynomial_fold *
4880 isl_pw_qpolynomial_fold_coalesce(
4881 __isl_take isl_pw_qpolynomial_fold *pwf);
4882 __isl_give isl_union_pw_qpolynomial *
4883 isl_union_pw_qpolynomial_coalesce(
4884 __isl_take isl_union_pw_qpolynomial *upwqp);
4885 __isl_give isl_union_pw_qpolynomial_fold *
4886 isl_union_pw_qpolynomial_fold_coalesce(
4887 __isl_take isl_union_pw_qpolynomial_fold *upwf);
4889 One of the methods for combining pairs of basic sets or relations
4890 can result in coefficients that are much larger than those that appear
4891 in the constraints of the input. By default, the coefficients are
4892 not allowed to grow larger, but this can be changed by unsetting
4893 the following option.
4895 isl_stat isl_options_set_coalesce_bounded_wrapping(
4896 isl_ctx *ctx, int val);
4897 int isl_options_get_coalesce_bounded_wrapping(
4900 =item * Detecting equalities
4902 __isl_give isl_basic_set *isl_basic_set_detect_equalities(
4903 __isl_take isl_basic_set *bset);
4904 __isl_give isl_basic_map *isl_basic_map_detect_equalities(
4905 __isl_take isl_basic_map *bmap);
4906 __isl_give isl_set *isl_set_detect_equalities(
4907 __isl_take isl_set *set);
4908 __isl_give isl_map *isl_map_detect_equalities(
4909 __isl_take isl_map *map);
4910 __isl_give isl_union_set *isl_union_set_detect_equalities(
4911 __isl_take isl_union_set *uset);
4912 __isl_give isl_union_map *isl_union_map_detect_equalities(
4913 __isl_take isl_union_map *umap);
4915 Simplify the representation of a set or relation by detecting implicit
4918 =item * Removing redundant constraints
4920 #include <isl/set.h>
4921 __isl_give isl_basic_set *isl_basic_set_remove_redundancies(
4922 __isl_take isl_basic_set *bset);
4923 __isl_give isl_set *isl_set_remove_redundancies(
4924 __isl_take isl_set *set);
4926 #include <isl/union_set.h>
4927 __isl_give isl_union_set *
4928 isl_union_set_remove_redundancies(
4929 __isl_take isl_union_set *uset);
4931 #include <isl/map.h>
4932 __isl_give isl_basic_map *isl_basic_map_remove_redundancies(
4933 __isl_take isl_basic_map *bmap);
4934 __isl_give isl_map *isl_map_remove_redundancies(
4935 __isl_take isl_map *map);
4937 #include <isl/union_map.h>
4938 __isl_give isl_union_map *
4939 isl_union_map_remove_redundancies(
4940 __isl_take isl_union_map *umap);
4944 __isl_give isl_basic_set *isl_set_convex_hull(
4945 __isl_take isl_set *set);
4946 __isl_give isl_basic_map *isl_map_convex_hull(
4947 __isl_take isl_map *map);
4949 If the input set or relation has any existentially quantified
4950 variables, then the result of these operations is currently undefined.
4954 #include <isl/set.h>
4955 __isl_give isl_basic_set *
4956 isl_set_unshifted_simple_hull(
4957 __isl_take isl_set *set);
4958 __isl_give isl_basic_set *isl_set_simple_hull(
4959 __isl_take isl_set *set);
4960 __isl_give isl_basic_set *
4961 isl_set_plain_unshifted_simple_hull(
4962 __isl_take isl_set *set);
4963 __isl_give isl_basic_set *
4964 isl_set_unshifted_simple_hull_from_set_list(
4965 __isl_take isl_set *set,
4966 __isl_take isl_set_list *list);
4968 #include <isl/map.h>
4969 __isl_give isl_basic_map *
4970 isl_map_unshifted_simple_hull(
4971 __isl_take isl_map *map);
4972 __isl_give isl_basic_map *isl_map_simple_hull(
4973 __isl_take isl_map *map);
4974 __isl_give isl_basic_map *
4975 isl_map_plain_unshifted_simple_hull(
4976 __isl_take isl_map *map);
4977 __isl_give isl_basic_map *
4978 isl_map_unshifted_simple_hull_from_map_list(
4979 __isl_take isl_map *map,
4980 __isl_take isl_map_list *list);
4982 #include <isl/union_map.h>
4983 __isl_give isl_union_map *isl_union_map_simple_hull(
4984 __isl_take isl_union_map *umap);
4986 These functions compute a single basic set or relation
4987 that contains the whole input set or relation.
4988 In particular, the output is described by translates
4989 of the constraints describing the basic sets or relations in the input.
4990 In case of C<isl_set_unshifted_simple_hull>, only the original
4991 constraints are used, without any translation.
4992 In case of C<isl_set_plain_unshifted_simple_hull> and
4993 C<isl_map_plain_unshifted_simple_hull>, the result is described
4994 by original constraints that are obviously satisfied
4995 by the entire input set or relation.
4996 In case of C<isl_set_unshifted_simple_hull_from_set_list> and
4997 C<isl_map_unshifted_simple_hull_from_map_list>, the
4998 constraints are taken from the elements of the second argument.
5002 (See \autoref{s:simple hull}.)
5008 __isl_give isl_basic_set *isl_basic_set_affine_hull(
5009 __isl_take isl_basic_set *bset);
5010 __isl_give isl_basic_set *isl_set_affine_hull(
5011 __isl_take isl_set *set);
5012 __isl_give isl_union_set *isl_union_set_affine_hull(
5013 __isl_take isl_union_set *uset);
5014 __isl_give isl_basic_map *isl_basic_map_affine_hull(
5015 __isl_take isl_basic_map *bmap);
5016 __isl_give isl_basic_map *isl_map_affine_hull(
5017 __isl_take isl_map *map);
5018 __isl_give isl_union_map *isl_union_map_affine_hull(
5019 __isl_take isl_union_map *umap);
5021 In case of union sets and relations, the affine hull is computed
5024 =item * Polyhedral hull
5026 __isl_give isl_basic_set *isl_set_polyhedral_hull(
5027 __isl_take isl_set *set);
5028 __isl_give isl_basic_map *isl_map_polyhedral_hull(
5029 __isl_take isl_map *map);
5030 __isl_give isl_union_set *isl_union_set_polyhedral_hull(
5031 __isl_take isl_union_set *uset);
5032 __isl_give isl_union_map *isl_union_map_polyhedral_hull(
5033 __isl_take isl_union_map *umap);
5035 These functions compute a single basic set or relation
5036 not involving any existentially quantified variables
5037 that contains the whole input set or relation.
5038 In case of union sets and relations, the polyhedral hull is computed
5041 =item * Other approximations
5043 #include <isl/set.h>
5044 __isl_give isl_basic_set *
5045 isl_basic_set_drop_constraints_involving_dims(
5046 __isl_take isl_basic_set *bset,
5047 enum isl_dim_type type,
5048 unsigned first, unsigned n);
5049 __isl_give isl_basic_set *
5050 isl_basic_set_drop_constraints_not_involving_dims(
5051 __isl_take isl_basic_set *bset,
5052 enum isl_dim_type type,
5053 unsigned first, unsigned n);
5054 __isl_give isl_set *
5055 isl_set_drop_constraints_involving_dims(
5056 __isl_take isl_set *set,
5057 enum isl_dim_type type,
5058 unsigned first, unsigned n);
5059 __isl_give isl_set *
5060 isl_set_drop_constraints_not_involving_dims(
5061 __isl_take isl_set *set,
5062 enum isl_dim_type type,
5063 unsigned first, unsigned n);
5065 #include <isl/map.h>
5066 __isl_give isl_basic_map *
5067 isl_basic_map_drop_constraints_involving_dims(
5068 __isl_take isl_basic_map *bmap,
5069 enum isl_dim_type type,
5070 unsigned first, unsigned n);
5071 __isl_give isl_basic_map *
5072 isl_basic_map_drop_constraints_not_involving_dims(
5073 __isl_take isl_basic_map *bmap,
5074 enum isl_dim_type type,
5075 unsigned first, unsigned n);
5076 __isl_give isl_map *
5077 isl_map_drop_constraints_involving_dims(
5078 __isl_take isl_map *map,
5079 enum isl_dim_type type,
5080 unsigned first, unsigned n);
5081 __isl_give isl_map *
5082 isl_map_drop_constraints_not_involving_dims(
5083 __isl_take isl_map *map,
5084 enum isl_dim_type type,
5085 unsigned first, unsigned n);
5087 These functions drop any constraints (not) involving the specified dimensions.
5088 Note that the result depends on the representation of the input.
5090 #include <isl/polynomial.h>
5091 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_to_polynomial(
5092 __isl_take isl_pw_qpolynomial *pwqp, int sign);
5093 __isl_give isl_union_pw_qpolynomial *
5094 isl_union_pw_qpolynomial_to_polynomial(
5095 __isl_take isl_union_pw_qpolynomial *upwqp, int sign);
5097 Approximate each quasipolynomial by a polynomial. If C<sign> is positive,
5098 the polynomial will be an overapproximation. If C<sign> is negative,
5099 it will be an underapproximation. If C<sign> is zero, the approximation
5100 will lie somewhere in between.
5104 __isl_give isl_basic_set *isl_basic_set_sample(
5105 __isl_take isl_basic_set *bset);
5106 __isl_give isl_basic_set *isl_set_sample(
5107 __isl_take isl_set *set);
5108 __isl_give isl_basic_map *isl_basic_map_sample(
5109 __isl_take isl_basic_map *bmap);
5110 __isl_give isl_basic_map *isl_map_sample(
5111 __isl_take isl_map *map);
5113 If the input (basic) set or relation is non-empty, then return
5114 a singleton subset of the input. Otherwise, return an empty set.
5116 =item * Optimization
5118 #include <isl/ilp.h>
5119 __isl_give isl_val *isl_basic_set_max_val(
5120 __isl_keep isl_basic_set *bset,
5121 __isl_keep isl_aff *obj);
5122 __isl_give isl_val *isl_set_min_val(
5123 __isl_keep isl_set *set,
5124 __isl_keep isl_aff *obj);
5125 __isl_give isl_val *isl_set_max_val(
5126 __isl_keep isl_set *set,
5127 __isl_keep isl_aff *obj);
5128 __isl_give isl_multi_val *
5129 isl_union_set_min_multi_union_pw_aff(
5130 __isl_keep isl_union_set *set,
5131 __isl_keep isl_multi_union_pw_aff *obj);
5133 Compute the minimum or maximum of the integer affine expression C<obj>
5134 over the points in C<set>, returning the result in C<opt>.
5135 The result is C<NULL> in case of an error, the optimal value in case
5136 there is one, negative infinity or infinity if the problem is unbounded and
5137 NaN if the problem is empty.
5139 =item * Parametric optimization
5141 __isl_give isl_pw_aff *isl_set_dim_min(
5142 __isl_take isl_set *set, int pos);
5143 __isl_give isl_pw_aff *isl_set_dim_max(
5144 __isl_take isl_set *set, int pos);
5145 __isl_give isl_pw_aff *isl_map_dim_min(
5146 __isl_take isl_map *map, int pos);
5147 __isl_give isl_pw_aff *isl_map_dim_max(
5148 __isl_take isl_map *map, int pos);
5150 Compute the minimum or maximum of the given set or output dimension
5151 as a function of the parameters (and input dimensions), but independently
5152 of the other set or output dimensions.
5153 For lexicographic optimization, see L<"Lexicographic Optimization">.
5157 The following functions compute either the set of (rational) coefficient
5158 values of valid constraints for the given set or the set of (rational)
5159 values satisfying the constraints with coefficients from the given set.
5160 Internally, these two sets of functions perform essentially the
5161 same operations, except that the set of coefficients is assumed to
5162 be a cone, while the set of values may be any polyhedron.
5163 The current implementation is based on the Farkas lemma and
5164 Fourier-Motzkin elimination, but this may change or be made optional
5165 in future. In particular, future implementations may use different
5166 dualization algorithms or skip the elimination step.
5168 #include <isl/set.h>
5169 __isl_give isl_basic_set *isl_basic_set_coefficients(
5170 __isl_take isl_basic_set *bset);
5171 __isl_give isl_basic_set_list *
5172 isl_basic_set_list_coefficients(
5173 __isl_take isl_basic_set_list *list);
5174 __isl_give isl_basic_set *isl_set_coefficients(
5175 __isl_take isl_set *set);
5176 __isl_give isl_union_set *isl_union_set_coefficients(
5177 __isl_take isl_union_set *bset);
5178 __isl_give isl_basic_set *isl_basic_set_solutions(
5179 __isl_take isl_basic_set *bset);
5180 __isl_give isl_basic_set *isl_set_solutions(
5181 __isl_take isl_set *set);
5182 __isl_give isl_union_set *isl_union_set_solutions(
5183 __isl_take isl_union_set *bset);
5187 __isl_give isl_map *isl_map_fixed_power_val(
5188 __isl_take isl_map *map,
5189 __isl_take isl_val *exp);
5190 __isl_give isl_union_map *
5191 isl_union_map_fixed_power_val(
5192 __isl_take isl_union_map *umap,
5193 __isl_take isl_val *exp);
5195 Compute the given power of C<map>, where C<exp> is assumed to be non-zero.
5196 If the exponent C<exp> is negative, then the -C<exp> th power of the inverse
5197 of C<map> is computed.
5199 __isl_give isl_map *isl_map_power(__isl_take isl_map *map,
5201 __isl_give isl_union_map *isl_union_map_power(
5202 __isl_take isl_union_map *umap, int *exact);
5204 Compute a parametric representation for all positive powers I<k> of C<map>.
5205 The result maps I<k> to a nested relation corresponding to the
5206 I<k>th power of C<map>.
5207 The result may be an overapproximation. If the result is known to be exact,
5208 then C<*exact> is set to C<1>.
5210 =item * Transitive closure
5212 __isl_give isl_map *isl_map_transitive_closure(
5213 __isl_take isl_map *map, int *exact);
5214 __isl_give isl_union_map *isl_union_map_transitive_closure(
5215 __isl_take isl_union_map *umap, int *exact);
5217 Compute the transitive closure of C<map>.
5218 The result may be an overapproximation. If the result is known to be exact,
5219 then C<*exact> is set to C<1>.
5221 =item * Reaching path lengths
5223 __isl_give isl_map *isl_map_reaching_path_lengths(
5224 __isl_take isl_map *map, int *exact);
5226 Compute a relation that maps each element in the range of C<map>
5227 to the lengths of all paths composed of edges in C<map> that
5228 end up in the given element.
5229 The result may be an overapproximation. If the result is known to be exact,
5230 then C<*exact> is set to C<1>.
5231 To compute the I<maximal> path length, the resulting relation
5232 should be postprocessed by C<isl_map_lexmax>.
5233 In particular, if the input relation is a dependence relation
5234 (mapping sources to sinks), then the maximal path length corresponds
5235 to the free schedule.
5236 Note, however, that C<isl_map_lexmax> expects the maximum to be
5237 finite, so if the path lengths are unbounded (possibly due to
5238 the overapproximation), then you will get an error message.
5242 #include <isl/space.h>
5243 __isl_give isl_space *isl_space_wrap(
5244 __isl_take isl_space *space);
5245 __isl_give isl_space *isl_space_unwrap(
5246 __isl_take isl_space *space);
5248 #include <isl/local_space.h>
5249 __isl_give isl_local_space *isl_local_space_wrap(
5250 __isl_take isl_local_space *ls);
5252 #include <isl/set.h>
5253 __isl_give isl_basic_map *isl_basic_set_unwrap(
5254 __isl_take isl_basic_set *bset);
5255 __isl_give isl_map *isl_set_unwrap(
5256 __isl_take isl_set *set);
5258 #include <isl/map.h>
5259 __isl_give isl_basic_set *isl_basic_map_wrap(
5260 __isl_take isl_basic_map *bmap);
5261 __isl_give isl_set *isl_map_wrap(
5262 __isl_take isl_map *map);
5264 #include <isl/union_set.h>
5265 __isl_give isl_union_map *isl_union_set_unwrap(
5266 __isl_take isl_union_set *uset);
5268 #include <isl/union_map.h>
5269 __isl_give isl_union_set *isl_union_map_wrap(
5270 __isl_take isl_union_map *umap);
5272 The input to C<isl_space_unwrap> should
5273 be the space of a set, while that of
5274 C<isl_space_wrap> should be the space of a relation.
5275 Conversely, the output of C<isl_space_unwrap> is the space
5276 of a relation, while that of C<isl_space_wrap> is the space of a set.
5280 Remove any internal structure of domain (and range) of the given
5281 set or relation. If there is any such internal structure in the input,
5282 then the name of the space is also removed.
5284 #include <isl/local_space.h>
5285 __isl_give isl_local_space *
5286 isl_local_space_flatten_domain(
5287 __isl_take isl_local_space *ls);
5288 __isl_give isl_local_space *
5289 isl_local_space_flatten_range(
5290 __isl_take isl_local_space *ls);
5292 #include <isl/set.h>
5293 __isl_give isl_basic_set *isl_basic_set_flatten(
5294 __isl_take isl_basic_set *bset);
5295 __isl_give isl_set *isl_set_flatten(
5296 __isl_take isl_set *set);
5298 #include <isl/map.h>
5299 __isl_give isl_basic_map *isl_basic_map_flatten_domain(
5300 __isl_take isl_basic_map *bmap);
5301 __isl_give isl_basic_map *isl_basic_map_flatten_range(
5302 __isl_take isl_basic_map *bmap);
5303 __isl_give isl_map *isl_map_flatten_range(
5304 __isl_take isl_map *map);
5305 __isl_give isl_map *isl_map_flatten_domain(
5306 __isl_take isl_map *map);
5307 __isl_give isl_basic_map *isl_basic_map_flatten(
5308 __isl_take isl_basic_map *bmap);
5309 __isl_give isl_map *isl_map_flatten(
5310 __isl_take isl_map *map);
5312 #include <isl/val.h>
5313 __isl_give isl_multi_val *isl_multi_val_flatten_range(
5314 __isl_take isl_multi_val *mv);
5316 #include <isl/aff.h>
5317 __isl_give isl_multi_aff *isl_multi_aff_flatten_domain(
5318 __isl_take isl_multi_aff *ma);
5319 __isl_give isl_multi_aff *isl_multi_aff_flatten_range(
5320 __isl_take isl_multi_aff *ma);
5321 __isl_give isl_multi_pw_aff *
5322 isl_multi_pw_aff_flatten_range(
5323 __isl_take isl_multi_pw_aff *mpa);
5324 __isl_give isl_multi_union_pw_aff *
5325 isl_multi_union_pw_aff_flatten_range(
5326 __isl_take isl_multi_union_pw_aff *mupa);
5328 #include <isl/map.h>
5329 __isl_give isl_map *isl_set_flatten_map(
5330 __isl_take isl_set *set);
5332 The function above constructs a relation
5333 that maps the input set to a flattened version of the set.
5337 Lift the input set to a space with extra dimensions corresponding
5338 to the existentially quantified variables in the input.
5339 In particular, the result lives in a wrapped map where the domain
5340 is the original space and the range corresponds to the original
5341 existentially quantified variables.
5343 #include <isl/set.h>
5344 __isl_give isl_basic_set *isl_basic_set_lift(
5345 __isl_take isl_basic_set *bset);
5346 __isl_give isl_set *isl_set_lift(
5347 __isl_take isl_set *set);
5348 __isl_give isl_union_set *isl_union_set_lift(
5349 __isl_take isl_union_set *uset);
5351 Given a local space that contains the existentially quantified
5352 variables of a set, a basic relation that, when applied to
5353 a basic set, has essentially the same effect as C<isl_basic_set_lift>,
5354 can be constructed using the following function.
5356 #include <isl/local_space.h>
5357 __isl_give isl_basic_map *isl_local_space_lifting(
5358 __isl_take isl_local_space *ls);
5360 #include <isl/aff.h>
5361 __isl_give isl_multi_aff *isl_multi_aff_lift(
5362 __isl_take isl_multi_aff *maff,
5363 __isl_give isl_local_space **ls);
5365 If the C<ls> argument of C<isl_multi_aff_lift> is not C<NULL>,
5366 then it is assigned the local space that lies at the basis of
5367 the lifting applied.
5369 =item * Internal Product
5371 #include <isl/space.h>
5372 __isl_give isl_space *isl_space_zip(
5373 __isl_take isl_space *space);
5375 #include <isl/map.h>
5376 __isl_give isl_basic_map *isl_basic_map_zip(
5377 __isl_take isl_basic_map *bmap);
5378 __isl_give isl_map *isl_map_zip(
5379 __isl_take isl_map *map);
5381 #include <isl/union_map.h>
5382 __isl_give isl_union_map *isl_union_map_zip(
5383 __isl_take isl_union_map *umap);
5385 Given a relation with nested relations for domain and range,
5386 interchange the range of the domain with the domain of the range.
5390 #include <isl/space.h>
5391 __isl_give isl_space *isl_space_curry(
5392 __isl_take isl_space *space);
5393 __isl_give isl_space *isl_space_uncurry(
5394 __isl_take isl_space *space);
5396 #include <isl/map.h>
5397 __isl_give isl_basic_map *isl_basic_map_curry(
5398 __isl_take isl_basic_map *bmap);
5399 __isl_give isl_basic_map *isl_basic_map_uncurry(
5400 __isl_take isl_basic_map *bmap);
5401 __isl_give isl_map *isl_map_curry(
5402 __isl_take isl_map *map);
5403 __isl_give isl_map *isl_map_uncurry(
5404 __isl_take isl_map *map);
5406 #include <isl/union_map.h>
5407 __isl_give isl_union_map *isl_union_map_curry(
5408 __isl_take isl_union_map *umap);
5409 __isl_give isl_union_map *isl_union_map_uncurry(
5410 __isl_take isl_union_map *umap);
5412 Given a relation with a nested relation for domain,
5413 the C<curry> functions
5414 move the range of the nested relation out of the domain
5415 and use it as the domain of a nested relation in the range,
5416 with the original range as range of this nested relation.
5417 The C<uncurry> functions perform the inverse operation.
5419 #include <isl/space.h>
5420 __isl_give isl_space *isl_space_range_curry(
5421 __isl_take isl_space *space);
5423 #include <isl/map.h>
5424 __isl_give isl_map *isl_map_range_curry(
5425 __isl_take isl_map *map);
5427 #include <isl/union_map.h>
5428 __isl_give isl_union_map *isl_union_map_range_curry(
5429 __isl_take isl_union_map *umap);
5431 These functions apply the currying to the relation that
5432 is nested inside the range of the input.
5434 =item * Aligning parameters
5436 Change the order of the parameters of the given set, relation
5438 such that the first parameters match those of C<model>.
5439 This may involve the introduction of extra parameters.
5440 All parameters need to be named.
5442 #include <isl/space.h>
5443 __isl_give isl_space *isl_space_align_params(
5444 __isl_take isl_space *space1,
5445 __isl_take isl_space *space2)
5447 #include <isl/set.h>
5448 __isl_give isl_basic_set *isl_basic_set_align_params(
5449 __isl_take isl_basic_set *bset,
5450 __isl_take isl_space *model);
5451 __isl_give isl_set *isl_set_align_params(
5452 __isl_take isl_set *set,
5453 __isl_take isl_space *model);
5455 #include <isl/map.h>
5456 __isl_give isl_basic_map *isl_basic_map_align_params(
5457 __isl_take isl_basic_map *bmap,
5458 __isl_take isl_space *model);
5459 __isl_give isl_map *isl_map_align_params(
5460 __isl_take isl_map *map,
5461 __isl_take isl_space *model);
5463 #include <isl/val.h>
5464 __isl_give isl_multi_val *isl_multi_val_align_params(
5465 __isl_take isl_multi_val *mv,
5466 __isl_take isl_space *model);
5468 #include <isl/aff.h>
5469 __isl_give isl_aff *isl_aff_align_params(
5470 __isl_take isl_aff *aff,
5471 __isl_take isl_space *model);
5472 __isl_give isl_multi_aff *isl_multi_aff_align_params(
5473 __isl_take isl_multi_aff *multi,
5474 __isl_take isl_space *model);
5475 __isl_give isl_pw_aff *isl_pw_aff_align_params(
5476 __isl_take isl_pw_aff *pwaff,
5477 __isl_take isl_space *model);
5478 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_align_params(
5479 __isl_take isl_pw_multi_aff *pma,
5480 __isl_take isl_space *model);
5481 __isl_give isl_union_pw_aff *
5482 isl_union_pw_aff_align_params(
5483 __isl_take isl_union_pw_aff *upa,
5484 __isl_take isl_space *model);
5485 __isl_give isl_union_pw_multi_aff *
5486 isl_union_pw_multi_aff_align_params(
5487 __isl_take isl_union_pw_multi_aff *upma,
5488 __isl_take isl_space *model);
5489 __isl_give isl_multi_union_pw_aff *
5490 isl_multi_union_pw_aff_align_params(
5491 __isl_take isl_multi_union_pw_aff *mupa,
5492 __isl_take isl_space *model);
5494 #include <isl/polynomial.h>
5495 __isl_give isl_qpolynomial *isl_qpolynomial_align_params(
5496 __isl_take isl_qpolynomial *qp,
5497 __isl_take isl_space *model);
5499 =item * Unary Arithmetic Operations
5501 #include <isl/set.h>
5502 __isl_give isl_set *isl_set_neg(
5503 __isl_take isl_set *set);
5504 #include <isl/map.h>
5505 __isl_give isl_map *isl_map_neg(
5506 __isl_take isl_map *map);
5508 C<isl_set_neg> constructs a set containing the opposites of
5509 the elements in its argument.
5510 The domain of the result of C<isl_map_neg> is the same
5511 as the domain of its argument. The corresponding range
5512 elements are the opposites of the corresponding range
5513 elements in the argument.
5515 #include <isl/val.h>
5516 __isl_give isl_multi_val *isl_multi_val_neg(
5517 __isl_take isl_multi_val *mv);
5519 #include <isl/aff.h>
5520 __isl_give isl_aff *isl_aff_neg(
5521 __isl_take isl_aff *aff);
5522 __isl_give isl_multi_aff *isl_multi_aff_neg(
5523 __isl_take isl_multi_aff *ma);
5524 __isl_give isl_pw_aff *isl_pw_aff_neg(
5525 __isl_take isl_pw_aff *pwaff);
5526 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_neg(
5527 __isl_take isl_pw_multi_aff *pma);
5528 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_neg(
5529 __isl_take isl_multi_pw_aff *mpa);
5530 __isl_give isl_union_pw_aff *isl_union_pw_aff_neg(
5531 __isl_take isl_union_pw_aff *upa);
5532 __isl_give isl_union_pw_multi_aff *
5533 isl_union_pw_multi_aff_neg(
5534 __isl_take isl_union_pw_multi_aff *upma);
5535 __isl_give isl_multi_union_pw_aff *
5536 isl_multi_union_pw_aff_neg(
5537 __isl_take isl_multi_union_pw_aff *mupa);
5538 __isl_give isl_aff *isl_aff_ceil(
5539 __isl_take isl_aff *aff);
5540 __isl_give isl_pw_aff *isl_pw_aff_ceil(
5541 __isl_take isl_pw_aff *pwaff);
5542 __isl_give isl_aff *isl_aff_floor(
5543 __isl_take isl_aff *aff);
5544 __isl_give isl_multi_aff *isl_multi_aff_floor(
5545 __isl_take isl_multi_aff *ma);
5546 __isl_give isl_pw_aff *isl_pw_aff_floor(
5547 __isl_take isl_pw_aff *pwaff);
5548 __isl_give isl_union_pw_aff *isl_union_pw_aff_floor(
5549 __isl_take isl_union_pw_aff *upa);
5550 __isl_give isl_multi_union_pw_aff *
5551 isl_multi_union_pw_aff_floor(
5552 __isl_take isl_multi_union_pw_aff *mupa);
5554 #include <isl/aff.h>
5555 __isl_give isl_pw_aff *isl_pw_aff_list_min(
5556 __isl_take isl_pw_aff_list *list);
5557 __isl_give isl_pw_aff *isl_pw_aff_list_max(
5558 __isl_take isl_pw_aff_list *list);
5560 #include <isl/polynomial.h>
5561 __isl_give isl_qpolynomial *isl_qpolynomial_neg(
5562 __isl_take isl_qpolynomial *qp);
5563 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_neg(
5564 __isl_take isl_pw_qpolynomial *pwqp);
5565 __isl_give isl_union_pw_qpolynomial *
5566 isl_union_pw_qpolynomial_neg(
5567 __isl_take isl_union_pw_qpolynomial *upwqp);
5568 __isl_give isl_qpolynomial *isl_qpolynomial_pow(
5569 __isl_take isl_qpolynomial *qp,
5571 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_pow(
5572 __isl_take isl_pw_qpolynomial *pwqp,
5577 The following functions evaluate a function in a point.
5579 #include <isl/polynomial.h>
5580 __isl_give isl_val *isl_pw_qpolynomial_eval(
5581 __isl_take isl_pw_qpolynomial *pwqp,
5582 __isl_take isl_point *pnt);
5583 __isl_give isl_val *isl_pw_qpolynomial_fold_eval(
5584 __isl_take isl_pw_qpolynomial_fold *pwf,
5585 __isl_take isl_point *pnt);
5586 __isl_give isl_val *isl_union_pw_qpolynomial_eval(
5587 __isl_take isl_union_pw_qpolynomial *upwqp,
5588 __isl_take isl_point *pnt);
5589 __isl_give isl_val *isl_union_pw_qpolynomial_fold_eval(
5590 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5591 __isl_take isl_point *pnt);
5593 =item * Dimension manipulation
5595 It is usually not advisable to directly change the (input or output)
5596 space of a set or a relation as this removes the name and the internal
5597 structure of the space. However, the functions below can be useful
5598 to add new parameters, assuming
5599 C<isl_set_align_params> and C<isl_map_align_params>
5602 #include <isl/space.h>
5603 __isl_give isl_space *isl_space_add_dims(
5604 __isl_take isl_space *space,
5605 enum isl_dim_type type, unsigned n);
5606 __isl_give isl_space *isl_space_insert_dims(
5607 __isl_take isl_space *space,
5608 enum isl_dim_type type, unsigned pos, unsigned n);
5609 __isl_give isl_space *isl_space_drop_dims(
5610 __isl_take isl_space *space,
5611 enum isl_dim_type type, unsigned first, unsigned n);
5612 __isl_give isl_space *isl_space_move_dims(
5613 __isl_take isl_space *space,
5614 enum isl_dim_type dst_type, unsigned dst_pos,
5615 enum isl_dim_type src_type, unsigned src_pos,
5618 #include <isl/local_space.h>
5619 __isl_give isl_local_space *isl_local_space_add_dims(
5620 __isl_take isl_local_space *ls,
5621 enum isl_dim_type type, unsigned n);
5622 __isl_give isl_local_space *isl_local_space_insert_dims(
5623 __isl_take isl_local_space *ls,
5624 enum isl_dim_type type, unsigned first, unsigned n);
5625 __isl_give isl_local_space *isl_local_space_drop_dims(
5626 __isl_take isl_local_space *ls,
5627 enum isl_dim_type type, unsigned first, unsigned n);
5629 #include <isl/set.h>
5630 __isl_give isl_basic_set *isl_basic_set_add_dims(
5631 __isl_take isl_basic_set *bset,
5632 enum isl_dim_type type, unsigned n);
5633 __isl_give isl_set *isl_set_add_dims(
5634 __isl_take isl_set *set,
5635 enum isl_dim_type type, unsigned n);
5636 __isl_give isl_basic_set *isl_basic_set_insert_dims(
5637 __isl_take isl_basic_set *bset,
5638 enum isl_dim_type type, unsigned pos,
5640 __isl_give isl_set *isl_set_insert_dims(
5641 __isl_take isl_set *set,
5642 enum isl_dim_type type, unsigned pos, unsigned n);
5643 __isl_give isl_basic_set *isl_basic_set_move_dims(
5644 __isl_take isl_basic_set *bset,
5645 enum isl_dim_type dst_type, unsigned dst_pos,
5646 enum isl_dim_type src_type, unsigned src_pos,
5648 __isl_give isl_set *isl_set_move_dims(
5649 __isl_take isl_set *set,
5650 enum isl_dim_type dst_type, unsigned dst_pos,
5651 enum isl_dim_type src_type, unsigned src_pos,
5654 #include <isl/map.h>
5655 __isl_give isl_basic_map *isl_basic_map_add_dims(
5656 __isl_take isl_basic_map *bmap,
5657 enum isl_dim_type type, unsigned n);
5658 __isl_give isl_map *isl_map_add_dims(
5659 __isl_take isl_map *map,
5660 enum isl_dim_type type, unsigned n);
5661 __isl_give isl_basic_map *isl_basic_map_insert_dims(
5662 __isl_take isl_basic_map *bmap,
5663 enum isl_dim_type type, unsigned pos,
5665 __isl_give isl_map *isl_map_insert_dims(
5666 __isl_take isl_map *map,
5667 enum isl_dim_type type, unsigned pos, unsigned n);
5668 __isl_give isl_basic_map *isl_basic_map_move_dims(
5669 __isl_take isl_basic_map *bmap,
5670 enum isl_dim_type dst_type, unsigned dst_pos,
5671 enum isl_dim_type src_type, unsigned src_pos,
5673 __isl_give isl_map *isl_map_move_dims(
5674 __isl_take isl_map *map,
5675 enum isl_dim_type dst_type, unsigned dst_pos,
5676 enum isl_dim_type src_type, unsigned src_pos,
5679 #include <isl/val.h>
5680 __isl_give isl_multi_val *isl_multi_val_insert_dims(
5681 __isl_take isl_multi_val *mv,
5682 enum isl_dim_type type, unsigned first, unsigned n);
5683 __isl_give isl_multi_val *isl_multi_val_add_dims(
5684 __isl_take isl_multi_val *mv,
5685 enum isl_dim_type type, unsigned n);
5686 __isl_give isl_multi_val *isl_multi_val_drop_dims(
5687 __isl_take isl_multi_val *mv,
5688 enum isl_dim_type type, unsigned first, unsigned n);
5690 #include <isl/aff.h>
5691 __isl_give isl_aff *isl_aff_insert_dims(
5692 __isl_take isl_aff *aff,
5693 enum isl_dim_type type, unsigned first, unsigned n);
5694 __isl_give isl_multi_aff *isl_multi_aff_insert_dims(
5695 __isl_take isl_multi_aff *ma,
5696 enum isl_dim_type type, unsigned first, unsigned n);
5697 __isl_give isl_pw_aff *isl_pw_aff_insert_dims(
5698 __isl_take isl_pw_aff *pwaff,
5699 enum isl_dim_type type, unsigned first, unsigned n);
5700 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_insert_dims(
5701 __isl_take isl_multi_pw_aff *mpa,
5702 enum isl_dim_type type, unsigned first, unsigned n);
5703 __isl_give isl_aff *isl_aff_add_dims(
5704 __isl_take isl_aff *aff,
5705 enum isl_dim_type type, unsigned n);
5706 __isl_give isl_multi_aff *isl_multi_aff_add_dims(
5707 __isl_take isl_multi_aff *ma,
5708 enum isl_dim_type type, unsigned n);
5709 __isl_give isl_pw_aff *isl_pw_aff_add_dims(
5710 __isl_take isl_pw_aff *pwaff,
5711 enum isl_dim_type type, unsigned n);
5712 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_add_dims(
5713 __isl_take isl_multi_pw_aff *mpa,
5714 enum isl_dim_type type, unsigned n);
5715 __isl_give isl_aff *isl_aff_drop_dims(
5716 __isl_take isl_aff *aff,
5717 enum isl_dim_type type, unsigned first, unsigned n);
5718 __isl_give isl_multi_aff *isl_multi_aff_drop_dims(
5719 __isl_take isl_multi_aff *maff,
5720 enum isl_dim_type type, unsigned first, unsigned n);
5721 __isl_give isl_pw_aff *isl_pw_aff_drop_dims(
5722 __isl_take isl_pw_aff *pwaff,
5723 enum isl_dim_type type, unsigned first, unsigned n);
5724 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_drop_dims(
5725 __isl_take isl_pw_multi_aff *pma,
5726 enum isl_dim_type type, unsigned first, unsigned n);
5727 __isl_give isl_union_pw_aff *isl_union_pw_aff_drop_dims(
5728 __isl_take isl_union_pw_aff *upa,
5729 enum isl_dim_type type, unsigned first, unsigned n);
5730 __isl_give isl_union_pw_multi_aff *
5731 isl_union_pw_multi_aff_drop_dims(
5732 __isl_take isl_union_pw_multi_aff *upma,
5733 enum isl_dim_type type,
5734 unsigned first, unsigned n);
5735 __isl_give isl_multi_union_pw_aff *
5736 isl_multi_union_pw_aff_drop_dims(
5737 __isl_take isl_multi_union_pw_aff *mupa,
5738 enum isl_dim_type type, unsigned first,
5740 __isl_give isl_aff *isl_aff_move_dims(
5741 __isl_take isl_aff *aff,
5742 enum isl_dim_type dst_type, unsigned dst_pos,
5743 enum isl_dim_type src_type, unsigned src_pos,
5745 __isl_give isl_multi_aff *isl_multi_aff_move_dims(
5746 __isl_take isl_multi_aff *ma,
5747 enum isl_dim_type dst_type, unsigned dst_pos,
5748 enum isl_dim_type src_type, unsigned src_pos,
5750 __isl_give isl_pw_aff *isl_pw_aff_move_dims(
5751 __isl_take isl_pw_aff *pa,
5752 enum isl_dim_type dst_type, unsigned dst_pos,
5753 enum isl_dim_type src_type, unsigned src_pos,
5755 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_move_dims(
5756 __isl_take isl_multi_pw_aff *pma,
5757 enum isl_dim_type dst_type, unsigned dst_pos,
5758 enum isl_dim_type src_type, unsigned src_pos,
5761 #include <isl/polynomial.h>
5762 __isl_give isl_union_pw_qpolynomial *
5763 isl_union_pw_qpolynomial_drop_dims(
5764 __isl_take isl_union_pw_qpolynomial *upwqp,
5765 enum isl_dim_type type,
5766 unsigned first, unsigned n);
5767 __isl_give isl_union_pw_qpolynomial_fold *
5768 isl_union_pw_qpolynomial_fold_drop_dims(
5769 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5770 enum isl_dim_type type,
5771 unsigned first, unsigned n);
5773 The operations on union expressions can only manipulate parameters.
5777 =head2 Binary Operations
5779 The two arguments of a binary operation not only need to live
5780 in the same C<isl_ctx>, they currently also need to have
5781 the same (number of) parameters.
5783 =head3 Basic Operations
5787 =item * Intersection
5789 #include <isl/local_space.h>
5790 __isl_give isl_local_space *isl_local_space_intersect(
5791 __isl_take isl_local_space *ls1,
5792 __isl_take isl_local_space *ls2);
5794 #include <isl/set.h>
5795 __isl_give isl_basic_set *isl_basic_set_intersect_params(
5796 __isl_take isl_basic_set *bset1,
5797 __isl_take isl_basic_set *bset2);
5798 __isl_give isl_basic_set *isl_basic_set_intersect(
5799 __isl_take isl_basic_set *bset1,
5800 __isl_take isl_basic_set *bset2);
5801 __isl_give isl_basic_set *isl_basic_set_list_intersect(
5802 __isl_take struct isl_basic_set_list *list);
5803 __isl_give isl_set *isl_set_intersect_params(
5804 __isl_take isl_set *set,
5805 __isl_take isl_set *params);
5806 __isl_give isl_set *isl_set_intersect(
5807 __isl_take isl_set *set1,
5808 __isl_take isl_set *set2);
5810 #include <isl/map.h>
5811 __isl_give isl_basic_map *isl_basic_map_intersect_domain(
5812 __isl_take isl_basic_map *bmap,
5813 __isl_take isl_basic_set *bset);
5814 __isl_give isl_basic_map *isl_basic_map_intersect_range(
5815 __isl_take isl_basic_map *bmap,
5816 __isl_take isl_basic_set *bset);
5817 __isl_give isl_basic_map *isl_basic_map_intersect(
5818 __isl_take isl_basic_map *bmap1,
5819 __isl_take isl_basic_map *bmap2);
5820 __isl_give isl_basic_map *isl_basic_map_list_intersect(
5821 __isl_take isl_basic_map_list *list);
5822 __isl_give isl_map *isl_map_intersect_params(
5823 __isl_take isl_map *map,
5824 __isl_take isl_set *params);
5825 __isl_give isl_map *isl_map_intersect_domain(
5826 __isl_take isl_map *map,
5827 __isl_take isl_set *set);
5828 __isl_give isl_map *isl_map_intersect_range(
5829 __isl_take isl_map *map,
5830 __isl_take isl_set *set);
5831 __isl_give isl_map *isl_map_intersect(
5832 __isl_take isl_map *map1,
5833 __isl_take isl_map *map2);
5835 #include <isl/union_set.h>
5836 __isl_give isl_union_set *isl_union_set_intersect_params(
5837 __isl_take isl_union_set *uset,
5838 __isl_take isl_set *set);
5839 __isl_give isl_union_set *isl_union_set_intersect(
5840 __isl_take isl_union_set *uset1,
5841 __isl_take isl_union_set *uset2);
5843 #include <isl/union_map.h>
5844 __isl_give isl_union_map *isl_union_map_intersect_params(
5845 __isl_take isl_union_map *umap,
5846 __isl_take isl_set *set);
5847 __isl_give isl_union_map *isl_union_map_intersect_domain(
5848 __isl_take isl_union_map *umap,
5849 __isl_take isl_union_set *uset);
5850 __isl_give isl_union_map *isl_union_map_intersect_range(
5851 __isl_take isl_union_map *umap,
5852 __isl_take isl_union_set *uset);
5853 __isl_give isl_union_map *isl_union_map_intersect(
5854 __isl_take isl_union_map *umap1,
5855 __isl_take isl_union_map *umap2);
5857 #include <isl/aff.h>
5858 __isl_give isl_pw_aff *isl_pw_aff_intersect_domain(
5859 __isl_take isl_pw_aff *pa,
5860 __isl_take isl_set *set);
5861 __isl_give isl_multi_pw_aff *
5862 isl_multi_pw_aff_intersect_domain(
5863 __isl_take isl_multi_pw_aff *mpa,
5864 __isl_take isl_set *domain);
5865 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_domain(
5866 __isl_take isl_pw_multi_aff *pma,
5867 __isl_take isl_set *set);
5868 __isl_give isl_union_pw_aff *isl_union_pw_aff_intersect_domain(
5869 __isl_take isl_union_pw_aff *upa,
5870 __isl_take isl_union_set *uset);
5871 __isl_give isl_union_pw_multi_aff *
5872 isl_union_pw_multi_aff_intersect_domain(
5873 __isl_take isl_union_pw_multi_aff *upma,
5874 __isl_take isl_union_set *uset);
5875 __isl_give isl_multi_union_pw_aff *
5876 isl_multi_union_pw_aff_intersect_domain(
5877 __isl_take isl_multi_union_pw_aff *mupa,
5878 __isl_take isl_union_set *uset);
5879 __isl_give isl_pw_aff *isl_pw_aff_intersect_params(
5880 __isl_take isl_pw_aff *pa,
5881 __isl_take isl_set *set);
5882 __isl_give isl_multi_pw_aff *
5883 isl_multi_pw_aff_intersect_params(
5884 __isl_take isl_multi_pw_aff *mpa,
5885 __isl_take isl_set *set);
5886 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_params(
5887 __isl_take isl_pw_multi_aff *pma,
5888 __isl_take isl_set *set);
5889 __isl_give isl_union_pw_aff *
5890 isl_union_pw_aff_intersect_params(
5891 __isl_take isl_union_pw_aff *upa,
5892 __isl_give isl_union_pw_multi_aff *
5893 isl_union_pw_multi_aff_intersect_params(
5894 __isl_take isl_union_pw_multi_aff *upma,
5895 __isl_take isl_set *set);
5896 __isl_give isl_multi_union_pw_aff *
5897 isl_multi_union_pw_aff_intersect_params(
5898 __isl_take isl_multi_union_pw_aff *mupa,
5899 __isl_take isl_set *params);
5900 isl_multi_union_pw_aff_intersect_range(
5901 __isl_take isl_multi_union_pw_aff *mupa,
5902 __isl_take isl_set *set);
5904 #include <isl/polynomial.h>
5905 __isl_give isl_pw_qpolynomial *
5906 isl_pw_qpolynomial_intersect_domain(
5907 __isl_take isl_pw_qpolynomial *pwpq,
5908 __isl_take isl_set *set);
5909 __isl_give isl_union_pw_qpolynomial *
5910 isl_union_pw_qpolynomial_intersect_domain(
5911 __isl_take isl_union_pw_qpolynomial *upwpq,
5912 __isl_take isl_union_set *uset);
5913 __isl_give isl_union_pw_qpolynomial_fold *
5914 isl_union_pw_qpolynomial_fold_intersect_domain(
5915 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5916 __isl_take isl_union_set *uset);
5917 __isl_give isl_pw_qpolynomial *
5918 isl_pw_qpolynomial_intersect_params(
5919 __isl_take isl_pw_qpolynomial *pwpq,
5920 __isl_take isl_set *set);
5921 __isl_give isl_pw_qpolynomial_fold *
5922 isl_pw_qpolynomial_fold_intersect_params(
5923 __isl_take isl_pw_qpolynomial_fold *pwf,
5924 __isl_take isl_set *set);
5925 __isl_give isl_union_pw_qpolynomial *
5926 isl_union_pw_qpolynomial_intersect_params(
5927 __isl_take isl_union_pw_qpolynomial *upwpq,
5928 __isl_take isl_set *set);
5929 __isl_give isl_union_pw_qpolynomial_fold *
5930 isl_union_pw_qpolynomial_fold_intersect_params(
5931 __isl_take isl_union_pw_qpolynomial_fold *upwf,
5932 __isl_take isl_set *set);
5934 The second argument to the C<_params> functions needs to be
5935 a parametric (basic) set. For the other functions, a parametric set
5936 for either argument is only allowed if the other argument is
5937 a parametric set as well.
5938 The list passed to C<isl_basic_set_list_intersect> needs to have
5939 at least one element and all elements need to live in the same space.
5940 The function C<isl_multi_union_pw_aff_intersect_range>
5941 restricts the input function to those shared domain elements
5942 that map to the specified range.
5946 #include <isl/set.h>
5947 __isl_give isl_set *isl_basic_set_union(
5948 __isl_take isl_basic_set *bset1,
5949 __isl_take isl_basic_set *bset2);
5950 __isl_give isl_set *isl_set_union(
5951 __isl_take isl_set *set1,
5952 __isl_take isl_set *set2);
5953 __isl_give isl_set *isl_set_list_union(
5954 __isl_take isl_set_list *list);
5956 #include <isl/map.h>
5957 __isl_give isl_map *isl_basic_map_union(
5958 __isl_take isl_basic_map *bmap1,
5959 __isl_take isl_basic_map *bmap2);
5960 __isl_give isl_map *isl_map_union(
5961 __isl_take isl_map *map1,
5962 __isl_take isl_map *map2);
5964 #include <isl/union_set.h>
5965 __isl_give isl_union_set *isl_union_set_union(
5966 __isl_take isl_union_set *uset1,
5967 __isl_take isl_union_set *uset2);
5968 __isl_give isl_union_set *isl_union_set_list_union(
5969 __isl_take isl_union_set_list *list);
5971 #include <isl/union_map.h>
5972 __isl_give isl_union_map *isl_union_map_union(
5973 __isl_take isl_union_map *umap1,
5974 __isl_take isl_union_map *umap2);
5976 The list passed to C<isl_set_list_union> needs to have
5977 at least one element and all elements need to live in the same space.
5979 =item * Set difference
5981 #include <isl/set.h>
5982 __isl_give isl_set *isl_set_subtract(
5983 __isl_take isl_set *set1,
5984 __isl_take isl_set *set2);
5986 #include <isl/map.h>
5987 __isl_give isl_map *isl_map_subtract(
5988 __isl_take isl_map *map1,
5989 __isl_take isl_map *map2);
5990 __isl_give isl_map *isl_map_subtract_domain(
5991 __isl_take isl_map *map,
5992 __isl_take isl_set *dom);
5993 __isl_give isl_map *isl_map_subtract_range(
5994 __isl_take isl_map *map,
5995 __isl_take isl_set *dom);
5997 #include <isl/union_set.h>
5998 __isl_give isl_union_set *isl_union_set_subtract(
5999 __isl_take isl_union_set *uset1,
6000 __isl_take isl_union_set *uset2);
6002 #include <isl/union_map.h>
6003 __isl_give isl_union_map *isl_union_map_subtract(
6004 __isl_take isl_union_map *umap1,
6005 __isl_take isl_union_map *umap2);
6006 __isl_give isl_union_map *isl_union_map_subtract_domain(
6007 __isl_take isl_union_map *umap,
6008 __isl_take isl_union_set *dom);
6009 __isl_give isl_union_map *isl_union_map_subtract_range(
6010 __isl_take isl_union_map *umap,
6011 __isl_take isl_union_set *dom);
6013 #include <isl/aff.h>
6014 __isl_give isl_pw_aff *isl_pw_aff_subtract_domain(
6015 __isl_take isl_pw_aff *pa,
6016 __isl_take isl_set *set);
6017 __isl_give isl_pw_multi_aff *
6018 isl_pw_multi_aff_subtract_domain(
6019 __isl_take isl_pw_multi_aff *pma,
6020 __isl_take isl_set *set);
6021 __isl_give isl_union_pw_aff *
6022 isl_union_pw_aff_subtract_domain(
6023 __isl_take isl_union_pw_aff *upa,
6024 __isl_take isl_union_set *uset);
6025 __isl_give isl_union_pw_multi_aff *
6026 isl_union_pw_multi_aff_subtract_domain(
6027 __isl_take isl_union_pw_multi_aff *upma,
6028 __isl_take isl_set *set);
6030 #include <isl/polynomial.h>
6031 __isl_give isl_pw_qpolynomial *
6032 isl_pw_qpolynomial_subtract_domain(
6033 __isl_take isl_pw_qpolynomial *pwpq,
6034 __isl_take isl_set *set);
6035 __isl_give isl_pw_qpolynomial_fold *
6036 isl_pw_qpolynomial_fold_subtract_domain(
6037 __isl_take isl_pw_qpolynomial_fold *pwf,
6038 __isl_take isl_set *set);
6039 __isl_give isl_union_pw_qpolynomial *
6040 isl_union_pw_qpolynomial_subtract_domain(
6041 __isl_take isl_union_pw_qpolynomial *upwpq,
6042 __isl_take isl_union_set *uset);
6043 __isl_give isl_union_pw_qpolynomial_fold *
6044 isl_union_pw_qpolynomial_fold_subtract_domain(
6045 __isl_take isl_union_pw_qpolynomial_fold *upwf,
6046 __isl_take isl_union_set *uset);
6050 #include <isl/space.h>
6051 __isl_give isl_space *isl_space_join(
6052 __isl_take isl_space *left,
6053 __isl_take isl_space *right);
6055 #include <isl/map.h>
6056 __isl_give isl_basic_set *isl_basic_set_apply(
6057 __isl_take isl_basic_set *bset,
6058 __isl_take isl_basic_map *bmap);
6059 __isl_give isl_set *isl_set_apply(
6060 __isl_take isl_set *set,
6061 __isl_take isl_map *map);
6062 __isl_give isl_union_set *isl_union_set_apply(
6063 __isl_take isl_union_set *uset,
6064 __isl_take isl_union_map *umap);
6065 __isl_give isl_basic_map *isl_basic_map_apply_domain(
6066 __isl_take isl_basic_map *bmap1,
6067 __isl_take isl_basic_map *bmap2);
6068 __isl_give isl_basic_map *isl_basic_map_apply_range(
6069 __isl_take isl_basic_map *bmap1,
6070 __isl_take isl_basic_map *bmap2);
6071 __isl_give isl_map *isl_map_apply_domain(
6072 __isl_take isl_map *map1,
6073 __isl_take isl_map *map2);
6074 __isl_give isl_map *isl_map_apply_range(
6075 __isl_take isl_map *map1,
6076 __isl_take isl_map *map2);
6078 #include <isl/union_map.h>
6079 __isl_give isl_union_map *isl_union_map_apply_domain(
6080 __isl_take isl_union_map *umap1,
6081 __isl_take isl_union_map *umap2);
6082 __isl_give isl_union_map *isl_union_map_apply_range(
6083 __isl_take isl_union_map *umap1,
6084 __isl_take isl_union_map *umap2);
6086 #include <isl/aff.h>
6087 __isl_give isl_union_pw_aff *
6088 isl_multi_union_pw_aff_apply_aff(
6089 __isl_take isl_multi_union_pw_aff *mupa,
6090 __isl_take isl_aff *aff);
6091 __isl_give isl_union_pw_aff *
6092 isl_multi_union_pw_aff_apply_pw_aff(
6093 __isl_take isl_multi_union_pw_aff *mupa,
6094 __isl_take isl_pw_aff *pa);
6095 __isl_give isl_multi_union_pw_aff *
6096 isl_multi_union_pw_aff_apply_multi_aff(
6097 __isl_take isl_multi_union_pw_aff *mupa,
6098 __isl_take isl_multi_aff *ma);
6099 __isl_give isl_multi_union_pw_aff *
6100 isl_multi_union_pw_aff_apply_pw_multi_aff(
6101 __isl_take isl_multi_union_pw_aff *mupa,
6102 __isl_take isl_pw_multi_aff *pma);
6104 The result of C<isl_multi_union_pw_aff_apply_aff> is defined
6105 over the shared domain of the elements of the input. The dimension is
6106 required to be greater than zero.
6107 The C<isl_multi_union_pw_aff> argument of
6108 C<isl_multi_union_pw_aff_apply_multi_aff> is allowed to be zero-dimensional,
6109 but only if the range of the C<isl_multi_aff> argument
6110 is also zero-dimensional.
6111 Similarly for C<isl_multi_union_pw_aff_apply_pw_multi_aff>.
6113 #include <isl/polynomial.h>
6114 __isl_give isl_pw_qpolynomial_fold *
6115 isl_set_apply_pw_qpolynomial_fold(
6116 __isl_take isl_set *set,
6117 __isl_take isl_pw_qpolynomial_fold *pwf,
6119 __isl_give isl_pw_qpolynomial_fold *
6120 isl_map_apply_pw_qpolynomial_fold(
6121 __isl_take isl_map *map,
6122 __isl_take isl_pw_qpolynomial_fold *pwf,
6124 __isl_give isl_union_pw_qpolynomial_fold *
6125 isl_union_set_apply_union_pw_qpolynomial_fold(
6126 __isl_take isl_union_set *uset,
6127 __isl_take isl_union_pw_qpolynomial_fold *upwf,
6129 __isl_give isl_union_pw_qpolynomial_fold *
6130 isl_union_map_apply_union_pw_qpolynomial_fold(
6131 __isl_take isl_union_map *umap,
6132 __isl_take isl_union_pw_qpolynomial_fold *upwf,
6135 The functions taking a map
6136 compose the given map with the given piecewise quasipolynomial reduction.
6137 That is, compute a bound (of the same type as C<pwf> or C<upwf> itself)
6138 over all elements in the intersection of the range of the map
6139 and the domain of the piecewise quasipolynomial reduction
6140 as a function of an element in the domain of the map.
6141 The functions taking a set compute a bound over all elements in the
6142 intersection of the set and the domain of the
6143 piecewise quasipolynomial reduction.
6147 #include <isl/set.h>
6148 __isl_give isl_basic_set *
6149 isl_basic_set_preimage_multi_aff(
6150 __isl_take isl_basic_set *bset,
6151 __isl_take isl_multi_aff *ma);
6152 __isl_give isl_set *isl_set_preimage_multi_aff(
6153 __isl_take isl_set *set,
6154 __isl_take isl_multi_aff *ma);
6155 __isl_give isl_set *isl_set_preimage_pw_multi_aff(
6156 __isl_take isl_set *set,
6157 __isl_take isl_pw_multi_aff *pma);
6158 __isl_give isl_set *isl_set_preimage_multi_pw_aff(
6159 __isl_take isl_set *set,
6160 __isl_take isl_multi_pw_aff *mpa);
6162 #include <isl/union_set.h>
6163 __isl_give isl_union_set *
6164 isl_union_set_preimage_multi_aff(
6165 __isl_take isl_union_set *uset,
6166 __isl_take isl_multi_aff *ma);
6167 __isl_give isl_union_set *
6168 isl_union_set_preimage_pw_multi_aff(
6169 __isl_take isl_union_set *uset,
6170 __isl_take isl_pw_multi_aff *pma);
6171 __isl_give isl_union_set *
6172 isl_union_set_preimage_union_pw_multi_aff(
6173 __isl_take isl_union_set *uset,
6174 __isl_take isl_union_pw_multi_aff *upma);
6176 #include <isl/map.h>
6177 __isl_give isl_basic_map *
6178 isl_basic_map_preimage_domain_multi_aff(
6179 __isl_take isl_basic_map *bmap,
6180 __isl_take isl_multi_aff *ma);
6181 __isl_give isl_map *isl_map_preimage_domain_multi_aff(
6182 __isl_take isl_map *map,
6183 __isl_take isl_multi_aff *ma);
6184 __isl_give isl_map *isl_map_preimage_range_multi_aff(
6185 __isl_take isl_map *map,
6186 __isl_take isl_multi_aff *ma);
6187 __isl_give isl_map *
6188 isl_map_preimage_domain_pw_multi_aff(
6189 __isl_take isl_map *map,
6190 __isl_take isl_pw_multi_aff *pma);
6191 __isl_give isl_map *
6192 isl_map_preimage_range_pw_multi_aff(
6193 __isl_take isl_map *map,
6194 __isl_take isl_pw_multi_aff *pma);
6195 __isl_give isl_map *
6196 isl_map_preimage_domain_multi_pw_aff(
6197 __isl_take isl_map *map,
6198 __isl_take isl_multi_pw_aff *mpa);
6199 __isl_give isl_basic_map *
6200 isl_basic_map_preimage_range_multi_aff(
6201 __isl_take isl_basic_map *bmap,
6202 __isl_take isl_multi_aff *ma);
6204 #include <isl/union_map.h>
6205 __isl_give isl_union_map *
6206 isl_union_map_preimage_domain_multi_aff(
6207 __isl_take isl_union_map *umap,
6208 __isl_take isl_multi_aff *ma);
6209 __isl_give isl_union_map *
6210 isl_union_map_preimage_range_multi_aff(
6211 __isl_take isl_union_map *umap,
6212 __isl_take isl_multi_aff *ma);
6213 __isl_give isl_union_map *
6214 isl_union_map_preimage_domain_pw_multi_aff(
6215 __isl_take isl_union_map *umap,
6216 __isl_take isl_pw_multi_aff *pma);
6217 __isl_give isl_union_map *
6218 isl_union_map_preimage_range_pw_multi_aff(
6219 __isl_take isl_union_map *umap,
6220 __isl_take isl_pw_multi_aff *pma);
6221 __isl_give isl_union_map *
6222 isl_union_map_preimage_domain_union_pw_multi_aff(
6223 __isl_take isl_union_map *umap,
6224 __isl_take isl_union_pw_multi_aff *upma);
6225 __isl_give isl_union_map *
6226 isl_union_map_preimage_range_union_pw_multi_aff(
6227 __isl_take isl_union_map *umap,
6228 __isl_take isl_union_pw_multi_aff *upma);
6230 These functions compute the preimage of the given set or map domain/range under
6231 the given function. In other words, the expression is plugged
6232 into the set description or into the domain/range of the map.
6236 #include <isl/aff.h>
6237 __isl_give isl_aff *isl_aff_pullback_aff(
6238 __isl_take isl_aff *aff1,
6239 __isl_take isl_aff *aff2);
6240 __isl_give isl_aff *isl_aff_pullback_multi_aff(
6241 __isl_take isl_aff *aff,
6242 __isl_take isl_multi_aff *ma);
6243 __isl_give isl_pw_aff *isl_pw_aff_pullback_multi_aff(
6244 __isl_take isl_pw_aff *pa,
6245 __isl_take isl_multi_aff *ma);
6246 __isl_give isl_pw_aff *isl_pw_aff_pullback_pw_multi_aff(
6247 __isl_take isl_pw_aff *pa,
6248 __isl_take isl_pw_multi_aff *pma);
6249 __isl_give isl_pw_aff *isl_pw_aff_pullback_multi_pw_aff(
6250 __isl_take isl_pw_aff *pa,
6251 __isl_take isl_multi_pw_aff *mpa);
6252 __isl_give isl_multi_aff *isl_multi_aff_pullback_multi_aff(
6253 __isl_take isl_multi_aff *ma1,
6254 __isl_take isl_multi_aff *ma2);
6255 __isl_give isl_pw_multi_aff *
6256 isl_pw_multi_aff_pullback_multi_aff(
6257 __isl_take isl_pw_multi_aff *pma,
6258 __isl_take isl_multi_aff *ma);
6259 __isl_give isl_multi_pw_aff *
6260 isl_multi_pw_aff_pullback_multi_aff(
6261 __isl_take isl_multi_pw_aff *mpa,
6262 __isl_take isl_multi_aff *ma);
6263 __isl_give isl_pw_multi_aff *
6264 isl_pw_multi_aff_pullback_pw_multi_aff(
6265 __isl_take isl_pw_multi_aff *pma1,
6266 __isl_take isl_pw_multi_aff *pma2);
6267 __isl_give isl_multi_pw_aff *
6268 isl_multi_pw_aff_pullback_pw_multi_aff(
6269 __isl_take isl_multi_pw_aff *mpa,
6270 __isl_take isl_pw_multi_aff *pma);
6271 __isl_give isl_multi_pw_aff *
6272 isl_multi_pw_aff_pullback_multi_pw_aff(
6273 __isl_take isl_multi_pw_aff *mpa1,
6274 __isl_take isl_multi_pw_aff *mpa2);
6275 __isl_give isl_union_pw_aff *
6276 isl_union_pw_aff_pullback_union_pw_multi_aff(
6277 __isl_take isl_union_pw_aff *upa,
6278 __isl_take isl_union_pw_multi_aff *upma);
6279 __isl_give isl_union_pw_multi_aff *
6280 isl_union_pw_multi_aff_pullback_union_pw_multi_aff(
6281 __isl_take isl_union_pw_multi_aff *upma1,
6282 __isl_take isl_union_pw_multi_aff *upma2);
6283 __isl_give isl_multi_union_pw_aff *
6284 isl_multi_union_pw_aff_pullback_union_pw_multi_aff(
6285 __isl_take isl_multi_union_pw_aff *mupa,
6286 __isl_take isl_union_pw_multi_aff *upma);
6288 These functions precompose the first expression by the second function.
6289 In other words, the second function is plugged
6290 into the first expression.
6294 #include <isl/aff.h>
6295 __isl_give isl_basic_set *isl_aff_eq_basic_set(
6296 __isl_take isl_aff *aff1,
6297 __isl_take isl_aff *aff2);
6298 __isl_give isl_set *isl_aff_eq_set(
6299 __isl_take isl_aff *aff1,
6300 __isl_take isl_aff *aff2);
6301 __isl_give isl_basic_set *isl_aff_le_basic_set(
6302 __isl_take isl_aff *aff1,
6303 __isl_take isl_aff *aff2);
6304 __isl_give isl_set *isl_aff_le_set(
6305 __isl_take isl_aff *aff1,
6306 __isl_take isl_aff *aff2);
6307 __isl_give isl_basic_set *isl_aff_lt_basic_set(
6308 __isl_take isl_aff *aff1,
6309 __isl_take isl_aff *aff2);
6310 __isl_give isl_set *isl_aff_lt_set(
6311 __isl_take isl_aff *aff1,
6312 __isl_take isl_aff *aff2);
6313 __isl_give isl_basic_set *isl_aff_ge_basic_set(
6314 __isl_take isl_aff *aff1,
6315 __isl_take isl_aff *aff2);
6316 __isl_give isl_set *isl_aff_ge_set(
6317 __isl_take isl_aff *aff1,
6318 __isl_take isl_aff *aff2);
6319 __isl_give isl_basic_set *isl_aff_gt_basic_set(
6320 __isl_take isl_aff *aff1,
6321 __isl_take isl_aff *aff2);
6322 __isl_give isl_set *isl_pw_aff_eq_set(
6323 __isl_take isl_pw_aff *pwaff1,
6324 __isl_take isl_pw_aff *pwaff2);
6325 __isl_give isl_set *isl_pw_aff_ne_set(
6326 __isl_take isl_pw_aff *pwaff1,
6327 __isl_take isl_pw_aff *pwaff2);
6328 __isl_give isl_set *isl_pw_aff_le_set(
6329 __isl_take isl_pw_aff *pwaff1,
6330 __isl_take isl_pw_aff *pwaff2);
6331 __isl_give isl_set *isl_pw_aff_lt_set(
6332 __isl_take isl_pw_aff *pwaff1,
6333 __isl_take isl_pw_aff *pwaff2);
6334 __isl_give isl_set *isl_pw_aff_ge_set(
6335 __isl_take isl_pw_aff *pwaff1,
6336 __isl_take isl_pw_aff *pwaff2);
6337 __isl_give isl_set *isl_pw_aff_gt_set(
6338 __isl_take isl_pw_aff *pwaff1,
6339 __isl_take isl_pw_aff *pwaff2);
6341 __isl_give isl_set *isl_multi_aff_lex_le_set(
6342 __isl_take isl_multi_aff *ma1,
6343 __isl_take isl_multi_aff *ma2);
6344 __isl_give isl_set *isl_multi_aff_lex_lt_set(
6345 __isl_take isl_multi_aff *ma1,
6346 __isl_take isl_multi_aff *ma2);
6347 __isl_give isl_set *isl_multi_aff_lex_ge_set(
6348 __isl_take isl_multi_aff *ma1,
6349 __isl_take isl_multi_aff *ma2);
6350 __isl_give isl_set *isl_multi_aff_lex_gt_set(
6351 __isl_take isl_multi_aff *ma1,
6352 __isl_take isl_multi_aff *ma2);
6354 __isl_give isl_set *isl_pw_aff_list_eq_set(
6355 __isl_take isl_pw_aff_list *list1,
6356 __isl_take isl_pw_aff_list *list2);
6357 __isl_give isl_set *isl_pw_aff_list_ne_set(
6358 __isl_take isl_pw_aff_list *list1,
6359 __isl_take isl_pw_aff_list *list2);
6360 __isl_give isl_set *isl_pw_aff_list_le_set(
6361 __isl_take isl_pw_aff_list *list1,
6362 __isl_take isl_pw_aff_list *list2);
6363 __isl_give isl_set *isl_pw_aff_list_lt_set(
6364 __isl_take isl_pw_aff_list *list1,
6365 __isl_take isl_pw_aff_list *list2);
6366 __isl_give isl_set *isl_pw_aff_list_ge_set(
6367 __isl_take isl_pw_aff_list *list1,
6368 __isl_take isl_pw_aff_list *list2);
6369 __isl_give isl_set *isl_pw_aff_list_gt_set(
6370 __isl_take isl_pw_aff_list *list1,
6371 __isl_take isl_pw_aff_list *list2);
6373 The function C<isl_aff_ge_basic_set> returns a basic set
6374 containing those elements in the shared space
6375 of C<aff1> and C<aff2> where C<aff1> is greater than or equal to C<aff2>.
6376 The function C<isl_pw_aff_ge_set> returns a set
6377 containing those elements in the shared domain
6378 of C<pwaff1> and C<pwaff2> where C<pwaff1> is
6379 greater than or equal to C<pwaff2>.
6380 The function C<isl_multi_aff_lex_le_set> returns a set
6381 containing those elements in the shared domain space
6382 where C<ma1> is lexicographically smaller than or
6384 The functions operating on C<isl_pw_aff_list> apply the corresponding
6385 C<isl_pw_aff> function to each pair of elements in the two lists.
6387 #include <isl/aff.h>
6388 __isl_give isl_map *isl_pw_aff_eq_map(
6389 __isl_take isl_pw_aff *pa1,
6390 __isl_take isl_pw_aff *pa2);
6391 __isl_give isl_map *isl_pw_aff_lt_map(
6392 __isl_take isl_pw_aff *pa1,
6393 __isl_take isl_pw_aff *pa2);
6394 __isl_give isl_map *isl_pw_aff_gt_map(
6395 __isl_take isl_pw_aff *pa1,
6396 __isl_take isl_pw_aff *pa2);
6398 __isl_give isl_map *isl_multi_pw_aff_eq_map(
6399 __isl_take isl_multi_pw_aff *mpa1,
6400 __isl_take isl_multi_pw_aff *mpa2);
6401 __isl_give isl_map *isl_multi_pw_aff_lex_lt_map(
6402 __isl_take isl_multi_pw_aff *mpa1,
6403 __isl_take isl_multi_pw_aff *mpa2);
6404 __isl_give isl_map *isl_multi_pw_aff_lex_gt_map(
6405 __isl_take isl_multi_pw_aff *mpa1,
6406 __isl_take isl_multi_pw_aff *mpa2);
6408 These functions return a map between domain elements of the arguments
6409 where the function values satisfy the given relation.
6411 #include <isl/union_map.h>
6412 __isl_give isl_union_map *
6413 isl_union_map_eq_at_multi_union_pw_aff(
6414 __isl_take isl_union_map *umap,
6415 __isl_take isl_multi_union_pw_aff *mupa);
6416 __isl_give isl_union_map *
6417 isl_union_map_lex_lt_at_multi_union_pw_aff(
6418 __isl_take isl_union_map *umap,
6419 __isl_take isl_multi_union_pw_aff *mupa);
6420 __isl_give isl_union_map *
6421 isl_union_map_lex_gt_at_multi_union_pw_aff(
6422 __isl_take isl_union_map *umap,
6423 __isl_take isl_multi_union_pw_aff *mupa);
6425 These functions select the subset of elements in the union map
6426 that have an equal or lexicographically smaller function value.
6428 =item * Cartesian Product
6430 #include <isl/space.h>
6431 __isl_give isl_space *isl_space_product(
6432 __isl_take isl_space *space1,
6433 __isl_take isl_space *space2);
6434 __isl_give isl_space *isl_space_domain_product(
6435 __isl_take isl_space *space1,
6436 __isl_take isl_space *space2);
6437 __isl_give isl_space *isl_space_range_product(
6438 __isl_take isl_space *space1,
6439 __isl_take isl_space *space2);
6442 C<isl_space_product>, C<isl_space_domain_product>
6443 and C<isl_space_range_product> take pairs or relation spaces and
6444 produce a single relations space, where either the domain, the range
6445 or both domain and range are wrapped spaces of relations between
6446 the domains and/or ranges of the input spaces.
6447 If the product is only constructed over the domain or the range
6448 then the ranges or the domains of the inputs should be the same.
6449 The function C<isl_space_product> also accepts a pair of set spaces,
6450 in which case it returns a wrapped space of a relation between the
6453 #include <isl/set.h>
6454 __isl_give isl_set *isl_set_product(
6455 __isl_take isl_set *set1,
6456 __isl_take isl_set *set2);
6458 #include <isl/map.h>
6459 __isl_give isl_basic_map *isl_basic_map_domain_product(
6460 __isl_take isl_basic_map *bmap1,
6461 __isl_take isl_basic_map *bmap2);
6462 __isl_give isl_basic_map *isl_basic_map_range_product(
6463 __isl_take isl_basic_map *bmap1,
6464 __isl_take isl_basic_map *bmap2);
6465 __isl_give isl_basic_map *isl_basic_map_product(
6466 __isl_take isl_basic_map *bmap1,
6467 __isl_take isl_basic_map *bmap2);
6468 __isl_give isl_map *isl_map_domain_product(
6469 __isl_take isl_map *map1,
6470 __isl_take isl_map *map2);
6471 __isl_give isl_map *isl_map_range_product(
6472 __isl_take isl_map *map1,
6473 __isl_take isl_map *map2);
6474 __isl_give isl_map *isl_map_product(
6475 __isl_take isl_map *map1,
6476 __isl_take isl_map *map2);
6478 #include <isl/union_set.h>
6479 __isl_give isl_union_set *isl_union_set_product(
6480 __isl_take isl_union_set *uset1,
6481 __isl_take isl_union_set *uset2);
6483 #include <isl/union_map.h>
6484 __isl_give isl_union_map *isl_union_map_domain_product(
6485 __isl_take isl_union_map *umap1,
6486 __isl_take isl_union_map *umap2);
6487 __isl_give isl_union_map *isl_union_map_range_product(
6488 __isl_take isl_union_map *umap1,
6489 __isl_take isl_union_map *umap2);
6490 __isl_give isl_union_map *isl_union_map_product(
6491 __isl_take isl_union_map *umap1,
6492 __isl_take isl_union_map *umap2);
6494 #include <isl/val.h>
6495 __isl_give isl_multi_val *isl_multi_val_range_product(
6496 __isl_take isl_multi_val *mv1,
6497 __isl_take isl_multi_val *mv2);
6498 __isl_give isl_multi_val *isl_multi_val_product(
6499 __isl_take isl_multi_val *mv1,
6500 __isl_take isl_multi_val *mv2);
6502 #include <isl/aff.h>
6503 __isl_give isl_multi_aff *isl_multi_aff_range_product(
6504 __isl_take isl_multi_aff *ma1,
6505 __isl_take isl_multi_aff *ma2);
6506 __isl_give isl_multi_aff *isl_multi_aff_product(
6507 __isl_take isl_multi_aff *ma1,
6508 __isl_take isl_multi_aff *ma2);
6509 __isl_give isl_multi_pw_aff *
6510 isl_multi_pw_aff_range_product(
6511 __isl_take isl_multi_pw_aff *mpa1,
6512 __isl_take isl_multi_pw_aff *mpa2);
6513 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_product(
6514 __isl_take isl_multi_pw_aff *mpa1,
6515 __isl_take isl_multi_pw_aff *mpa2);
6516 __isl_give isl_pw_multi_aff *
6517 isl_pw_multi_aff_range_product(
6518 __isl_take isl_pw_multi_aff *pma1,
6519 __isl_take isl_pw_multi_aff *pma2);
6520 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_product(
6521 __isl_take isl_pw_multi_aff *pma1,
6522 __isl_take isl_pw_multi_aff *pma2);
6523 __isl_give isl_multi_union_pw_aff *
6524 isl_multi_union_pw_aff_range_product(
6525 __isl_take isl_multi_union_pw_aff *mupa1,
6526 __isl_take isl_multi_union_pw_aff *mupa2);
6528 The above functions compute the cross product of the given
6529 sets, relations or functions. The domains and ranges of the results
6530 are wrapped maps between domains and ranges of the inputs.
6531 To obtain a ``flat'' product, use the following functions
6534 #include <isl/set.h>
6535 __isl_give isl_basic_set *isl_basic_set_flat_product(
6536 __isl_take isl_basic_set *bset1,
6537 __isl_take isl_basic_set *bset2);
6538 __isl_give isl_set *isl_set_flat_product(
6539 __isl_take isl_set *set1,
6540 __isl_take isl_set *set2);
6542 #include <isl/map.h>
6543 __isl_give isl_basic_map *isl_basic_map_flat_range_product(
6544 __isl_take isl_basic_map *bmap1,
6545 __isl_take isl_basic_map *bmap2);
6546 __isl_give isl_map *isl_map_flat_domain_product(
6547 __isl_take isl_map *map1,
6548 __isl_take isl_map *map2);
6549 __isl_give isl_map *isl_map_flat_range_product(
6550 __isl_take isl_map *map1,
6551 __isl_take isl_map *map2);
6552 __isl_give isl_basic_map *isl_basic_map_flat_product(
6553 __isl_take isl_basic_map *bmap1,
6554 __isl_take isl_basic_map *bmap2);
6555 __isl_give isl_map *isl_map_flat_product(
6556 __isl_take isl_map *map1,
6557 __isl_take isl_map *map2);
6559 #include <isl/union_map.h>
6560 __isl_give isl_union_map *
6561 isl_union_map_flat_domain_product(
6562 __isl_take isl_union_map *umap1,
6563 __isl_take isl_union_map *umap2);
6564 __isl_give isl_union_map *
6565 isl_union_map_flat_range_product(
6566 __isl_take isl_union_map *umap1,
6567 __isl_take isl_union_map *umap2);
6569 #include <isl/val.h>
6570 __isl_give isl_multi_val *isl_multi_val_flat_range_product(
6571 __isl_take isl_multi_val *mv1,
6572 __isl_take isl_multi_aff *mv2);
6574 #include <isl/aff.h>
6575 __isl_give isl_multi_aff *isl_multi_aff_flat_range_product(
6576 __isl_take isl_multi_aff *ma1,
6577 __isl_take isl_multi_aff *ma2);
6578 __isl_give isl_pw_multi_aff *
6579 isl_pw_multi_aff_flat_range_product(
6580 __isl_take isl_pw_multi_aff *pma1,
6581 __isl_take isl_pw_multi_aff *pma2);
6582 __isl_give isl_multi_pw_aff *
6583 isl_multi_pw_aff_flat_range_product(
6584 __isl_take isl_multi_pw_aff *mpa1,
6585 __isl_take isl_multi_pw_aff *mpa2);
6586 __isl_give isl_union_pw_multi_aff *
6587 isl_union_pw_multi_aff_flat_range_product(
6588 __isl_take isl_union_pw_multi_aff *upma1,
6589 __isl_take isl_union_pw_multi_aff *upma2);
6590 __isl_give isl_multi_union_pw_aff *
6591 isl_multi_union_pw_aff_flat_range_product(
6592 __isl_take isl_multi_union_pw_aff *mupa1,
6593 __isl_take isl_multi_union_pw_aff *mupa2);
6595 #include <isl/space.h>
6596 __isl_give isl_space *isl_space_factor_domain(
6597 __isl_take isl_space *space);
6598 __isl_give isl_space *isl_space_factor_range(
6599 __isl_take isl_space *space);
6600 __isl_give isl_space *isl_space_domain_factor_domain(
6601 __isl_take isl_space *space);
6602 __isl_give isl_space *isl_space_domain_factor_range(
6603 __isl_take isl_space *space);
6604 __isl_give isl_space *isl_space_range_factor_domain(
6605 __isl_take isl_space *space);
6606 __isl_give isl_space *isl_space_range_factor_range(
6607 __isl_take isl_space *space);
6609 The functions C<isl_space_range_factor_domain> and
6610 C<isl_space_range_factor_range> extract the two arguments from
6611 the result of a call to C<isl_space_range_product>.
6613 The arguments of a call to a product can be extracted
6614 from the result using the following functions.
6616 #include <isl/map.h>
6617 __isl_give isl_map *isl_map_factor_domain(
6618 __isl_take isl_map *map);
6619 __isl_give isl_map *isl_map_factor_range(
6620 __isl_take isl_map *map);
6621 __isl_give isl_map *isl_map_domain_factor_domain(
6622 __isl_take isl_map *map);
6623 __isl_give isl_map *isl_map_domain_factor_range(
6624 __isl_take isl_map *map);
6625 __isl_give isl_map *isl_map_range_factor_domain(
6626 __isl_take isl_map *map);
6627 __isl_give isl_map *isl_map_range_factor_range(
6628 __isl_take isl_map *map);
6630 #include <isl/union_map.h>
6631 __isl_give isl_union_map *isl_union_map_factor_domain(
6632 __isl_take isl_union_map *umap);
6633 __isl_give isl_union_map *isl_union_map_factor_range(
6634 __isl_take isl_union_map *umap);
6635 __isl_give isl_union_map *
6636 isl_union_map_domain_factor_domain(
6637 __isl_take isl_union_map *umap);
6638 __isl_give isl_union_map *
6639 isl_union_map_domain_factor_range(
6640 __isl_take isl_union_map *umap);
6641 __isl_give isl_union_map *
6642 isl_union_map_range_factor_domain(
6643 __isl_take isl_union_map *umap);
6644 __isl_give isl_union_map *
6645 isl_union_map_range_factor_range(
6646 __isl_take isl_union_map *umap);
6648 #include <isl/val.h>
6649 __isl_give isl_multi_val *isl_multi_val_factor_range(
6650 __isl_take isl_multi_val *mv);
6651 __isl_give isl_multi_val *
6652 isl_multi_val_range_factor_domain(
6653 __isl_take isl_multi_val *mv);
6654 __isl_give isl_multi_val *
6655 isl_multi_val_range_factor_range(
6656 __isl_take isl_multi_val *mv);
6658 #include <isl/aff.h>
6659 __isl_give isl_multi_aff *isl_multi_aff_factor_range(
6660 __isl_take isl_multi_aff *ma);
6661 __isl_give isl_multi_aff *
6662 isl_multi_aff_range_factor_domain(
6663 __isl_take isl_multi_aff *ma);
6664 __isl_give isl_multi_aff *
6665 isl_multi_aff_range_factor_range(
6666 __isl_take isl_multi_aff *ma);
6667 __isl_give isl_multi_pw_aff *
6668 isl_multi_pw_aff_factor_range(
6669 __isl_take isl_multi_pw_aff *mpa);
6670 __isl_give isl_multi_pw_aff *
6671 isl_multi_pw_aff_range_factor_domain(
6672 __isl_take isl_multi_pw_aff *mpa);
6673 __isl_give isl_multi_pw_aff *
6674 isl_multi_pw_aff_range_factor_range(
6675 __isl_take isl_multi_pw_aff *mpa);
6676 __isl_give isl_multi_union_pw_aff *
6677 isl_multi_union_pw_aff_factor_range(
6678 __isl_take isl_multi_union_pw_aff *mupa);
6679 __isl_give isl_multi_union_pw_aff *
6680 isl_multi_union_pw_aff_range_factor_domain(
6681 __isl_take isl_multi_union_pw_aff *mupa);
6682 __isl_give isl_multi_union_pw_aff *
6683 isl_multi_union_pw_aff_range_factor_range(
6684 __isl_take isl_multi_union_pw_aff *mupa);
6686 The splice functions are a generalization of the flat product functions,
6687 where the second argument may be inserted at any position inside
6688 the first argument rather than being placed at the end.
6689 The functions C<isl_multi_val_factor_range>,
6690 C<isl_multi_aff_factor_range>,
6691 C<isl_multi_pw_aff_factor_range> and
6692 C<isl_multi_union_pw_aff_factor_range>
6693 take functions that live in a set space.
6695 #include <isl/val.h>
6696 __isl_give isl_multi_val *isl_multi_val_range_splice(
6697 __isl_take isl_multi_val *mv1, unsigned pos,
6698 __isl_take isl_multi_val *mv2);
6700 #include <isl/aff.h>
6701 __isl_give isl_multi_aff *isl_multi_aff_range_splice(
6702 __isl_take isl_multi_aff *ma1, unsigned pos,
6703 __isl_take isl_multi_aff *ma2);
6704 __isl_give isl_multi_aff *isl_multi_aff_splice(
6705 __isl_take isl_multi_aff *ma1,
6706 unsigned in_pos, unsigned out_pos,
6707 __isl_take isl_multi_aff *ma2);
6708 __isl_give isl_multi_pw_aff *
6709 isl_multi_pw_aff_range_splice(
6710 __isl_take isl_multi_pw_aff *mpa1, unsigned pos,
6711 __isl_take isl_multi_pw_aff *mpa2);
6712 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_splice(
6713 __isl_take isl_multi_pw_aff *mpa1,
6714 unsigned in_pos, unsigned out_pos,
6715 __isl_take isl_multi_pw_aff *mpa2);
6716 __isl_give isl_multi_union_pw_aff *
6717 isl_multi_union_pw_aff_range_splice(
6718 __isl_take isl_multi_union_pw_aff *mupa1,
6720 __isl_take isl_multi_union_pw_aff *mupa2);
6722 =item * Simplification
6724 When applied to a set or relation,
6725 the gist operation returns a set or relation that has the
6726 same intersection with the context as the input set or relation.
6727 Any implicit equality in the intersection is made explicit in the result,
6728 while all inequalities that are redundant with respect to the intersection
6730 In case of union sets and relations, the gist operation is performed
6733 When applied to a function,
6734 the gist operation applies the set gist operation to each of
6735 the cells in the domain of the input piecewise expression.
6736 The context is also exploited
6737 to simplify the expression associated to each cell.
6739 #include <isl/set.h>
6740 __isl_give isl_basic_set *isl_basic_set_gist(
6741 __isl_take isl_basic_set *bset,
6742 __isl_take isl_basic_set *context);
6743 __isl_give isl_set *isl_set_gist(__isl_take isl_set *set,
6744 __isl_take isl_set *context);
6745 __isl_give isl_set *isl_set_gist_params(
6746 __isl_take isl_set *set,
6747 __isl_take isl_set *context);
6749 #include <isl/map.h>
6750 __isl_give isl_basic_map *isl_basic_map_gist(
6751 __isl_take isl_basic_map *bmap,
6752 __isl_take isl_basic_map *context);
6753 __isl_give isl_basic_map *isl_basic_map_gist_domain(
6754 __isl_take isl_basic_map *bmap,
6755 __isl_take isl_basic_set *context);
6756 __isl_give isl_map *isl_map_gist(__isl_take isl_map *map,
6757 __isl_take isl_map *context);
6758 __isl_give isl_map *isl_map_gist_params(
6759 __isl_take isl_map *map,
6760 __isl_take isl_set *context);
6761 __isl_give isl_map *isl_map_gist_domain(
6762 __isl_take isl_map *map,
6763 __isl_take isl_set *context);
6764 __isl_give isl_map *isl_map_gist_range(
6765 __isl_take isl_map *map,
6766 __isl_take isl_set *context);
6768 #include <isl/union_set.h>
6769 __isl_give isl_union_set *isl_union_set_gist(
6770 __isl_take isl_union_set *uset,
6771 __isl_take isl_union_set *context);
6772 __isl_give isl_union_set *isl_union_set_gist_params(
6773 __isl_take isl_union_set *uset,
6774 __isl_take isl_set *set);
6776 #include <isl/union_map.h>
6777 __isl_give isl_union_map *isl_union_map_gist(
6778 __isl_take isl_union_map *umap,
6779 __isl_take isl_union_map *context);
6780 __isl_give isl_union_map *isl_union_map_gist_params(
6781 __isl_take isl_union_map *umap,
6782 __isl_take isl_set *set);
6783 __isl_give isl_union_map *isl_union_map_gist_domain(
6784 __isl_take isl_union_map *umap,
6785 __isl_take isl_union_set *uset);
6786 __isl_give isl_union_map *isl_union_map_gist_range(
6787 __isl_take isl_union_map *umap,
6788 __isl_take isl_union_set *uset);
6790 #include <isl/aff.h>
6791 __isl_give isl_aff *isl_aff_gist_params(
6792 __isl_take isl_aff *aff,
6793 __isl_take isl_set *context);
6794 __isl_give isl_aff *isl_aff_gist(__isl_take isl_aff *aff,
6795 __isl_take isl_set *context);
6796 __isl_give isl_multi_aff *isl_multi_aff_gist_params(
6797 __isl_take isl_multi_aff *maff,
6798 __isl_take isl_set *context);
6799 __isl_give isl_multi_aff *isl_multi_aff_gist(
6800 __isl_take isl_multi_aff *maff,
6801 __isl_take isl_set *context);
6802 __isl_give isl_pw_aff *isl_pw_aff_gist_params(
6803 __isl_take isl_pw_aff *pwaff,
6804 __isl_take isl_set *context);
6805 __isl_give isl_pw_aff *isl_pw_aff_gist(
6806 __isl_take isl_pw_aff *pwaff,
6807 __isl_take isl_set *context);
6808 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist_params(
6809 __isl_take isl_pw_multi_aff *pma,
6810 __isl_take isl_set *set);
6811 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist(
6812 __isl_take isl_pw_multi_aff *pma,
6813 __isl_take isl_set *set);
6814 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_gist_params(
6815 __isl_take isl_multi_pw_aff *mpa,
6816 __isl_take isl_set *set);
6817 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_gist(
6818 __isl_take isl_multi_pw_aff *mpa,
6819 __isl_take isl_set *set);
6820 __isl_give isl_union_pw_aff *isl_union_pw_aff_gist(
6821 __isl_take isl_union_pw_aff *upa,
6822 __isl_take isl_union_set *context);
6823 __isl_give isl_union_pw_aff *isl_union_pw_aff_gist_params(
6824 __isl_take isl_union_pw_aff *upa,
6825 __isl_take isl_set *context);
6826 __isl_give isl_union_pw_multi_aff *
6827 isl_union_pw_multi_aff_gist_params(
6828 __isl_take isl_union_pw_multi_aff *upma,
6829 __isl_take isl_set *context);
6830 __isl_give isl_union_pw_multi_aff *
6831 isl_union_pw_multi_aff_gist(
6832 __isl_take isl_union_pw_multi_aff *upma,
6833 __isl_take isl_union_set *context);
6834 __isl_give isl_multi_union_pw_aff *
6835 isl_multi_union_pw_aff_gist_params(
6836 __isl_take isl_multi_union_pw_aff *aff,
6837 __isl_take isl_set *context);
6838 __isl_give isl_multi_union_pw_aff *
6839 isl_multi_union_pw_aff_gist(
6840 __isl_take isl_multi_union_pw_aff *aff,
6841 __isl_take isl_union_set *context);
6843 #include <isl/polynomial.h>
6844 __isl_give isl_qpolynomial *isl_qpolynomial_gist_params(
6845 __isl_take isl_qpolynomial *qp,
6846 __isl_take isl_set *context);
6847 __isl_give isl_qpolynomial *isl_qpolynomial_gist(
6848 __isl_take isl_qpolynomial *qp,
6849 __isl_take isl_set *context);
6850 __isl_give isl_qpolynomial_fold *
6851 isl_qpolynomial_fold_gist_params(
6852 __isl_take isl_qpolynomial_fold *fold,
6853 __isl_take isl_set *context);
6854 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist(
6855 __isl_take isl_qpolynomial_fold *fold,
6856 __isl_take isl_set *context);
6857 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist_params(
6858 __isl_take isl_pw_qpolynomial *pwqp,
6859 __isl_take isl_set *context);
6860 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist(
6861 __isl_take isl_pw_qpolynomial *pwqp,
6862 __isl_take isl_set *context);
6863 __isl_give isl_pw_qpolynomial_fold *
6864 isl_pw_qpolynomial_fold_gist(
6865 __isl_take isl_pw_qpolynomial_fold *pwf,
6866 __isl_take isl_set *context);
6867 __isl_give isl_pw_qpolynomial_fold *
6868 isl_pw_qpolynomial_fold_gist_params(
6869 __isl_take isl_pw_qpolynomial_fold *pwf,
6870 __isl_take isl_set *context);
6871 __isl_give isl_union_pw_qpolynomial *
6872 isl_union_pw_qpolynomial_gist_params(
6873 __isl_take isl_union_pw_qpolynomial *upwqp,
6874 __isl_take isl_set *context);
6875 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_gist(
6876 __isl_take isl_union_pw_qpolynomial *upwqp,
6877 __isl_take isl_union_set *context);
6878 __isl_give isl_union_pw_qpolynomial_fold *
6879 isl_union_pw_qpolynomial_fold_gist(
6880 __isl_take isl_union_pw_qpolynomial_fold *upwf,
6881 __isl_take isl_union_set *context);
6882 __isl_give isl_union_pw_qpolynomial_fold *
6883 isl_union_pw_qpolynomial_fold_gist_params(
6884 __isl_take isl_union_pw_qpolynomial_fold *upwf,
6885 __isl_take isl_set *context);
6887 =item * Binary Arithmetic Operations
6889 #include <isl/set.h>
6890 __isl_give isl_set *isl_set_sum(
6891 __isl_take isl_set *set1,
6892 __isl_take isl_set *set2);
6893 #include <isl/map.h>
6894 __isl_give isl_map *isl_map_sum(
6895 __isl_take isl_map *map1,
6896 __isl_take isl_map *map2);
6898 C<isl_set_sum> computes the Minkowski sum of its two arguments,
6899 i.e., the set containing the sums of pairs of elements from
6900 C<set1> and C<set2>.
6901 The domain of the result of C<isl_map_sum> is the intersection
6902 of the domains of its two arguments. The corresponding range
6903 elements are the sums of the corresponding range elements
6904 in the two arguments.
6906 #include <isl/val.h>
6907 __isl_give isl_multi_val *isl_multi_val_add(
6908 __isl_take isl_multi_val *mv1,
6909 __isl_take isl_multi_val *mv2);
6910 __isl_give isl_multi_val *isl_multi_val_sub(
6911 __isl_take isl_multi_val *mv1,
6912 __isl_take isl_multi_val *mv2);
6914 #include <isl/aff.h>
6915 __isl_give isl_aff *isl_aff_add(
6916 __isl_take isl_aff *aff1,
6917 __isl_take isl_aff *aff2);
6918 __isl_give isl_multi_aff *isl_multi_aff_add(
6919 __isl_take isl_multi_aff *maff1,
6920 __isl_take isl_multi_aff *maff2);
6921 __isl_give isl_pw_aff *isl_pw_aff_add(
6922 __isl_take isl_pw_aff *pwaff1,
6923 __isl_take isl_pw_aff *pwaff2);
6924 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_add(
6925 __isl_take isl_multi_pw_aff *mpa1,
6926 __isl_take isl_multi_pw_aff *mpa2);
6927 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_add(
6928 __isl_take isl_pw_multi_aff *pma1,
6929 __isl_take isl_pw_multi_aff *pma2);
6930 __isl_give isl_union_pw_aff *isl_union_pw_aff_add(
6931 __isl_take isl_union_pw_aff *upa1,
6932 __isl_take isl_union_pw_aff *upa2);
6933 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_add(
6934 __isl_take isl_union_pw_multi_aff *upma1,
6935 __isl_take isl_union_pw_multi_aff *upma2);
6936 __isl_give isl_multi_union_pw_aff *
6937 isl_multi_union_pw_aff_add(
6938 __isl_take isl_multi_union_pw_aff *mupa1,
6939 __isl_take isl_multi_union_pw_aff *mupa2);
6940 __isl_give isl_pw_aff *isl_pw_aff_min(
6941 __isl_take isl_pw_aff *pwaff1,
6942 __isl_take isl_pw_aff *pwaff2);
6943 __isl_give isl_pw_aff *isl_pw_aff_max(
6944 __isl_take isl_pw_aff *pwaff1,
6945 __isl_take isl_pw_aff *pwaff2);
6946 __isl_give isl_aff *isl_aff_sub(
6947 __isl_take isl_aff *aff1,
6948 __isl_take isl_aff *aff2);
6949 __isl_give isl_multi_aff *isl_multi_aff_sub(
6950 __isl_take isl_multi_aff *ma1,
6951 __isl_take isl_multi_aff *ma2);
6952 __isl_give isl_pw_aff *isl_pw_aff_sub(
6953 __isl_take isl_pw_aff *pwaff1,
6954 __isl_take isl_pw_aff *pwaff2);
6955 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_sub(
6956 __isl_take isl_multi_pw_aff *mpa1,
6957 __isl_take isl_multi_pw_aff *mpa2);
6958 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_sub(
6959 __isl_take isl_pw_multi_aff *pma1,
6960 __isl_take isl_pw_multi_aff *pma2);
6961 __isl_give isl_union_pw_aff *isl_union_pw_aff_sub(
6962 __isl_take isl_union_pw_aff *upa1,
6963 __isl_take isl_union_pw_aff *upa2);
6964 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_sub(
6965 __isl_take isl_union_pw_multi_aff *upma1,
6966 __isl_take isl_union_pw_multi_aff *upma2);
6967 __isl_give isl_multi_union_pw_aff *
6968 isl_multi_union_pw_aff_sub(
6969 __isl_take isl_multi_union_pw_aff *mupa1,
6970 __isl_take isl_multi_union_pw_aff *mupa2);
6972 C<isl_aff_sub> subtracts the second argument from the first.
6974 #include <isl/polynomial.h>
6975 __isl_give isl_qpolynomial *isl_qpolynomial_add(
6976 __isl_take isl_qpolynomial *qp1,
6977 __isl_take isl_qpolynomial *qp2);
6978 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add(
6979 __isl_take isl_pw_qpolynomial *pwqp1,
6980 __isl_take isl_pw_qpolynomial *pwqp2);
6981 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add_disjoint(
6982 __isl_take isl_pw_qpolynomial *pwqp1,
6983 __isl_take isl_pw_qpolynomial *pwqp2);
6984 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_add(
6985 __isl_take isl_pw_qpolynomial_fold *pwf1,
6986 __isl_take isl_pw_qpolynomial_fold *pwf2);
6987 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add(
6988 __isl_take isl_union_pw_qpolynomial *upwqp1,
6989 __isl_take isl_union_pw_qpolynomial *upwqp2);
6990 __isl_give isl_qpolynomial *isl_qpolynomial_sub(
6991 __isl_take isl_qpolynomial *qp1,
6992 __isl_take isl_qpolynomial *qp2);
6993 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_sub(
6994 __isl_take isl_pw_qpolynomial *pwqp1,
6995 __isl_take isl_pw_qpolynomial *pwqp2);
6996 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_sub(
6997 __isl_take isl_union_pw_qpolynomial *upwqp1,
6998 __isl_take isl_union_pw_qpolynomial *upwqp2);
6999 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_fold(
7000 __isl_take isl_pw_qpolynomial_fold *pwf1,
7001 __isl_take isl_pw_qpolynomial_fold *pwf2);
7002 __isl_give isl_union_pw_qpolynomial_fold *
7003 isl_union_pw_qpolynomial_fold_fold(
7004 __isl_take isl_union_pw_qpolynomial_fold *upwf1,
7005 __isl_take isl_union_pw_qpolynomial_fold *upwf2);
7007 #include <isl/aff.h>
7008 __isl_give isl_pw_aff *isl_pw_aff_union_add(
7009 __isl_take isl_pw_aff *pwaff1,
7010 __isl_take isl_pw_aff *pwaff2);
7011 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_add(
7012 __isl_take isl_pw_multi_aff *pma1,
7013 __isl_take isl_pw_multi_aff *pma2);
7014 __isl_give isl_union_pw_aff *isl_union_pw_aff_union_add(
7015 __isl_take isl_union_pw_aff *upa1,
7016 __isl_take isl_union_pw_aff *upa2);
7017 __isl_give isl_union_pw_multi_aff *
7018 isl_union_pw_multi_aff_union_add(
7019 __isl_take isl_union_pw_multi_aff *upma1,
7020 __isl_take isl_union_pw_multi_aff *upma2);
7021 __isl_give isl_multi_union_pw_aff *
7022 isl_multi_union_pw_aff_union_add(
7023 __isl_take isl_multi_union_pw_aff *mupa1,
7024 __isl_take isl_multi_union_pw_aff *mupa2);
7025 __isl_give isl_pw_aff *isl_pw_aff_union_min(
7026 __isl_take isl_pw_aff *pwaff1,
7027 __isl_take isl_pw_aff *pwaff2);
7028 __isl_give isl_pw_aff *isl_pw_aff_union_max(
7029 __isl_take isl_pw_aff *pwaff1,
7030 __isl_take isl_pw_aff *pwaff2);
7032 The function C<isl_pw_aff_union_max> computes a piecewise quasi-affine
7033 expression with a domain that is the union of those of C<pwaff1> and
7034 C<pwaff2> and such that on each cell, the quasi-affine expression is
7035 the maximum of those of C<pwaff1> and C<pwaff2>. If only one of
7036 C<pwaff1> or C<pwaff2> is defined on a given cell, then the
7037 associated expression is the defined one.
7038 This in contrast to the C<isl_pw_aff_max> function, which is
7039 only defined on the shared definition domain of the arguments.
7041 #include <isl/val.h>
7042 __isl_give isl_multi_val *isl_multi_val_add_val(
7043 __isl_take isl_multi_val *mv,
7044 __isl_take isl_val *v);
7045 __isl_give isl_multi_val *isl_multi_val_mod_val(
7046 __isl_take isl_multi_val *mv,
7047 __isl_take isl_val *v);
7048 __isl_give isl_multi_val *isl_multi_val_scale_val(
7049 __isl_take isl_multi_val *mv,
7050 __isl_take isl_val *v);
7051 __isl_give isl_multi_val *isl_multi_val_scale_down_val(
7052 __isl_take isl_multi_val *mv,
7053 __isl_take isl_val *v);
7055 #include <isl/aff.h>
7056 __isl_give isl_aff *isl_aff_mod_val(__isl_take isl_aff *aff,
7057 __isl_take isl_val *mod);
7058 __isl_give isl_pw_aff *isl_pw_aff_mod_val(
7059 __isl_take isl_pw_aff *pa,
7060 __isl_take isl_val *mod);
7061 __isl_give isl_union_pw_aff *isl_union_pw_aff_mod_val(
7062 __isl_take isl_union_pw_aff *upa,
7063 __isl_take isl_val *f);
7064 __isl_give isl_aff *isl_aff_scale_val(__isl_take isl_aff *aff,
7065 __isl_take isl_val *v);
7066 __isl_give isl_multi_aff *isl_multi_aff_scale_val(
7067 __isl_take isl_multi_aff *ma,
7068 __isl_take isl_val *v);
7069 __isl_give isl_pw_aff *isl_pw_aff_scale_val(
7070 __isl_take isl_pw_aff *pa, __isl_take isl_val *v);
7071 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_scale_val(
7072 __isl_take isl_multi_pw_aff *mpa,
7073 __isl_take isl_val *v);
7074 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_val(
7075 __isl_take isl_pw_multi_aff *pma,
7076 __isl_take isl_val *v);
7077 __isl_give isl_union_pw_multi_aff *
7078 __isl_give isl_union_pw_aff *isl_union_pw_aff_scale_val(
7079 __isl_take isl_union_pw_aff *upa,
7080 __isl_take isl_val *f);
7081 isl_union_pw_multi_aff_scale_val(
7082 __isl_take isl_union_pw_multi_aff *upma,
7083 __isl_take isl_val *val);
7084 __isl_give isl_multi_union_pw_aff *
7085 isl_multi_union_pw_aff_scale_val(
7086 __isl_take isl_multi_union_pw_aff *mupa,
7087 __isl_take isl_val *v);
7088 __isl_give isl_aff *isl_aff_scale_down_ui(
7089 __isl_take isl_aff *aff, unsigned f);
7090 __isl_give isl_aff *isl_aff_scale_down_val(
7091 __isl_take isl_aff *aff, __isl_take isl_val *v);
7092 __isl_give isl_multi_aff *isl_multi_aff_scale_down_val(
7093 __isl_take isl_multi_aff *ma,
7094 __isl_take isl_val *v);
7095 __isl_give isl_pw_aff *isl_pw_aff_scale_down_val(
7096 __isl_take isl_pw_aff *pa,
7097 __isl_take isl_val *f);
7098 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_scale_down_val(
7099 __isl_take isl_multi_pw_aff *mpa,
7100 __isl_take isl_val *v);
7101 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_down_val(
7102 __isl_take isl_pw_multi_aff *pma,
7103 __isl_take isl_val *v);
7104 __isl_give isl_union_pw_aff *isl_union_pw_aff_scale_down_val(
7105 __isl_take isl_union_pw_aff *upa,
7106 __isl_take isl_val *v);
7107 __isl_give isl_union_pw_multi_aff *
7108 isl_union_pw_multi_aff_scale_down_val(
7109 __isl_take isl_union_pw_multi_aff *upma,
7110 __isl_take isl_val *val);
7111 __isl_give isl_multi_union_pw_aff *
7112 isl_multi_union_pw_aff_scale_down_val(
7113 __isl_take isl_multi_union_pw_aff *mupa,
7114 __isl_take isl_val *v);
7116 #include <isl/polynomial.h>
7117 __isl_give isl_qpolynomial *isl_qpolynomial_scale_val(
7118 __isl_take isl_qpolynomial *qp,
7119 __isl_take isl_val *v);
7120 __isl_give isl_qpolynomial_fold *
7121 isl_qpolynomial_fold_scale_val(
7122 __isl_take isl_qpolynomial_fold *fold,
7123 __isl_take isl_val *v);
7124 __isl_give isl_pw_qpolynomial *
7125 isl_pw_qpolynomial_scale_val(
7126 __isl_take isl_pw_qpolynomial *pwqp,
7127 __isl_take isl_val *v);
7128 __isl_give isl_pw_qpolynomial_fold *
7129 isl_pw_qpolynomial_fold_scale_val(
7130 __isl_take isl_pw_qpolynomial_fold *pwf,
7131 __isl_take isl_val *v);
7132 __isl_give isl_union_pw_qpolynomial *
7133 isl_union_pw_qpolynomial_scale_val(
7134 __isl_take isl_union_pw_qpolynomial *upwqp,
7135 __isl_take isl_val *v);
7136 __isl_give isl_union_pw_qpolynomial_fold *
7137 isl_union_pw_qpolynomial_fold_scale_val(
7138 __isl_take isl_union_pw_qpolynomial_fold *upwf,
7139 __isl_take isl_val *v);
7140 __isl_give isl_qpolynomial *
7141 isl_qpolynomial_scale_down_val(
7142 __isl_take isl_qpolynomial *qp,
7143 __isl_take isl_val *v);
7144 __isl_give isl_qpolynomial_fold *
7145 isl_qpolynomial_fold_scale_down_val(
7146 __isl_take isl_qpolynomial_fold *fold,
7147 __isl_take isl_val *v);
7148 __isl_give isl_pw_qpolynomial *
7149 isl_pw_qpolynomial_scale_down_val(
7150 __isl_take isl_pw_qpolynomial *pwqp,
7151 __isl_take isl_val *v);
7152 __isl_give isl_pw_qpolynomial_fold *
7153 isl_pw_qpolynomial_fold_scale_down_val(
7154 __isl_take isl_pw_qpolynomial_fold *pwf,
7155 __isl_take isl_val *v);
7156 __isl_give isl_union_pw_qpolynomial *
7157 isl_union_pw_qpolynomial_scale_down_val(
7158 __isl_take isl_union_pw_qpolynomial *upwqp,
7159 __isl_take isl_val *v);
7160 __isl_give isl_union_pw_qpolynomial_fold *
7161 isl_union_pw_qpolynomial_fold_scale_down_val(
7162 __isl_take isl_union_pw_qpolynomial_fold *upwf,
7163 __isl_take isl_val *v);
7165 #include <isl/val.h>
7166 __isl_give isl_multi_val *isl_multi_val_mod_multi_val(
7167 __isl_take isl_multi_val *mv1,
7168 __isl_take isl_multi_val *mv2);
7169 __isl_give isl_multi_val *isl_multi_val_scale_multi_val(
7170 __isl_take isl_multi_val *mv1,
7171 __isl_take isl_multi_val *mv2);
7172 __isl_give isl_multi_val *
7173 isl_multi_val_scale_down_multi_val(
7174 __isl_take isl_multi_val *mv1,
7175 __isl_take isl_multi_val *mv2);
7177 #include <isl/aff.h>
7178 __isl_give isl_multi_aff *isl_multi_aff_mod_multi_val(
7179 __isl_take isl_multi_aff *ma,
7180 __isl_take isl_multi_val *mv);
7181 __isl_give isl_multi_union_pw_aff *
7182 isl_multi_union_pw_aff_mod_multi_val(
7183 __isl_take isl_multi_union_pw_aff *upma,
7184 __isl_take isl_multi_val *mv);
7185 __isl_give isl_multi_pw_aff *
7186 isl_multi_pw_aff_mod_multi_val(
7187 __isl_take isl_multi_pw_aff *mpa,
7188 __isl_take isl_multi_val *mv);
7189 __isl_give isl_multi_aff *isl_multi_aff_scale_multi_val(
7190 __isl_take isl_multi_aff *ma,
7191 __isl_take isl_multi_val *mv);
7192 __isl_give isl_pw_multi_aff *
7193 isl_pw_multi_aff_scale_multi_val(
7194 __isl_take isl_pw_multi_aff *pma,
7195 __isl_take isl_multi_val *mv);
7196 __isl_give isl_multi_pw_aff *
7197 isl_multi_pw_aff_scale_multi_val(
7198 __isl_take isl_multi_pw_aff *mpa,
7199 __isl_take isl_multi_val *mv);
7200 __isl_give isl_multi_union_pw_aff *
7201 isl_multi_union_pw_aff_scale_multi_val(
7202 __isl_take isl_multi_union_pw_aff *mupa,
7203 __isl_take isl_multi_val *mv);
7204 __isl_give isl_union_pw_multi_aff *
7205 isl_union_pw_multi_aff_scale_multi_val(
7206 __isl_take isl_union_pw_multi_aff *upma,
7207 __isl_take isl_multi_val *mv);
7208 __isl_give isl_multi_aff *
7209 isl_multi_aff_scale_down_multi_val(
7210 __isl_take isl_multi_aff *ma,
7211 __isl_take isl_multi_val *mv);
7212 __isl_give isl_multi_pw_aff *
7213 isl_multi_pw_aff_scale_down_multi_val(
7214 __isl_take isl_multi_pw_aff *mpa,
7215 __isl_take isl_multi_val *mv);
7216 __isl_give isl_multi_union_pw_aff *
7217 isl_multi_union_pw_aff_scale_down_multi_val(
7218 __isl_take isl_multi_union_pw_aff *mupa,
7219 __isl_take isl_multi_val *mv);
7221 C<isl_multi_aff_scale_multi_val> scales the elements of C<ma>
7222 by the corresponding elements of C<mv>.
7224 #include <isl/aff.h>
7225 __isl_give isl_aff *isl_aff_mul(
7226 __isl_take isl_aff *aff1,
7227 __isl_take isl_aff *aff2);
7228 __isl_give isl_aff *isl_aff_div(
7229 __isl_take isl_aff *aff1,
7230 __isl_take isl_aff *aff2);
7231 __isl_give isl_pw_aff *isl_pw_aff_mul(
7232 __isl_take isl_pw_aff *pwaff1,
7233 __isl_take isl_pw_aff *pwaff2);
7234 __isl_give isl_pw_aff *isl_pw_aff_div(
7235 __isl_take isl_pw_aff *pa1,
7236 __isl_take isl_pw_aff *pa2);
7237 __isl_give isl_pw_aff *isl_pw_aff_tdiv_q(
7238 __isl_take isl_pw_aff *pa1,
7239 __isl_take isl_pw_aff *pa2);
7240 __isl_give isl_pw_aff *isl_pw_aff_tdiv_r(
7241 __isl_take isl_pw_aff *pa1,
7242 __isl_take isl_pw_aff *pa2);
7244 When multiplying two affine expressions, at least one of the two needs
7245 to be a constant. Similarly, when dividing an affine expression by another,
7246 the second expression needs to be a constant.
7247 C<isl_pw_aff_tdiv_q> computes the quotient of an integer division with
7248 rounding towards zero. C<isl_pw_aff_tdiv_r> computes the corresponding
7251 #include <isl/polynomial.h>
7252 __isl_give isl_qpolynomial *isl_qpolynomial_mul(
7253 __isl_take isl_qpolynomial *qp1,
7254 __isl_take isl_qpolynomial *qp2);
7255 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_mul(
7256 __isl_take isl_pw_qpolynomial *pwqp1,
7257 __isl_take isl_pw_qpolynomial *pwqp2);
7258 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_mul(
7259 __isl_take isl_union_pw_qpolynomial *upwqp1,
7260 __isl_take isl_union_pw_qpolynomial *upwqp2);
7264 =head3 Lexicographic Optimization
7266 Given a (basic) set C<set> (or C<bset>) and a zero-dimensional domain C<dom>,
7267 the following functions
7268 compute a set that contains the lexicographic minimum or maximum
7269 of the elements in C<set> (or C<bset>) for those values of the parameters
7270 that satisfy C<dom>.
7271 If C<empty> is not C<NULL>, then C<*empty> is assigned a set
7272 that contains the parameter values in C<dom> for which C<set> (or C<bset>)
7274 In other words, the union of the parameter values
7275 for which the result is non-empty and of C<*empty>
7278 #include <isl/set.h>
7279 __isl_give isl_set *isl_basic_set_partial_lexmin(
7280 __isl_take isl_basic_set *bset,
7281 __isl_take isl_basic_set *dom,
7282 __isl_give isl_set **empty);
7283 __isl_give isl_set *isl_basic_set_partial_lexmax(
7284 __isl_take isl_basic_set *bset,
7285 __isl_take isl_basic_set *dom,
7286 __isl_give isl_set **empty);
7287 __isl_give isl_set *isl_set_partial_lexmin(
7288 __isl_take isl_set *set, __isl_take isl_set *dom,
7289 __isl_give isl_set **empty);
7290 __isl_give isl_set *isl_set_partial_lexmax(
7291 __isl_take isl_set *set, __isl_take isl_set *dom,
7292 __isl_give isl_set **empty);
7294 Given a (basic) set C<set> (or C<bset>), the following functions simply
7295 return a set containing the lexicographic minimum or maximum
7296 of the elements in C<set> (or C<bset>).
7297 In case of union sets, the optimum is computed per space.
7299 #include <isl/set.h>
7300 __isl_give isl_set *isl_basic_set_lexmin(
7301 __isl_take isl_basic_set *bset);
7302 __isl_give isl_set *isl_basic_set_lexmax(
7303 __isl_take isl_basic_set *bset);
7304 __isl_give isl_set *isl_set_lexmin(
7305 __isl_take isl_set *set);
7306 __isl_give isl_set *isl_set_lexmax(
7307 __isl_take isl_set *set);
7308 __isl_give isl_union_set *isl_union_set_lexmin(
7309 __isl_take isl_union_set *uset);
7310 __isl_give isl_union_set *isl_union_set_lexmax(
7311 __isl_take isl_union_set *uset);
7313 Given a (basic) relation C<map> (or C<bmap>) and a domain C<dom>,
7314 the following functions
7315 compute a relation that maps each element of C<dom>
7316 to the single lexicographic minimum or maximum
7317 of the elements that are associated to that same
7318 element in C<map> (or C<bmap>).
7319 If C<empty> is not C<NULL>, then C<*empty> is assigned a set
7320 that contains the elements in C<dom> that do not map
7321 to any elements in C<map> (or C<bmap>).
7322 In other words, the union of the domain of the result and of C<*empty>
7325 #include <isl/map.h>
7326 __isl_give isl_map *isl_basic_map_partial_lexmax(
7327 __isl_take isl_basic_map *bmap,
7328 __isl_take isl_basic_set *dom,
7329 __isl_give isl_set **empty);
7330 __isl_give isl_map *isl_basic_map_partial_lexmin(
7331 __isl_take isl_basic_map *bmap,
7332 __isl_take isl_basic_set *dom,
7333 __isl_give isl_set **empty);
7334 __isl_give isl_map *isl_map_partial_lexmax(
7335 __isl_take isl_map *map, __isl_take isl_set *dom,
7336 __isl_give isl_set **empty);
7337 __isl_give isl_map *isl_map_partial_lexmin(
7338 __isl_take isl_map *map, __isl_take isl_set *dom,
7339 __isl_give isl_set **empty);
7341 Given a (basic) map C<map> (or C<bmap>), the following functions simply
7342 return a map mapping each element in the domain of
7343 C<map> (or C<bmap>) to the lexicographic minimum or maximum
7344 of all elements associated to that element.
7345 In case of union relations, the optimum is computed per space.
7347 #include <isl/map.h>
7348 __isl_give isl_map *isl_basic_map_lexmin(
7349 __isl_take isl_basic_map *bmap);
7350 __isl_give isl_map *isl_basic_map_lexmax(
7351 __isl_take isl_basic_map *bmap);
7352 __isl_give isl_map *isl_map_lexmin(
7353 __isl_take isl_map *map);
7354 __isl_give isl_map *isl_map_lexmax(
7355 __isl_take isl_map *map);
7356 __isl_give isl_union_map *isl_union_map_lexmin(
7357 __isl_take isl_union_map *umap);
7358 __isl_give isl_union_map *isl_union_map_lexmax(
7359 __isl_take isl_union_map *umap);
7361 The following functions return their result in the form of
7362 a piecewise multi-affine expression,
7363 but are otherwise equivalent to the corresponding functions
7364 returning a basic set or relation.
7366 #include <isl/set.h>
7367 __isl_give isl_pw_multi_aff *
7368 isl_basic_set_partial_lexmin_pw_multi_aff(
7369 __isl_take isl_basic_set *bset,
7370 __isl_take isl_basic_set *dom,
7371 __isl_give isl_set **empty);
7372 __isl_give isl_pw_multi_aff *
7373 isl_basic_set_partial_lexmax_pw_multi_aff(
7374 __isl_take isl_basic_set *bset,
7375 __isl_take isl_basic_set *dom,
7376 __isl_give isl_set **empty);
7377 __isl_give isl_pw_multi_aff *isl_set_lexmin_pw_multi_aff(
7378 __isl_take isl_set *set);
7379 __isl_give isl_pw_multi_aff *isl_set_lexmax_pw_multi_aff(
7380 __isl_take isl_set *set);
7382 #include <isl/map.h>
7383 __isl_give isl_pw_multi_aff *
7384 isl_basic_map_lexmin_pw_multi_aff(
7385 __isl_take isl_basic_map *bmap);
7386 __isl_give isl_pw_multi_aff *
7387 isl_basic_map_partial_lexmin_pw_multi_aff(
7388 __isl_take isl_basic_map *bmap,
7389 __isl_take isl_basic_set *dom,
7390 __isl_give isl_set **empty);
7391 __isl_give isl_pw_multi_aff *
7392 isl_basic_map_partial_lexmax_pw_multi_aff(
7393 __isl_take isl_basic_map *bmap,
7394 __isl_take isl_basic_set *dom,
7395 __isl_give isl_set **empty);
7396 __isl_give isl_pw_multi_aff *isl_map_lexmin_pw_multi_aff(
7397 __isl_take isl_map *map);
7398 __isl_give isl_pw_multi_aff *isl_map_lexmax_pw_multi_aff(
7399 __isl_take isl_map *map);
7401 The following functions return the lexicographic minimum or maximum
7402 on the shared domain of the inputs and the single defined function
7403 on those parts of the domain where only a single function is defined.
7405 #include <isl/aff.h>
7406 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmin(
7407 __isl_take isl_pw_multi_aff *pma1,
7408 __isl_take isl_pw_multi_aff *pma2);
7409 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmax(
7410 __isl_take isl_pw_multi_aff *pma1,
7411 __isl_take isl_pw_multi_aff *pma2);
7413 If the input to a lexicographic optimization problem has
7414 multiple constraints with the same coefficients for the optimized
7415 variables, then, by default, this symmetry is exploited by
7416 replacing those constraints by a single constraint with
7417 an abstract bound, which is in turn bounded by the corresponding terms
7418 in the original constraints.
7419 Without this optimization, the solver would typically consider
7420 all possible orderings of those original bounds, resulting in a needless
7421 decomposition of the domain.
7422 However, the optimization can also result in slowdowns since
7423 an extra parameter is introduced that may get used in additional
7425 The following option determines whether symmetry detection is applied
7426 during lexicographic optimization.
7428 #include <isl/options.h>
7429 isl_stat isl_options_set_pip_symmetry(isl_ctx *ctx,
7431 int isl_options_get_pip_symmetry(isl_ctx *ctx);
7435 See also \autoref{s:offline}.
7439 =head2 Ternary Operations
7441 #include <isl/aff.h>
7442 __isl_give isl_pw_aff *isl_pw_aff_cond(
7443 __isl_take isl_pw_aff *cond,
7444 __isl_take isl_pw_aff *pwaff_true,
7445 __isl_take isl_pw_aff *pwaff_false);
7447 The function C<isl_pw_aff_cond> performs a conditional operator
7448 and returns an expression that is equal to C<pwaff_true>
7449 for elements where C<cond> is non-zero and equal to C<pwaff_false> for elements
7450 where C<cond> is zero.
7454 Lists are defined over several element types, including
7455 C<isl_val>, C<isl_id>, C<isl_aff>, C<isl_pw_aff>, C<isl_union_pw_aff>,
7456 C<isl_union_pw_multi_aff>, C<isl_constraint>,
7457 C<isl_basic_set>, C<isl_set>, C<isl_basic_map>, C<isl_map>, C<isl_union_set>,
7458 C<isl_union_map>, C<isl_ast_expr> and C<isl_ast_node>.
7459 Here we take lists of C<isl_set>s as an example.
7460 Lists can be created, copied, modified and freed using the following functions.
7462 #include <isl/set.h>
7463 __isl_give isl_set_list *isl_set_list_from_set(
7464 __isl_take isl_set *el);
7465 __isl_give isl_set_list *isl_set_list_alloc(
7466 isl_ctx *ctx, int n);
7467 __isl_give isl_set_list *isl_set_list_copy(
7468 __isl_keep isl_set_list *list);
7469 __isl_give isl_set_list *isl_set_list_insert(
7470 __isl_take isl_set_list *list, unsigned pos,
7471 __isl_take isl_set *el);
7472 __isl_give isl_set_list *isl_set_list_add(
7473 __isl_take isl_set_list *list,
7474 __isl_take isl_set *el);
7475 __isl_give isl_set_list *isl_set_list_drop(
7476 __isl_take isl_set_list *list,
7477 unsigned first, unsigned n);
7478 __isl_give isl_set_list *isl_set_list_set_set(
7479 __isl_take isl_set_list *list, int index,
7480 __isl_take isl_set *set);
7481 __isl_give isl_set_list *isl_set_list_concat(
7482 __isl_take isl_set_list *list1,
7483 __isl_take isl_set_list *list2);
7484 __isl_give isl_set_list *isl_set_list_map(
7485 __isl_take isl_set_list *list,
7486 __isl_give isl_set *(*fn)(__isl_take isl_set *el,
7489 __isl_give isl_set_list *isl_set_list_sort(
7490 __isl_take isl_set_list *list,
7491 int (*cmp)(__isl_keep isl_set *a,
7492 __isl_keep isl_set *b, void *user),
7494 __isl_null isl_set_list *isl_set_list_free(
7495 __isl_take isl_set_list *list);
7497 C<isl_set_list_alloc> creates an empty list with an initial capacity
7498 for C<n> elements. C<isl_set_list_insert> and C<isl_set_list_add>
7499 add elements to a list, increasing its capacity as needed.
7500 C<isl_set_list_from_set> creates a list with a single element.
7502 Lists can be inspected using the following functions.
7504 #include <isl/set.h>
7505 int isl_set_list_n_set(__isl_keep isl_set_list *list);
7506 __isl_give isl_set *isl_set_list_get_set(
7507 __isl_keep isl_set_list *list, int index);
7508 isl_stat isl_set_list_foreach(__isl_keep isl_set_list *list,
7509 isl_stat (*fn)(__isl_take isl_set *el, void *user),
7511 isl_stat isl_set_list_foreach_scc(
7512 __isl_keep isl_set_list *list,
7513 isl_bool (*follows)(__isl_keep isl_set *a,
7514 __isl_keep isl_set *b, void *user),
7516 isl_stat (*fn)(__isl_take isl_set *el, void *user),
7519 The function C<isl_set_list_foreach_scc> calls C<fn> on each of the
7520 strongly connected components of the graph with as vertices the elements
7521 of C<list> and a directed edge from vertex C<b> to vertex C<a>
7522 iff C<follows(a, b)> returns C<isl_bool_true>. The callbacks C<follows> and
7523 C<fn> should return C<isl_bool_error> or C<isl_stat_error> on error.
7525 Lists can be printed using
7527 #include <isl/set.h>
7528 __isl_give isl_printer *isl_printer_print_set_list(
7529 __isl_take isl_printer *p,
7530 __isl_keep isl_set_list *list);
7532 =head2 Associative arrays
7534 Associative arrays map isl objects of a specific type to isl objects
7535 of some (other) specific type. They are defined for several pairs
7536 of types, including (C<isl_map>, C<isl_basic_set>),
7537 (C<isl_id>, C<isl_ast_expr>),
7538 (C<isl_id>, C<isl_id>) and
7539 (C<isl_id>, C<isl_pw_aff>).
7540 Here, we take associative arrays that map C<isl_id>s to C<isl_ast_expr>s
7543 Associative arrays can be created, copied and freed using
7544 the following functions.
7546 #include <isl/id_to_ast_expr.h>
7547 __isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_alloc(
7548 isl_ctx *ctx, int min_size);
7549 __isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_copy(
7550 __isl_keep isl_id_to_ast_expr *id2expr);
7551 __isl_null isl_id_to_ast_expr *isl_id_to_ast_expr_free(
7552 __isl_take isl_id_to_ast_expr *id2expr);
7554 The C<min_size> argument to C<isl_id_to_ast_expr_alloc> can be used
7555 to specify the expected size of the associative array.
7556 The associative array will be grown automatically as needed.
7558 Associative arrays can be inspected using the following functions.
7560 #include <isl/id_to_ast_expr.h>
7561 __isl_give isl_maybe_isl_ast_expr
7562 isl_id_to_ast_expr_try_get(
7563 __isl_keep isl_id_to_ast_expr *id2expr,
7564 __isl_keep isl_id *key);
7565 isl_bool isl_id_to_ast_expr_has(
7566 __isl_keep isl_id_to_ast_expr *id2expr,
7567 __isl_keep isl_id *key);
7568 __isl_give isl_ast_expr *isl_id_to_ast_expr_get(
7569 __isl_keep isl_id_to_ast_expr *id2expr,
7570 __isl_take isl_id *key);
7571 isl_stat isl_id_to_ast_expr_foreach(
7572 __isl_keep isl_id_to_ast_expr *id2expr,
7573 isl_stat (*fn)(__isl_take isl_id *key,
7574 __isl_take isl_ast_expr *val, void *user),
7577 The function C<isl_id_to_ast_expr_try_get> returns a structure
7578 containing two elements, C<valid> and C<value>.
7579 If there is a value associated to the key, then C<valid>
7580 is set to C<isl_bool_true> and C<value> contains a copy of
7581 the associated value. Otherwise C<value> is C<NULL> and
7582 C<valid> may be C<isl_bool_error> or C<isl_bool_false> depending
7583 on whether some error has occurred or there simply is no associated value.
7584 The function C<isl_id_to_ast_expr_has> returns the C<valid> field
7585 in the structure and
7586 the function C<isl_id_to_ast_expr_get> returns the C<value> field.
7588 Associative arrays can be modified using the following functions.
7590 #include <isl/id_to_ast_expr.h>
7591 __isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_set(
7592 __isl_take isl_id_to_ast_expr *id2expr,
7593 __isl_take isl_id *key,
7594 __isl_take isl_ast_expr *val);
7595 __isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_drop(
7596 __isl_take isl_id_to_ast_expr *id2expr,
7597 __isl_take isl_id *key);
7599 Associative arrays can be printed using the following function.
7601 #include <isl/id_to_ast_expr.h>
7602 __isl_give isl_printer *isl_printer_print_id_to_ast_expr(
7603 __isl_take isl_printer *p,
7604 __isl_keep isl_id_to_ast_expr *id2expr);
7608 Vectors can be created, copied and freed using the following functions.
7610 #include <isl/vec.h>
7611 __isl_give isl_vec *isl_vec_alloc(isl_ctx *ctx,
7613 __isl_give isl_vec *isl_vec_copy(__isl_keep isl_vec *vec);
7614 __isl_null isl_vec *isl_vec_free(__isl_take isl_vec *vec);
7616 Note that the elements of a newly created vector may have arbitrary values.
7617 The elements can be changed and inspected using the following functions.
7619 int isl_vec_size(__isl_keep isl_vec *vec);
7620 __isl_give isl_val *isl_vec_get_element_val(
7621 __isl_keep isl_vec *vec, int pos);
7622 __isl_give isl_vec *isl_vec_set_element_si(
7623 __isl_take isl_vec *vec, int pos, int v);
7624 __isl_give isl_vec *isl_vec_set_element_val(
7625 __isl_take isl_vec *vec, int pos,
7626 __isl_take isl_val *v);
7627 __isl_give isl_vec *isl_vec_set_si(__isl_take isl_vec *vec,
7629 __isl_give isl_vec *isl_vec_set_val(
7630 __isl_take isl_vec *vec, __isl_take isl_val *v);
7631 int isl_vec_cmp_element(__isl_keep isl_vec *vec1,
7632 __isl_keep isl_vec *vec2, int pos);
7634 C<isl_vec_get_element> will return a negative value if anything went wrong.
7635 In that case, the value of C<*v> is undefined.
7637 The following function can be used to concatenate two vectors.
7639 __isl_give isl_vec *isl_vec_concat(__isl_take isl_vec *vec1,
7640 __isl_take isl_vec *vec2);
7644 Matrices can be created, copied and freed using the following functions.
7646 #include <isl/mat.h>
7647 __isl_give isl_mat *isl_mat_alloc(isl_ctx *ctx,
7648 unsigned n_row, unsigned n_col);
7649 __isl_give isl_mat *isl_mat_copy(__isl_keep isl_mat *mat);
7650 __isl_null isl_mat *isl_mat_free(__isl_take isl_mat *mat);
7652 Note that the elements of a newly created matrix may have arbitrary values.
7653 The elements can be changed and inspected using the following functions.
7655 int isl_mat_rows(__isl_keep isl_mat *mat);
7656 int isl_mat_cols(__isl_keep isl_mat *mat);
7657 __isl_give isl_val *isl_mat_get_element_val(
7658 __isl_keep isl_mat *mat, int row, int col);
7659 __isl_give isl_mat *isl_mat_set_element_si(__isl_take isl_mat *mat,
7660 int row, int col, int v);
7661 __isl_give isl_mat *isl_mat_set_element_val(
7662 __isl_take isl_mat *mat, int row, int col,
7663 __isl_take isl_val *v);
7665 C<isl_mat_get_element> will return a negative value if anything went wrong.
7666 In that case, the value of C<*v> is undefined.
7668 The following function can be used to compute the (right) inverse
7669 of a matrix, i.e., a matrix such that the product of the original
7670 and the inverse (in that order) is a multiple of the identity matrix.
7671 The input matrix is assumed to be of full row-rank.
7673 __isl_give isl_mat *isl_mat_right_inverse(__isl_take isl_mat *mat);
7675 The following function can be used to compute the (right) kernel
7676 (or null space) of a matrix, i.e., a matrix such that the product of
7677 the original and the kernel (in that order) is the zero matrix.
7679 __isl_give isl_mat *isl_mat_right_kernel(__isl_take isl_mat *mat);
7681 =head2 Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions
7683 The following functions determine
7684 an upper or lower bound on a quasipolynomial over its domain.
7686 __isl_give isl_pw_qpolynomial_fold *
7687 isl_pw_qpolynomial_bound(
7688 __isl_take isl_pw_qpolynomial *pwqp,
7689 enum isl_fold type, int *tight);
7691 __isl_give isl_union_pw_qpolynomial_fold *
7692 isl_union_pw_qpolynomial_bound(
7693 __isl_take isl_union_pw_qpolynomial *upwqp,
7694 enum isl_fold type, int *tight);
7696 The C<type> argument may be either C<isl_fold_min> or C<isl_fold_max>.
7697 If C<tight> is not C<NULL>, then C<*tight> is set to C<1>
7698 is the returned bound is known be tight, i.e., for each value
7699 of the parameters there is at least
7700 one element in the domain that reaches the bound.
7701 If the domain of C<pwqp> is not wrapping, then the bound is computed
7702 over all elements in that domain and the result has a purely parametric
7703 domain. If the domain of C<pwqp> is wrapping, then the bound is
7704 computed over the range of the wrapped relation. The domain of the
7705 wrapped relation becomes the domain of the result.
7707 =head2 Parametric Vertex Enumeration
7709 The parametric vertex enumeration described in this section
7710 is mainly intended to be used internally and by the C<barvinok>
7713 #include <isl/vertices.h>
7714 __isl_give isl_vertices *isl_basic_set_compute_vertices(
7715 __isl_keep isl_basic_set *bset);
7717 The function C<isl_basic_set_compute_vertices> performs the
7718 actual computation of the parametric vertices and the chamber
7719 decomposition and stores the result in an C<isl_vertices> object.
7720 This information can be queried by either iterating over all
7721 the vertices or iterating over all the chambers or cells
7722 and then iterating over all vertices that are active on the chamber.
7724 isl_stat isl_vertices_foreach_vertex(
7725 __isl_keep isl_vertices *vertices,
7726 isl_stat (*fn)(__isl_take isl_vertex *vertex,
7727 void *user), void *user);
7729 isl_stat isl_vertices_foreach_cell(
7730 __isl_keep isl_vertices *vertices,
7731 isl_stat (*fn)(__isl_take isl_cell *cell,
7732 void *user), void *user);
7733 isl_stat isl_cell_foreach_vertex(__isl_keep isl_cell *cell,
7734 isl_stat (*fn)(__isl_take isl_vertex *vertex,
7735 void *user), void *user);
7737 Other operations that can be performed on an C<isl_vertices> object are
7740 int isl_vertices_get_n_vertices(
7741 __isl_keep isl_vertices *vertices);
7742 __isl_null isl_vertices *isl_vertices_free(
7743 __isl_take isl_vertices *vertices);
7745 Vertices can be inspected and destroyed using the following functions.
7747 int isl_vertex_get_id(__isl_keep isl_vertex *vertex);
7748 __isl_give isl_basic_set *isl_vertex_get_domain(
7749 __isl_keep isl_vertex *vertex);
7750 __isl_give isl_multi_aff *isl_vertex_get_expr(
7751 __isl_keep isl_vertex *vertex);
7752 void isl_vertex_free(__isl_take isl_vertex *vertex);
7754 C<isl_vertex_get_expr> returns a multiple quasi-affine expression
7755 describing the vertex in terms of the parameters,
7756 while C<isl_vertex_get_domain> returns the activity domain
7759 Chambers can be inspected and destroyed using the following functions.
7761 __isl_give isl_basic_set *isl_cell_get_domain(
7762 __isl_keep isl_cell *cell);
7763 void isl_cell_free(__isl_take isl_cell *cell);
7765 =head1 Polyhedral Compilation Library
7767 This section collects functionality in C<isl> that has been specifically
7768 designed for use during polyhedral compilation.
7770 =head2 Schedule Trees
7772 A schedule tree is a structured representation of a schedule,
7773 assigning a relative order to a set of domain elements.
7774 The relative order expressed by the schedule tree is
7775 defined recursively. In particular, the order between
7776 two domain elements is determined by the node that is closest
7777 to the root that refers to both elements and that orders them apart.
7778 Each node in the tree is of one of several types.
7779 The root node is always of type C<isl_schedule_node_domain>
7780 (or C<isl_schedule_node_extension>)
7781 and it describes the (extra) domain elements to which the schedule applies.
7782 The other types of nodes are as follows.
7786 =item C<isl_schedule_node_band>
7788 A band of schedule dimensions. Each schedule dimension is represented
7789 by a union piecewise quasi-affine expression. If this expression
7790 assigns a different value to two domain elements, while all previous
7791 schedule dimensions in the same band assign them the same value,
7792 then the two domain elements are ordered according to these two
7794 Each expression is required to be total in the domain elements
7795 that reach the band node.
7797 =item C<isl_schedule_node_expansion>
7799 An expansion node maps each of the domain elements that reach the node
7800 to one or more domain elements. The image of this mapping forms
7801 the set of domain elements that reach the child of the expansion node.
7802 The function that maps each of the expanded domain elements
7803 to the original domain element from which it was expanded
7804 is called the contraction.
7806 =item C<isl_schedule_node_filter>
7808 A filter node does not impose any ordering, but rather intersects
7809 the set of domain elements that the current subtree refers to
7810 with a given union set. The subtree of the filter node only
7811 refers to domain elements in the intersection.
7812 A filter node is typically only used as a child of a sequence or
7815 =item C<isl_schedule_node_leaf>
7817 A leaf of the schedule tree. Leaf nodes do not impose any ordering.
7819 =item C<isl_schedule_node_mark>
7821 A mark node can be used to attach any kind of information to a subtree
7822 of the schedule tree.
7824 =item C<isl_schedule_node_sequence>
7826 A sequence node has one or more children, each of which is a filter node.
7827 The filters on these filter nodes form a partition of
7828 the domain elements that the current subtree refers to.
7829 If two domain elements appear in distinct filters then the sequence
7830 node orders them according to the child positions of the corresponding
7833 =item C<isl_schedule_node_set>
7835 A set node is similar to a sequence node, except that
7836 it expresses that domain elements appearing in distinct filters
7837 may have any order. The order of the children of a set node
7838 is therefore also immaterial.
7842 The following node types are only supported by the AST generator.
7846 =item C<isl_schedule_node_context>
7848 The context describes constraints on the parameters and
7849 the schedule dimensions of outer
7850 bands that the AST generator may assume to hold. It is also the only
7851 kind of node that may introduce additional parameters.
7852 The space of the context is that of the flat product of the outer
7853 band nodes. In particular, if there are no outer band nodes, then
7854 this space is the unnamed zero-dimensional space.
7855 Since a context node references the outer band nodes, any tree
7856 containing a context node is considered to be anchored.
7858 =item C<isl_schedule_node_extension>
7860 An extension node instructs the AST generator to add additional
7861 domain elements that need to be scheduled.
7862 The additional domain elements are described by the range of
7863 the extension map in terms of the outer schedule dimensions,
7864 i.e., the flat product of the outer band nodes.
7865 Note that domain elements are added whenever the AST generator
7866 reaches the extension node, meaning that there are still some
7867 active domain elements for which an AST needs to be generated.
7868 The conditions under which some domain elements are still active
7869 may however not be completely described by the outer AST nodes
7870 generated at that point.
7872 An extension node may also appear as the root of a schedule tree,
7873 when it is intended to be inserted into another tree
7874 using C<isl_schedule_node_graft_before> or C<isl_schedule_node_graft_after>.
7875 In this case, the domain of the extension node should
7876 correspond to the flat product of the outer band nodes
7877 in this other schedule tree at the point where the extension tree
7880 =item C<isl_schedule_node_guard>
7882 The guard describes constraints on the parameters and
7883 the schedule dimensions of outer
7884 bands that need to be enforced by the outer nodes
7885 in the generated AST.
7886 The space of the guard is that of the flat product of the outer
7887 band nodes. In particular, if there are no outer band nodes, then
7888 this space is the unnamed zero-dimensional space.
7889 Since a guard node references the outer band nodes, any tree
7890 containing a guard node is considered to be anchored.
7894 Except for the C<isl_schedule_node_context> nodes,
7895 none of the nodes may introduce any parameters that were not
7896 already present in the root domain node.
7898 A schedule tree is encapsulated in an C<isl_schedule> object.
7899 The simplest such objects, those with a tree consisting of single domain node,
7900 can be created using the following functions with either an empty
7901 domain or a given domain.
7903 #include <isl/schedule.h>
7904 __isl_give isl_schedule *isl_schedule_empty(
7905 __isl_take isl_space *space);
7906 __isl_give isl_schedule *isl_schedule_from_domain(
7907 __isl_take isl_union_set *domain);
7909 The function C<isl_schedule_constraints_compute_schedule> described
7910 in L</"Scheduling"> can also be used to construct schedules.
7912 C<isl_schedule> objects may be copied and freed using the following functions.
7914 #include <isl/schedule.h>
7915 __isl_give isl_schedule *isl_schedule_copy(
7916 __isl_keep isl_schedule *sched);
7917 __isl_null isl_schedule *isl_schedule_free(
7918 __isl_take isl_schedule *sched);
7920 The following functions checks whether two C<isl_schedule> objects
7921 are obviously the same.
7923 #include <isl/schedule.h>
7924 isl_bool isl_schedule_plain_is_equal(
7925 __isl_keep isl_schedule *schedule1,
7926 __isl_keep isl_schedule *schedule2);
7928 The domain of the schedule, i.e., the domain described by the root node,
7929 can be obtained using the following function.
7931 #include <isl/schedule.h>
7932 __isl_give isl_union_set *isl_schedule_get_domain(
7933 __isl_keep isl_schedule *schedule);
7935 An extra top-level band node (right underneath the domain node) can
7936 be introduced into the schedule using the following function.
7937 The schedule tree is assumed not to have any anchored nodes.
7939 #include <isl/schedule.h>
7940 __isl_give isl_schedule *
7941 isl_schedule_insert_partial_schedule(
7942 __isl_take isl_schedule *schedule,
7943 __isl_take isl_multi_union_pw_aff *partial);
7945 A top-level context node (right underneath the domain node) can
7946 be introduced into the schedule using the following function.
7948 #include <isl/schedule.h>
7949 __isl_give isl_schedule *isl_schedule_insert_context(
7950 __isl_take isl_schedule *schedule,
7951 __isl_take isl_set *context)
7953 A top-level guard node (right underneath the domain node) can
7954 be introduced into the schedule using the following function.
7956 #include <isl/schedule.h>
7957 __isl_give isl_schedule *isl_schedule_insert_guard(
7958 __isl_take isl_schedule *schedule,
7959 __isl_take isl_set *guard)
7961 A schedule that combines two schedules either in the given
7962 order or in an arbitrary order, i.e., with an C<isl_schedule_node_sequence>
7963 or an C<isl_schedule_node_set> node,
7964 can be created using the following functions.
7966 #include <isl/schedule.h>
7967 __isl_give isl_schedule *isl_schedule_sequence(
7968 __isl_take isl_schedule *schedule1,
7969 __isl_take isl_schedule *schedule2);
7970 __isl_give isl_schedule *isl_schedule_set(
7971 __isl_take isl_schedule *schedule1,
7972 __isl_take isl_schedule *schedule2);
7974 The domains of the two input schedules need to be disjoint.
7976 The following function can be used to restrict the domain
7977 of a schedule with a domain node as root to be a subset of the given union set.
7978 This operation may remove nodes in the tree that have become
7981 #include <isl/schedule.h>
7982 __isl_give isl_schedule *isl_schedule_intersect_domain(
7983 __isl_take isl_schedule *schedule,
7984 __isl_take isl_union_set *domain);
7986 The following function can be used to simplify the domain
7987 of a schedule with a domain node as root with respect to the given
7990 #include <isl/schedule.h>
7991 __isl_give isl_schedule *isl_schedule_gist_domain_params(
7992 __isl_take isl_schedule *schedule,
7993 __isl_take isl_set *context);
7995 The following function resets the user pointers on all parameter
7996 and tuple identifiers referenced by the nodes of the given schedule.
7998 #include <isl/schedule.h>
7999 __isl_give isl_schedule *isl_schedule_reset_user(
8000 __isl_take isl_schedule *schedule);
8002 The following function aligns the parameters of all nodes
8003 in the given schedule to the given space.
8005 #include <isl/schedule.h>
8006 __isl_give isl_schedule *isl_schedule_align_params(
8007 __isl_take isl_schedule *schedule,
8008 __isl_take isl_space *space);
8010 The following function allows the user to plug in a given function
8011 in the iteration domains. The input schedule is not allowed to contain
8012 any expansion nodes.
8014 #include <isl/schedule.h>
8015 __isl_give isl_schedule *
8016 isl_schedule_pullback_union_pw_multi_aff(
8017 __isl_take isl_schedule *schedule,
8018 __isl_take isl_union_pw_multi_aff *upma);
8020 The following function can be used to plug in the schedule C<expansion>
8021 in the leaves of C<schedule>, where C<contraction> describes how
8022 the domain elements of C<expansion> map to the domain elements
8023 at the original leaves of C<schedule>.
8024 The resulting schedule will contain expansion nodes, unless
8025 C<contraction> is an identity function.
8027 #include <isl/schedule.h>
8028 __isl_give isl_schedule *isl_schedule_expand(
8029 __isl_take isl_schedule *schedule,
8030 __isl_take isl_union_pw_multi_aff *contraction,
8031 __isl_take isl_schedule *expansion);
8033 An C<isl_union_map> representation of the schedule can be obtained
8034 from an C<isl_schedule> using the following function.
8036 #include <isl/schedule.h>
8037 __isl_give isl_union_map *isl_schedule_get_map(
8038 __isl_keep isl_schedule *sched);
8040 The resulting relation encodes the same relative ordering as
8041 the schedule by mapping the domain elements to a common schedule space.
8042 If the schedule_separate_components option is set, then the order
8043 of the children of a set node is explicitly encoded in the result.
8044 If the tree contains any expansion nodes, then the relation
8045 is formulated in terms of the expanded domain elements.
8047 Schedules can be read from input using the following functions.
8049 #include <isl/schedule.h>
8050 __isl_give isl_schedule *isl_schedule_read_from_file(
8051 isl_ctx *ctx, FILE *input);
8052 __isl_give isl_schedule *isl_schedule_read_from_str(
8053 isl_ctx *ctx, const char *str);
8055 A representation of the schedule can be printed using
8057 #include <isl/schedule.h>
8058 __isl_give isl_printer *isl_printer_print_schedule(
8059 __isl_take isl_printer *p,
8060 __isl_keep isl_schedule *schedule);
8061 __isl_give char *isl_schedule_to_str(
8062 __isl_keep isl_schedule *schedule);
8064 C<isl_schedule_to_str> prints the schedule in flow format.
8066 The schedule tree can be traversed through the use of
8067 C<isl_schedule_node> objects that point to a particular
8068 position in the schedule tree. Whenever a C<isl_schedule_node>
8069 is use to modify a node in the schedule tree, the original schedule
8070 tree is left untouched and the modifications are performed to a copy
8071 of the tree. The returned C<isl_schedule_node> then points to
8072 this modified copy of the tree.
8074 The root of the schedule tree can be obtained using the following function.
8076 #include <isl/schedule.h>
8077 __isl_give isl_schedule_node *isl_schedule_get_root(
8078 __isl_keep isl_schedule *schedule);
8080 A pointer to a newly created schedule tree with a single domain
8081 node can be created using the following functions.
8083 #include <isl/schedule_node.h>
8084 __isl_give isl_schedule_node *
8085 isl_schedule_node_from_domain(
8086 __isl_take isl_union_set *domain);
8087 __isl_give isl_schedule_node *
8088 isl_schedule_node_from_extension(
8089 __isl_take isl_union_map *extension);
8091 C<isl_schedule_node_from_extension> creates a tree with an extension
8094 Schedule nodes can be copied and freed using the following functions.
8096 #include <isl/schedule_node.h>
8097 __isl_give isl_schedule_node *isl_schedule_node_copy(
8098 __isl_keep isl_schedule_node *node);
8099 __isl_null isl_schedule_node *isl_schedule_node_free(
8100 __isl_take isl_schedule_node *node);
8102 The following functions can be used to check if two schedule
8103 nodes point to the same position in the same schedule.
8105 #include <isl/schedule_node.h>
8106 isl_bool isl_schedule_node_is_equal(
8107 __isl_keep isl_schedule_node *node1,
8108 __isl_keep isl_schedule_node *node2);
8110 The following properties can be obtained from a schedule node.
8112 #include <isl/schedule_node.h>
8113 enum isl_schedule_node_type isl_schedule_node_get_type(
8114 __isl_keep isl_schedule_node *node);
8115 enum isl_schedule_node_type
8116 isl_schedule_node_get_parent_type(
8117 __isl_keep isl_schedule_node *node);
8118 __isl_give isl_schedule *isl_schedule_node_get_schedule(
8119 __isl_keep isl_schedule_node *node);
8121 The function C<isl_schedule_node_get_type> returns the type of
8122 the node, while C<isl_schedule_node_get_parent_type> returns
8123 type of the parent of the node, which is required to exist.
8124 The function C<isl_schedule_node_get_schedule> returns a copy
8125 to the schedule to which the node belongs.
8127 The following functions can be used to move the schedule node
8128 to a different position in the tree or to check if such a position
8131 #include <isl/schedule_node.h>
8132 isl_bool isl_schedule_node_has_parent(
8133 __isl_keep isl_schedule_node *node);
8134 __isl_give isl_schedule_node *isl_schedule_node_parent(
8135 __isl_take isl_schedule_node *node);
8136 __isl_give isl_schedule_node *isl_schedule_node_root(
8137 __isl_take isl_schedule_node *node);
8138 __isl_give isl_schedule_node *isl_schedule_node_ancestor(
8139 __isl_take isl_schedule_node *node,
8141 int isl_schedule_node_n_children(
8142 __isl_keep isl_schedule_node *node);
8143 __isl_give isl_schedule_node *isl_schedule_node_child(
8144 __isl_take isl_schedule_node *node, int pos);
8145 isl_bool isl_schedule_node_has_children(
8146 __isl_keep isl_schedule_node *node);
8147 __isl_give isl_schedule_node *isl_schedule_node_first_child(
8148 __isl_take isl_schedule_node *node);
8149 isl_bool isl_schedule_node_has_previous_sibling(
8150 __isl_keep isl_schedule_node *node);
8151 __isl_give isl_schedule_node *
8152 isl_schedule_node_previous_sibling(
8153 __isl_take isl_schedule_node *node);
8154 isl_bool isl_schedule_node_has_next_sibling(
8155 __isl_keep isl_schedule_node *node);
8156 __isl_give isl_schedule_node *
8157 isl_schedule_node_next_sibling(
8158 __isl_take isl_schedule_node *node);
8160 For C<isl_schedule_node_ancestor>, the ancestor of generation 0
8161 is the node itself, the ancestor of generation 1 is its parent and so on.
8163 It is also possible to query the number of ancestors of a node,
8164 the position of the current node
8165 within the children of its parent, the position of the subtree
8166 containing a node within the children of an ancestor
8167 or to obtain a copy of a given
8168 child without destroying the current node.
8169 Given two nodes that point to the same schedule, their closest
8170 shared ancestor can be obtained using
8171 C<isl_schedule_node_get_shared_ancestor>.
8173 #include <isl/schedule_node.h>
8174 int isl_schedule_node_get_tree_depth(
8175 __isl_keep isl_schedule_node *node);
8176 int isl_schedule_node_get_child_position(
8177 __isl_keep isl_schedule_node *node);
8178 int isl_schedule_node_get_ancestor_child_position(
8179 __isl_keep isl_schedule_node *node,
8180 __isl_keep isl_schedule_node *ancestor);
8181 __isl_give isl_schedule_node *isl_schedule_node_get_child(
8182 __isl_keep isl_schedule_node *node, int pos);
8183 __isl_give isl_schedule_node *
8184 isl_schedule_node_get_shared_ancestor(
8185 __isl_keep isl_schedule_node *node1,
8186 __isl_keep isl_schedule_node *node2);
8188 All nodes in a schedule tree or
8189 all descendants of a specific node (including the node) can be visited
8190 in depth-first pre-order using the following functions.
8192 #include <isl/schedule.h>
8193 isl_stat isl_schedule_foreach_schedule_node_top_down(
8194 __isl_keep isl_schedule *sched,
8195 isl_bool (*fn)(__isl_keep isl_schedule_node *node,
8196 void *user), void *user);
8198 #include <isl/schedule_node.h>
8199 isl_stat isl_schedule_node_foreach_descendant_top_down(
8200 __isl_keep isl_schedule_node *node,
8201 isl_bool (*fn)(__isl_keep isl_schedule_node *node,
8202 void *user), void *user);
8204 The callback function is slightly different from the usual
8205 callbacks in that it not only indicates success (non-negative result)
8206 or failure (negative result), but also indicates whether the children
8207 of the given node should be visited. In particular, if the callback
8208 returns a positive value, then the children are visited, but if
8209 the callback returns zero, then the children are not visited.
8211 The ancestors of a node in a schedule tree can be visited from
8212 the root down to and including the parent of the node using
8213 the following function.
8215 #include <isl/schedule_node.h>
8216 isl_stat isl_schedule_node_foreach_ancestor_top_down(
8217 __isl_keep isl_schedule_node *node,
8218 isl_stat (*fn)(__isl_keep isl_schedule_node *node,
8219 void *user), void *user);
8221 The following functions allows for a depth-first post-order
8222 traversal of the nodes in a schedule tree or
8223 of the descendants of a specific node (including the node
8224 itself), where the user callback is allowed to modify the
8227 #include <isl/schedule.h>
8228 __isl_give isl_schedule *
8229 isl_schedule_map_schedule_node_bottom_up(
8230 __isl_take isl_schedule *schedule,
8231 __isl_give isl_schedule_node *(*fn)(
8232 __isl_take isl_schedule_node *node,
8233 void *user), void *user);
8235 #include <isl/schedule_node.h>
8236 __isl_give isl_schedule_node *
8237 isl_schedule_node_map_descendant_bottom_up(
8238 __isl_take isl_schedule_node *node,
8239 __isl_give isl_schedule_node *(*fn)(
8240 __isl_take isl_schedule_node *node,
8241 void *user), void *user);
8243 The traversal continues from the node returned by the callback function.
8244 It is the responsibility of the user to ensure that this does not
8245 lead to an infinite loop. It is safest to always return a pointer
8246 to the same position (same ancestors and child positions) as the input node.
8248 The following function removes a node (along with its descendants)
8249 from a schedule tree and returns a pointer to the leaf at the
8250 same position in the updated tree.
8251 It is not allowed to remove the root of a schedule tree or
8252 a child of a set or sequence node.
8254 #include <isl/schedule_node.h>
8255 __isl_give isl_schedule_node *isl_schedule_node_cut(
8256 __isl_take isl_schedule_node *node);
8258 The following function removes a single node
8259 from a schedule tree and returns a pointer to the child
8260 of the node, now located at the position of the original node
8261 or to a leaf node at that position if there was no child.
8262 It is not allowed to remove the root of a schedule tree,
8263 a set or sequence node, a child of a set or sequence node or
8264 a band node with an anchored subtree.
8266 #include <isl/schedule_node.h>
8267 __isl_give isl_schedule_node *isl_schedule_node_delete(
8268 __isl_take isl_schedule_node *node);
8270 Most nodes in a schedule tree only contain local information.
8271 In some cases, however, a node may also refer to the schedule dimensions
8272 of its outer band nodes.
8273 This means that the position of the node within the tree should
8274 not be changed, or at least that no changes are performed to the
8275 outer band nodes. The following function can be used to test
8276 whether the subtree rooted at a given node contains any such nodes.
8278 #include <isl/schedule_node.h>
8279 isl_bool isl_schedule_node_is_subtree_anchored(
8280 __isl_keep isl_schedule_node *node);
8282 The following function resets the user pointers on all parameter
8283 and tuple identifiers referenced by the given schedule node.
8285 #include <isl/schedule_node.h>
8286 __isl_give isl_schedule_node *isl_schedule_node_reset_user(
8287 __isl_take isl_schedule_node *node);
8289 The following function aligns the parameters of the given schedule
8290 node to the given space.
8292 #include <isl/schedule_node.h>
8293 __isl_give isl_schedule_node *
8294 isl_schedule_node_align_params(
8295 __isl_take isl_schedule_node *node,
8296 __isl_take isl_space *space);
8298 Several node types have their own functions for querying
8299 (and in some cases setting) some node type specific properties.
8301 #include <isl/schedule_node.h>
8302 __isl_give isl_space *isl_schedule_node_band_get_space(
8303 __isl_keep isl_schedule_node *node);
8304 __isl_give isl_multi_union_pw_aff *
8305 isl_schedule_node_band_get_partial_schedule(
8306 __isl_keep isl_schedule_node *node);
8307 __isl_give isl_union_map *
8308 isl_schedule_node_band_get_partial_schedule_union_map(
8309 __isl_keep isl_schedule_node *node);
8310 unsigned isl_schedule_node_band_n_member(
8311 __isl_keep isl_schedule_node *node);
8312 isl_bool isl_schedule_node_band_member_get_coincident(
8313 __isl_keep isl_schedule_node *node, int pos);
8314 __isl_give isl_schedule_node *
8315 isl_schedule_node_band_member_set_coincident(
8316 __isl_take isl_schedule_node *node, int pos,
8318 isl_bool isl_schedule_node_band_get_permutable(
8319 __isl_keep isl_schedule_node *node);
8320 __isl_give isl_schedule_node *
8321 isl_schedule_node_band_set_permutable(
8322 __isl_take isl_schedule_node *node, int permutable);
8323 enum isl_ast_loop_type
8324 isl_schedule_node_band_member_get_ast_loop_type(
8325 __isl_keep isl_schedule_node *node, int pos);
8326 __isl_give isl_schedule_node *
8327 isl_schedule_node_band_member_set_ast_loop_type(
8328 __isl_take isl_schedule_node *node, int pos,
8329 enum isl_ast_loop_type type);
8330 __isl_give isl_union_set *
8331 enum isl_ast_loop_type
8332 isl_schedule_node_band_member_get_isolate_ast_loop_type(
8333 __isl_keep isl_schedule_node *node, int pos);
8334 __isl_give isl_schedule_node *
8335 isl_schedule_node_band_member_set_isolate_ast_loop_type(
8336 __isl_take isl_schedule_node *node, int pos,
8337 enum isl_ast_loop_type type);
8338 isl_schedule_node_band_get_ast_build_options(
8339 __isl_keep isl_schedule_node *node);
8340 __isl_give isl_schedule_node *
8341 isl_schedule_node_band_set_ast_build_options(
8342 __isl_take isl_schedule_node *node,
8343 __isl_take isl_union_set *options);
8344 __isl_give isl_set *
8345 isl_schedule_node_band_get_ast_isolate_option(
8346 __isl_keep isl_schedule_node *node);
8348 The function C<isl_schedule_node_band_get_space> returns the space
8349 of the partial schedule of the band.
8350 The function C<isl_schedule_node_band_get_partial_schedule_union_map>
8351 returns a representation of the partial schedule of the band node
8352 in the form of an C<isl_union_map>.
8353 The coincident and permutable properties are set by
8354 C<isl_schedule_constraints_compute_schedule> on the schedule tree
8356 A scheduling dimension is considered to be ``coincident''
8357 if it satisfies the coincidence constraints within its band.
8358 That is, if the dependence distances of the coincidence
8359 constraints are all zero in that direction (for fixed
8360 iterations of outer bands).
8361 A band is marked permutable if it was produced using the Pluto-like scheduler.
8362 Note that the scheduler may have to resort to a Feautrier style scheduling
8363 step even if the default scheduler is used.
8364 An C<isl_ast_loop_type> is one of C<isl_ast_loop_default>,
8365 C<isl_ast_loop_atomic>, C<isl_ast_loop_unroll> or C<isl_ast_loop_separate>.
8366 For the meaning of these loop AST generation types and the difference
8367 between the regular loop AST generation type and the isolate
8368 loop AST generation type, see L</"AST Generation Options (Schedule Tree)">.
8369 The functions C<isl_schedule_node_band_member_get_ast_loop_type>
8370 and C<isl_schedule_node_band_member_get_isolate_ast_loop_type>
8371 may return C<isl_ast_loop_error> if an error occurs.
8372 The AST build options govern how an AST is generated for
8373 the individual schedule dimensions during AST generation.
8374 See L</"AST Generation Options (Schedule Tree)">.
8375 The isolate option for the given node can be extracted from these
8376 AST build options using the function
8377 C<isl_schedule_node_band_get_ast_isolate_option>.
8379 #include <isl/schedule_node.h>
8380 __isl_give isl_set *
8381 isl_schedule_node_context_get_context(
8382 __isl_keep isl_schedule_node *node);
8384 #include <isl/schedule_node.h>
8385 __isl_give isl_union_set *
8386 isl_schedule_node_domain_get_domain(
8387 __isl_keep isl_schedule_node *node);
8389 #include <isl/schedule_node.h>
8390 __isl_give isl_union_map *
8391 isl_schedule_node_expansion_get_expansion(
8392 __isl_keep isl_schedule_node *node);
8393 __isl_give isl_union_pw_multi_aff *
8394 isl_schedule_node_expansion_get_contraction(
8395 __isl_keep isl_schedule_node *node);
8397 #include <isl/schedule_node.h>
8398 __isl_give isl_union_map *
8399 isl_schedule_node_extension_get_extension(
8400 __isl_keep isl_schedule_node *node);
8402 #include <isl/schedule_node.h>
8403 __isl_give isl_union_set *
8404 isl_schedule_node_filter_get_filter(
8405 __isl_keep isl_schedule_node *node);
8407 #include <isl/schedule_node.h>
8408 __isl_give isl_set *isl_schedule_node_guard_get_guard(
8409 __isl_keep isl_schedule_node *node);
8411 #include <isl/schedule_node.h>
8412 __isl_give isl_id *isl_schedule_node_mark_get_id(
8413 __isl_keep isl_schedule_node *node);
8415 The following functions can be used to obtain an C<isl_multi_union_pw_aff>,
8416 an C<isl_union_pw_multi_aff> or C<isl_union_map> representation of
8417 partial schedules related to the node.
8419 #include <isl/schedule_node.h>
8420 __isl_give isl_multi_union_pw_aff *
8421 isl_schedule_node_get_prefix_schedule_multi_union_pw_aff(
8422 __isl_keep isl_schedule_node *node);
8423 __isl_give isl_union_pw_multi_aff *
8424 isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(
8425 __isl_keep isl_schedule_node *node);
8426 __isl_give isl_union_map *
8427 isl_schedule_node_get_prefix_schedule_union_map(
8428 __isl_keep isl_schedule_node *node);
8429 __isl_give isl_union_map *
8430 isl_schedule_node_get_prefix_schedule_relation(
8431 __isl_keep isl_schedule_node *node);
8432 __isl_give isl_union_map *
8433 isl_schedule_node_get_subtree_schedule_union_map(
8434 __isl_keep isl_schedule_node *node);
8436 In particular, the functions
8437 C<isl_schedule_node_get_prefix_schedule_multi_union_pw_aff>,
8438 C<isl_schedule_node_get_prefix_schedule_union_pw_multi_aff>
8439 and C<isl_schedule_node_get_prefix_schedule_union_map>
8440 return a relative ordering on the domain elements that reach the given
8441 node determined by its ancestors.
8442 The function C<isl_schedule_node_get_prefix_schedule_relation>
8443 additionally includes the domain constraints in the result.
8444 The function C<isl_schedule_node_get_subtree_schedule_union_map>
8445 returns a representation of the partial schedule defined by the
8446 subtree rooted at the given node.
8447 If the tree contains any expansion nodes, then the subtree schedule
8448 is formulated in terms of the expanded domain elements.
8449 The tree passed to functions returning a prefix schedule
8450 may only contain extension nodes if these would not affect
8451 the result of these functions. That is, if one of the ancestors
8452 is an extension node, then all of the domain elements that were
8453 added by the extension node need to have been filtered out
8454 by filter nodes between the extension node and the input node.
8455 The tree passed to C<isl_schedule_node_get_subtree_schedule_union_map>
8456 may not contain in extension nodes in the selected subtree.
8458 The expansion/contraction defined by an entire subtree, combining
8459 the expansions/contractions
8460 on the expansion nodes in the subtree, can be obtained using
8461 the following functions.
8463 #include <isl/schedule_node.h>
8464 __isl_give isl_union_map *
8465 isl_schedule_node_get_subtree_expansion(
8466 __isl_keep isl_schedule_node *node);
8467 __isl_give isl_union_pw_multi_aff *
8468 isl_schedule_node_get_subtree_contraction(
8469 __isl_keep isl_schedule_node *node);
8471 The total number of outer band members of given node, i.e.,
8472 the shared output dimension of the maps in the result
8473 of C<isl_schedule_node_get_prefix_schedule_union_map> can be obtained
8474 using the following function.
8476 #include <isl/schedule_node.h>
8477 int isl_schedule_node_get_schedule_depth(
8478 __isl_keep isl_schedule_node *node);
8480 The following functions return the elements that reach the given node
8481 or the union of universes in the spaces that contain these elements.
8483 #include <isl/schedule_node.h>
8484 __isl_give isl_union_set *
8485 isl_schedule_node_get_domain(
8486 __isl_keep isl_schedule_node *node);
8487 __isl_give isl_union_set *
8488 isl_schedule_node_get_universe_domain(
8489 __isl_keep isl_schedule_node *node);
8491 The input tree of C<isl_schedule_node_get_domain>
8492 may only contain extension nodes if these would not affect
8493 the result of this function. That is, if one of the ancestors
8494 is an extension node, then all of the domain elements that were
8495 added by the extension node need to have been filtered out
8496 by filter nodes between the extension node and the input node.
8498 The following functions can be used to introduce additional nodes
8499 in the schedule tree. The new node is introduced at the point
8500 in the tree where the C<isl_schedule_node> points to and
8501 the results points to the new node.
8503 #include <isl/schedule_node.h>
8504 __isl_give isl_schedule_node *
8505 isl_schedule_node_insert_partial_schedule(
8506 __isl_take isl_schedule_node *node,
8507 __isl_take isl_multi_union_pw_aff *schedule);
8509 This function inserts a new band node with (the greatest integer
8510 part of) the given partial schedule.
8511 The subtree rooted at the given node is assumed not to have
8514 #include <isl/schedule_node.h>
8515 __isl_give isl_schedule_node *
8516 isl_schedule_node_insert_context(
8517 __isl_take isl_schedule_node *node,
8518 __isl_take isl_set *context);
8520 This function inserts a new context node with the given context constraints.
8522 #include <isl/schedule_node.h>
8523 __isl_give isl_schedule_node *
8524 isl_schedule_node_insert_filter(
8525 __isl_take isl_schedule_node *node,
8526 __isl_take isl_union_set *filter);
8528 This function inserts a new filter node with the given filter.
8529 If the original node already pointed to a filter node, then the
8530 two filter nodes are merged into one.
8532 #include <isl/schedule_node.h>
8533 __isl_give isl_schedule_node *
8534 isl_schedule_node_insert_guard(
8535 __isl_take isl_schedule_node *node,
8536 __isl_take isl_set *guard);
8538 This function inserts a new guard node with the given guard constraints.
8540 #include <isl/schedule_node.h>
8541 __isl_give isl_schedule_node *
8542 isl_schedule_node_insert_mark(
8543 __isl_take isl_schedule_node *node,
8544 __isl_take isl_id *mark);
8546 This function inserts a new mark node with the give mark identifier.
8548 #include <isl/schedule_node.h>
8549 __isl_give isl_schedule_node *
8550 isl_schedule_node_insert_sequence(
8551 __isl_take isl_schedule_node *node,
8552 __isl_take isl_union_set_list *filters);
8553 __isl_give isl_schedule_node *
8554 isl_schedule_node_insert_set(
8555 __isl_take isl_schedule_node *node,
8556 __isl_take isl_union_set_list *filters);
8558 These functions insert a new sequence or set node with the given
8559 filters as children.
8561 #include <isl/schedule_node.h>
8562 __isl_give isl_schedule_node *isl_schedule_node_group(
8563 __isl_take isl_schedule_node *node,
8564 __isl_take isl_id *group_id);
8566 This function introduces an expansion node in between the current
8567 node and its parent that expands instances of a space with tuple
8568 identifier C<group_id> to the original domain elements that reach
8569 the node. The group instances are identified by the prefix schedule
8570 of those domain elements. The ancestors of the node are adjusted
8571 to refer to the group instances instead of the original domain
8572 elements. The return value points to the same node in the updated
8573 schedule tree as the input node, i.e., to the child of the newly
8574 introduced expansion node. Grouping instances of different statements
8575 ensures that they will be treated as a single statement by the
8576 AST generator up to the point of the expansion node.
8578 The following function can be used to flatten a nested
8581 #include <isl/schedule_node.h>
8582 __isl_give isl_schedule_node *
8583 isl_schedule_node_sequence_splice_child(
8584 __isl_take isl_schedule_node *node, int pos);
8586 That is, given a sequence node C<node> that has another sequence node
8587 in its child at position C<pos> (in particular, the child of that filter
8588 node is a sequence node), attach the children of that other sequence
8589 node as children of C<node>, replacing the original child at position
8592 The partial schedule of a band node can be scaled (down) or reduced using
8593 the following functions.
8595 #include <isl/schedule_node.h>
8596 __isl_give isl_schedule_node *
8597 isl_schedule_node_band_scale(
8598 __isl_take isl_schedule_node *node,
8599 __isl_take isl_multi_val *mv);
8600 __isl_give isl_schedule_node *
8601 isl_schedule_node_band_scale_down(
8602 __isl_take isl_schedule_node *node,
8603 __isl_take isl_multi_val *mv);
8604 __isl_give isl_schedule_node *
8605 isl_schedule_node_band_mod(
8606 __isl_take isl_schedule_node *node,
8607 __isl_take isl_multi_val *mv);
8609 The spaces of the two arguments need to match.
8610 After scaling, the partial schedule is replaced by its greatest
8611 integer part to ensure that the schedule remains integral.
8613 The partial schedule of a band node can be shifted by an
8614 C<isl_multi_union_pw_aff> with a domain that is a superset
8615 of the domain of the partial schedule using
8616 the following function.
8618 #include <isl/schedule_node.h>
8619 __isl_give isl_schedule_node *
8620 isl_schedule_node_band_shift(
8621 __isl_take isl_schedule_node *node,
8622 __isl_take isl_multi_union_pw_aff *shift);
8624 A band node can be tiled using the following function.
8626 #include <isl/schedule_node.h>
8627 __isl_give isl_schedule_node *isl_schedule_node_band_tile(
8628 __isl_take isl_schedule_node *node,
8629 __isl_take isl_multi_val *sizes);
8631 isl_stat isl_options_set_tile_scale_tile_loops(isl_ctx *ctx,
8633 int isl_options_get_tile_scale_tile_loops(isl_ctx *ctx);
8634 isl_stat isl_options_set_tile_shift_point_loops(isl_ctx *ctx,
8636 int isl_options_get_tile_shift_point_loops(isl_ctx *ctx);
8638 The C<isl_schedule_node_band_tile> function tiles
8639 the band using the given tile sizes inside its schedule.
8640 A new child band node is created to represent the point loops and it is
8641 inserted between the modified band and its children.
8642 The subtree rooted at the given node is assumed not to have
8644 The C<tile_scale_tile_loops> option specifies whether the tile
8645 loops iterators should be scaled by the tile sizes.
8646 If the C<tile_shift_point_loops> option is set, then the point loops
8647 are shifted to start at zero.
8649 A band node can be split into two nested band nodes
8650 using the following function.
8652 #include <isl/schedule_node.h>
8653 __isl_give isl_schedule_node *isl_schedule_node_band_split(
8654 __isl_take isl_schedule_node *node, int pos);
8656 The resulting outer band node contains the first C<pos> dimensions of
8657 the schedule of C<node> while the inner band contains the remaining dimensions.
8658 The schedules of the two band nodes live in anonymous spaces.
8659 The loop AST generation type options and the isolate option
8660 are split over the the two band nodes.
8662 A band node can be moved down to the leaves of the subtree rooted
8663 at the band node using the following function.
8665 #include <isl/schedule_node.h>
8666 __isl_give isl_schedule_node *isl_schedule_node_band_sink(
8667 __isl_take isl_schedule_node *node);
8669 The subtree rooted at the given node is assumed not to have
8671 The result points to the node in the resulting tree that is in the same
8672 position as the node pointed to by C<node> in the original tree.
8674 #include <isl/schedule_node.h>
8675 __isl_give isl_schedule_node *
8676 isl_schedule_node_order_before(
8677 __isl_take isl_schedule_node *node,
8678 __isl_take isl_union_set *filter);
8679 __isl_give isl_schedule_node *
8680 isl_schedule_node_order_after(
8681 __isl_take isl_schedule_node *node,
8682 __isl_take isl_union_set *filter);
8684 These functions split the domain elements that reach C<node>
8685 into those that satisfy C<filter> and those that do not and
8686 arranges for the elements that do satisfy the filter to be
8687 executed before (in case of C<isl_schedule_node_order_before>)
8688 or after (in case of C<isl_schedule_node_order_after>)
8689 those that do not. The order is imposed by
8690 a sequence node, possibly reusing the grandparent of C<node>
8691 on two copies of the subtree attached to the original C<node>.
8692 Both copies are simplified with respect to their filter.
8694 Return a pointer to the copy of the subtree that does not
8695 satisfy C<filter>. If there is no such copy (because all
8696 reaching domain elements satisfy the filter), then return
8697 the original pointer.
8699 #include <isl/schedule_node.h>
8700 __isl_give isl_schedule_node *
8701 isl_schedule_node_graft_before(
8702 __isl_take isl_schedule_node *node,
8703 __isl_take isl_schedule_node *graft);
8704 __isl_give isl_schedule_node *
8705 isl_schedule_node_graft_after(
8706 __isl_take isl_schedule_node *node,
8707 __isl_take isl_schedule_node *graft);
8709 This function inserts the C<graft> tree into the tree containing C<node>
8710 such that it is executed before (in case of C<isl_schedule_node_graft_before>)
8711 or after (in case of C<isl_schedule_node_graft_after>) C<node>.
8712 The root node of C<graft>
8713 should be an extension node where the domain of the extension
8714 is the flat product of all outer band nodes of C<node>.
8715 The root node may also be a domain node.
8716 The elements of the domain or the range of the extension may not
8717 intersect with the domain elements that reach "node".
8718 The schedule tree of C<graft> may not be anchored.
8720 The schedule tree of C<node> is modified to include an extension node
8721 corresponding to the root node of C<graft> as a child of the original
8722 parent of C<node>. The original node that C<node> points to and the
8723 child of the root node of C<graft> are attached to this extension node
8724 through a sequence, with appropriate filters and with the child
8725 of C<graft> appearing before or after the original C<node>.
8727 If C<node> already appears inside a sequence that is the child of
8728 an extension node and if the spaces of the new domain elements
8729 do not overlap with those of the original domain elements,
8730 then that extension node is extended with the new extension
8731 rather than introducing a new segment of extension and sequence nodes.
8733 Return a pointer to the same node in the modified tree that
8734 C<node> pointed to in the original tree.
8736 A representation of the schedule node can be printed using
8738 #include <isl/schedule_node.h>
8739 __isl_give isl_printer *isl_printer_print_schedule_node(
8740 __isl_take isl_printer *p,
8741 __isl_keep isl_schedule_node *node);
8742 __isl_give char *isl_schedule_node_to_str(
8743 __isl_keep isl_schedule_node *node);
8745 C<isl_schedule_node_to_str> prints the schedule node in block format.
8747 =head2 Dependence Analysis
8749 C<isl> contains specialized functionality for performing
8750 array dataflow analysis. That is, given a I<sink> access relation
8751 and a collection of possible I<source> access relations,
8752 C<isl> can compute relations that describe
8753 for each iteration of the sink access, which iteration
8754 of which of the source access relations was the last
8755 to access the same data element before the given iteration
8757 The resulting dependence relations map source iterations
8758 to either the corresponding sink iterations or
8759 pairs of corresponding sink iterations and accessed data elements.
8760 To compute standard flow dependences, the sink should be
8761 a read, while the sources should be writes.
8762 If any of the source accesses are marked as being I<may>
8763 accesses, then there will be a (may) dependence from the last
8764 I<must> access B<and> from any I<may> access that follows
8765 this last I<must> access, but still precedes the sink access.
8766 Only dependences originating in a must access and without
8767 any may accesses between the must access and the sink access
8768 are considered to be must dependences.
8769 In particular, if I<all> sources are I<may> accesses,
8770 then memory based dependence analysis is performed.
8771 If, on the other hand, all sources are I<must> accesses,
8772 then value based dependence analysis is performed.
8774 =head3 High-level Interface
8776 A high-level interface to dependence analysis is provided
8777 by the following function.
8779 #include <isl/flow.h>
8780 __isl_give isl_union_flow *
8781 isl_union_access_info_compute_flow(
8782 __isl_take isl_union_access_info *access);
8784 The input C<isl_union_access_info> object describes the sink
8785 access relations, the source access relations and a schedule,
8786 while the output C<isl_union_flow> object describes
8787 the resulting dependence relations and the subsets of the
8788 sink relations for which no source was found.
8790 An C<isl_union_access_info> is created, modified, copied and freed using
8791 the following functions.
8793 #include <isl/flow.h>
8794 __isl_give isl_union_access_info *
8795 isl_union_access_info_from_sink(
8796 __isl_take isl_union_map *sink);
8797 __isl_give isl_union_access_info *
8798 isl_union_access_info_set_must_source(
8799 __isl_take isl_union_access_info *access,
8800 __isl_take isl_union_map *must_source);
8801 __isl_give isl_union_access_info *
8802 isl_union_access_info_set_may_source(
8803 __isl_take isl_union_access_info *access,
8804 __isl_take isl_union_map *may_source);
8805 __isl_give isl_union_access_info *
8806 isl_union_access_info_set_schedule(
8807 __isl_take isl_union_access_info *access,
8808 __isl_take isl_schedule *schedule);
8809 __isl_give isl_union_access_info *
8810 isl_union_access_info_set_schedule_map(
8811 __isl_take isl_union_access_info *access,
8812 __isl_take isl_union_map *schedule_map);
8813 __isl_give isl_union_access_info *
8814 isl_union_access_info_copy(
8815 __isl_keep isl_union_access_info *access);
8816 __isl_null isl_union_access_info *
8817 isl_union_access_info_free(
8818 __isl_take isl_union_access_info *access);
8820 The may sources set by C<isl_union_access_info_set_may_source>
8821 do not need to include the must sources set by
8822 C<isl_union_access_info_set_must_source> as a subset.
8823 The user is free not to call one (or both) of these functions,
8824 in which case the corresponding set is kept to its empty default.
8825 Similarly, the default schedule initialized by
8826 C<isl_union_access_info_from_sink> is empty.
8827 The current schedule is determined by the last call to either
8828 C<isl_union_access_info_set_schedule> or
8829 C<isl_union_access_info_set_schedule_map>.
8830 The domain of the schedule corresponds to the domains of
8831 the access relations. In particular, the domains of the access
8832 relations are effectively intersected with the domain of the schedule
8833 and only the resulting accesses are considered by the dependence analysis.
8835 A representation of the information contained in an object
8836 of type C<isl_union_access_info> can be obtained using
8838 #include <isl/flow.h>
8839 __isl_give isl_printer *
8840 isl_printer_print_union_access_info(
8841 __isl_take isl_printer *p,
8842 __isl_keep isl_union_access_info *access);
8843 __isl_give char *isl_union_access_info_to_str(
8844 __isl_keep isl_union_access_info *access);
8846 C<isl_union_access_info_to_str> prints the information in flow format.
8848 The output of C<isl_union_access_info_compute_flow> can be examined,
8849 copied, and freed using the following functions.
8851 #include <isl/flow.h>
8852 __isl_give isl_union_map *isl_union_flow_get_must_dependence(
8853 __isl_keep isl_union_flow *flow);
8854 __isl_give isl_union_map *isl_union_flow_get_may_dependence(
8855 __isl_keep isl_union_flow *flow);
8856 __isl_give isl_union_map *
8857 isl_union_flow_get_full_must_dependence(
8858 __isl_keep isl_union_flow *flow);
8859 __isl_give isl_union_map *
8860 isl_union_flow_get_full_may_dependence(
8861 __isl_keep isl_union_flow *flow);
8862 __isl_give isl_union_map *isl_union_flow_get_must_no_source(
8863 __isl_keep isl_union_flow *flow);
8864 __isl_give isl_union_map *isl_union_flow_get_may_no_source(
8865 __isl_keep isl_union_flow *flow);
8866 __isl_give isl_union_flow *isl_union_flow_copy(
8867 __isl_keep isl_union_flow *flow);
8868 __isl_null isl_union_flow *isl_union_flow_free(
8869 __isl_take isl_union_flow *flow);
8871 The relation returned by C<isl_union_flow_get_must_dependence>
8872 relates domain elements of must sources to domain elements of the sink.
8873 The relation returned by C<isl_union_flow_get_may_dependence>
8874 relates domain elements of must or may sources to domain elements of the sink
8875 and includes the previous relation as a subset.
8876 The relation returned by C<isl_union_flow_get_full_must_dependence>
8877 relates domain elements of must sources to pairs of domain elements of the sink
8878 and accessed data elements.
8879 The relation returned by C<isl_union_flow_get_full_may_dependence>
8880 relates domain elements of must or may sources to pairs of
8881 domain elements of the sink and accessed data elements.
8882 This relation includes the previous relation as a subset.
8883 The relation returned by C<isl_union_flow_get_must_no_source> is the subset
8884 of the sink relation for which no dependences have been found.
8885 The relation returned by C<isl_union_flow_get_may_no_source> is the subset
8886 of the sink relation for which no definite dependences have been found.
8887 That is, it contains those sink access that do not contribute to any
8888 of the elements in the relation returned
8889 by C<isl_union_flow_get_must_dependence>.
8891 A representation of the information contained in an object
8892 of type C<isl_union_flow> can be obtained using
8894 #include <isl/flow.h>
8895 __isl_give isl_printer *isl_printer_print_union_flow(
8896 __isl_take isl_printer *p,
8897 __isl_keep isl_union_flow *flow);
8898 __isl_give char *isl_union_flow_to_str(
8899 __isl_keep isl_union_flow *flow);
8901 C<isl_union_flow_to_str> prints the information in flow format.
8903 =head3 Low-level Interface
8905 A lower-level interface is provided by the following functions.
8907 #include <isl/flow.h>
8909 typedef int (*isl_access_level_before)(void *first, void *second);
8911 __isl_give isl_access_info *isl_access_info_alloc(
8912 __isl_take isl_map *sink,
8913 void *sink_user, isl_access_level_before fn,
8915 __isl_give isl_access_info *isl_access_info_add_source(
8916 __isl_take isl_access_info *acc,
8917 __isl_take isl_map *source, int must,
8919 __isl_null isl_access_info *isl_access_info_free(
8920 __isl_take isl_access_info *acc);
8922 __isl_give isl_flow *isl_access_info_compute_flow(
8923 __isl_take isl_access_info *acc);
8925 isl_stat isl_flow_foreach(__isl_keep isl_flow *deps,
8926 isl_stat (*fn)(__isl_take isl_map *dep, int must,
8927 void *dep_user, void *user),
8929 __isl_give isl_map *isl_flow_get_no_source(
8930 __isl_keep isl_flow *deps, int must);
8931 void isl_flow_free(__isl_take isl_flow *deps);
8933 The function C<isl_access_info_compute_flow> performs the actual
8934 dependence analysis. The other functions are used to construct
8935 the input for this function or to read off the output.
8937 The input is collected in an C<isl_access_info>, which can
8938 be created through a call to C<isl_access_info_alloc>.
8939 The arguments to this functions are the sink access relation
8940 C<sink>, a token C<sink_user> used to identify the sink
8941 access to the user, a callback function for specifying the
8942 relative order of source and sink accesses, and the number
8943 of source access relations that will be added.
8944 The callback function has type C<int (*)(void *first, void *second)>.
8945 The function is called with two user supplied tokens identifying
8946 either a source or the sink and it should return the shared nesting
8947 level and the relative order of the two accesses.
8948 In particular, let I<n> be the number of loops shared by
8949 the two accesses. If C<first> precedes C<second> textually,
8950 then the function should return I<2 * n + 1>; otherwise,
8951 it should return I<2 * n>.
8952 The sources can be added to the C<isl_access_info> by performing
8953 (at most) C<max_source> calls to C<isl_access_info_add_source>.
8954 C<must> indicates whether the source is a I<must> access
8955 or a I<may> access. Note that a multi-valued access relation
8956 should only be marked I<must> if every iteration in the domain
8957 of the relation accesses I<all> elements in its image.
8958 The C<source_user> token is again used to identify
8959 the source access. The range of the source access relation
8960 C<source> should have the same dimension as the range
8961 of the sink access relation.
8962 The C<isl_access_info_free> function should usually not be
8963 called explicitly, because it is called implicitly by
8964 C<isl_access_info_compute_flow>.
8966 The result of the dependence analysis is collected in an
8967 C<isl_flow>. There may be elements of
8968 the sink access for which no preceding source access could be
8969 found or for which all preceding sources are I<may> accesses.
8970 The relations containing these elements can be obtained through
8971 calls to C<isl_flow_get_no_source>, the first with C<must> set
8972 and the second with C<must> unset.
8973 In the case of standard flow dependence analysis,
8974 with the sink a read and the sources I<must> writes,
8975 the first relation corresponds to the reads from uninitialized
8976 array elements and the second relation is empty.
8977 The actual flow dependences can be extracted using
8978 C<isl_flow_foreach>. This function will call the user-specified
8979 callback function C<fn> for each B<non-empty> dependence between
8980 a source and the sink. The callback function is called
8981 with four arguments, the actual flow dependence relation
8982 mapping source iterations to sink iterations, a boolean that
8983 indicates whether it is a I<must> or I<may> dependence, a token
8984 identifying the source and an additional C<void *> with value
8985 equal to the third argument of the C<isl_flow_foreach> call.
8986 A dependence is marked I<must> if it originates from a I<must>
8987 source and if it is not followed by any I<may> sources.
8989 After finishing with an C<isl_flow>, the user should call
8990 C<isl_flow_free> to free all associated memory.
8992 =head3 Interaction with the Low-level Interface
8994 During the dependence analysis, we frequently need to perform
8995 the following operation. Given a relation between sink iterations
8996 and potential source iterations from a particular source domain,
8997 what is the last potential source iteration corresponding to each
8998 sink iteration. It can sometimes be convenient to adjust
8999 the set of potential source iterations before or after each such operation.
9000 The prototypical example is fuzzy array dataflow analysis,
9001 where we need to analyze if, based on data-dependent constraints,
9002 the sink iteration can ever be executed without one or more of
9003 the corresponding potential source iterations being executed.
9004 If so, we can introduce extra parameters and select an unknown
9005 but fixed source iteration from the potential source iterations.
9006 To be able to perform such manipulations, C<isl> provides the following
9009 #include <isl/flow.h>
9011 typedef __isl_give isl_restriction *(*isl_access_restrict)(
9012 __isl_keep isl_map *source_map,
9013 __isl_keep isl_set *sink, void *source_user,
9015 __isl_give isl_access_info *isl_access_info_set_restrict(
9016 __isl_take isl_access_info *acc,
9017 isl_access_restrict fn, void *user);
9019 The function C<isl_access_info_set_restrict> should be called
9020 before calling C<isl_access_info_compute_flow> and registers a callback function
9021 that will be called any time C<isl> is about to compute the last
9022 potential source. The first argument is the (reverse) proto-dependence,
9023 mapping sink iterations to potential source iterations.
9024 The second argument represents the sink iterations for which
9025 we want to compute the last source iteration.
9026 The third argument is the token corresponding to the source
9027 and the final argument is the token passed to C<isl_access_info_set_restrict>.
9028 The callback is expected to return a restriction on either the input or
9029 the output of the operation computing the last potential source.
9030 If the input needs to be restricted then restrictions are needed
9031 for both the source and the sink iterations. The sink iterations
9032 and the potential source iterations will be intersected with these sets.
9033 If the output needs to be restricted then only a restriction on the source
9034 iterations is required.
9035 If any error occurs, the callback should return C<NULL>.
9036 An C<isl_restriction> object can be created, freed and inspected
9037 using the following functions.
9039 #include <isl/flow.h>
9041 __isl_give isl_restriction *isl_restriction_input(
9042 __isl_take isl_set *source_restr,
9043 __isl_take isl_set *sink_restr);
9044 __isl_give isl_restriction *isl_restriction_output(
9045 __isl_take isl_set *source_restr);
9046 __isl_give isl_restriction *isl_restriction_none(
9047 __isl_take isl_map *source_map);
9048 __isl_give isl_restriction *isl_restriction_empty(
9049 __isl_take isl_map *source_map);
9050 __isl_null isl_restriction *isl_restriction_free(
9051 __isl_take isl_restriction *restr);
9053 C<isl_restriction_none> and C<isl_restriction_empty> are special
9054 cases of C<isl_restriction_input>. C<isl_restriction_none>
9055 is essentially equivalent to
9057 isl_restriction_input(isl_set_universe(
9058 isl_space_range(isl_map_get_space(source_map))),
9060 isl_space_domain(isl_map_get_space(source_map))));
9062 whereas C<isl_restriction_empty> is essentially equivalent to
9064 isl_restriction_input(isl_set_empty(
9065 isl_space_range(isl_map_get_space(source_map))),
9067 isl_space_domain(isl_map_get_space(source_map))));
9071 #include <isl/schedule.h>
9072 __isl_give isl_schedule *
9073 isl_schedule_constraints_compute_schedule(
9074 __isl_take isl_schedule_constraints *sc);
9076 The function C<isl_schedule_constraints_compute_schedule> can be
9077 used to compute a schedule that satisfies the given schedule constraints.
9078 These schedule constraints include the iteration domain for which
9079 a schedule should be computed and dependences between pairs of
9080 iterations. In particular, these dependences include
9081 I<validity> dependences and I<proximity> dependences.
9082 By default, the algorithm used to construct the schedule is similar
9083 to that of C<Pluto>.
9084 Alternatively, Feautrier's multi-dimensional scheduling algorithm can
9086 The generated schedule respects all validity dependences.
9087 That is, all dependence distances over these dependences in the
9088 scheduled space are lexicographically positive.
9090 The default algorithm tries to ensure that the dependence distances
9091 over coincidence constraints are zero and to minimize the
9092 dependence distances over proximity dependences.
9093 Moreover, it tries to obtain sequences (bands) of schedule dimensions
9094 for groups of domains where the dependence distances over validity
9095 dependences have only non-negative values.
9096 Note that when minimizing the maximal dependence distance
9097 over proximity dependences, a single affine expression in the parameters
9098 is constructed that bounds all dependence distances. If no such expression
9099 exists, then the algorithm will fail and resort to an alternative
9100 scheduling algorithm. In particular, this means that adding proximity
9101 dependences may eliminate valid solutions. A typical example where this
9102 phenomenon may occur is when some subset of the proximity dependences
9103 has no restriction on some parameter, forcing the coefficient of that
9104 parameter to be zero, while some other subset forces the dependence
9105 distance to depend on that parameter, requiring the same coefficient
9107 When using Feautrier's algorithm, the coincidence and proximity constraints
9108 are only taken into account during the extension to a
9109 full-dimensional schedule.
9111 An C<isl_schedule_constraints> object can be constructed
9112 and manipulated using the following functions.
9114 #include <isl/schedule.h>
9115 __isl_give isl_schedule_constraints *
9116 isl_schedule_constraints_copy(
9117 __isl_keep isl_schedule_constraints *sc);
9118 __isl_give isl_schedule_constraints *
9119 isl_schedule_constraints_on_domain(
9120 __isl_take isl_union_set *domain);
9121 __isl_give isl_schedule_constraints *
9122 isl_schedule_constraints_set_context(
9123 __isl_take isl_schedule_constraints *sc,
9124 __isl_take isl_set *context);
9125 __isl_give isl_schedule_constraints *
9126 isl_schedule_constraints_set_validity(
9127 __isl_take isl_schedule_constraints *sc,
9128 __isl_take isl_union_map *validity);
9129 __isl_give isl_schedule_constraints *
9130 isl_schedule_constraints_set_coincidence(
9131 __isl_take isl_schedule_constraints *sc,
9132 __isl_take isl_union_map *coincidence);
9133 __isl_give isl_schedule_constraints *
9134 isl_schedule_constraints_set_proximity(
9135 __isl_take isl_schedule_constraints *sc,
9136 __isl_take isl_union_map *proximity);
9137 __isl_give isl_schedule_constraints *
9138 isl_schedule_constraints_set_conditional_validity(
9139 __isl_take isl_schedule_constraints *sc,
9140 __isl_take isl_union_map *condition,
9141 __isl_take isl_union_map *validity);
9142 __isl_give isl_schedule_constraints *
9143 isl_schedule_constraints_apply(
9144 __isl_take isl_schedule_constraints *sc,
9145 __isl_take isl_union_map *umap);
9146 __isl_null isl_schedule_constraints *
9147 isl_schedule_constraints_free(
9148 __isl_take isl_schedule_constraints *sc);
9150 The initial C<isl_schedule_constraints> object created by
9151 C<isl_schedule_constraints_on_domain> does not impose any constraints.
9152 That is, it has an empty set of dependences.
9153 The function C<isl_schedule_constraints_set_context> allows the user
9154 to specify additional constraints on the parameters that may
9155 be assumed to hold during the construction of the schedule.
9156 The function C<isl_schedule_constraints_set_validity> replaces the
9157 validity dependences, mapping domain elements I<i> to domain
9158 elements that should be scheduled after I<i>.
9159 The function C<isl_schedule_constraints_set_coincidence> replaces the
9160 coincidence dependences, mapping domain elements I<i> to domain
9161 elements that should be scheduled together with I<I>, if possible.
9162 The function C<isl_schedule_constraints_set_proximity> replaces the
9163 proximity dependences, mapping domain elements I<i> to domain
9164 elements that should be scheduled either before I<I>
9165 or as early as possible after I<i>.
9167 The function C<isl_schedule_constraints_set_conditional_validity>
9168 replaces the conditional validity constraints.
9169 A conditional validity constraint is only imposed when any of the corresponding
9170 conditions is satisfied, i.e., when any of them is non-zero.
9171 That is, the scheduler ensures that within each band if the dependence
9172 distances over the condition constraints are not all zero
9173 then all corresponding conditional validity constraints are respected.
9174 A conditional validity constraint corresponds to a condition
9175 if the two are adjacent, i.e., if the domain of one relation intersect
9176 the range of the other relation.
9177 The typical use case of conditional validity constraints is
9178 to allow order constraints between live ranges to be violated
9179 as long as the live ranges themselves are local to the band.
9180 To allow more fine-grained control over which conditions correspond
9181 to which conditional validity constraints, the domains and ranges
9182 of these relations may include I<tags>. That is, the domains and
9183 ranges of those relation may themselves be wrapped relations
9184 where the iteration domain appears in the domain of those wrapped relations
9185 and the range of the wrapped relations can be arbitrarily chosen
9186 by the user. Conditions and conditional validity constraints are only
9187 considered adjacent to each other if the entire wrapped relation matches.
9188 In particular, a relation with a tag will never be considered adjacent
9189 to a relation without a tag.
9191 The function C<isl_schedule_constraints_compute_schedule> takes
9192 schedule constraints that are defined on some set of domain elements
9193 and transforms them to schedule constraints on the elements
9194 to which these domain elements are mapped by the given transformation.
9196 An C<isl_schedule_constraints> object can be inspected
9197 using the following functions.
9199 #include <isl/schedule.h>
9200 __isl_give isl_union_set *
9201 isl_schedule_constraints_get_domain(
9202 __isl_keep isl_schedule_constraints *sc);
9203 __isl_give isl_set *isl_schedule_constraints_get_context(
9204 __isl_keep isl_schedule_constraints *sc);
9205 __isl_give isl_union_map *
9206 isl_schedule_constraints_get_validity(
9207 __isl_keep isl_schedule_constraints *sc);
9208 __isl_give isl_union_map *
9209 isl_schedule_constraints_get_coincidence(
9210 __isl_keep isl_schedule_constraints *sc);
9211 __isl_give isl_union_map *
9212 isl_schedule_constraints_get_proximity(
9213 __isl_keep isl_schedule_constraints *sc);
9214 __isl_give isl_union_map *
9215 isl_schedule_constraints_get_conditional_validity(
9216 __isl_keep isl_schedule_constraints *sc);
9217 __isl_give isl_union_map *
9218 isl_schedule_constraints_get_conditional_validity_condition(
9219 __isl_keep isl_schedule_constraints *sc);
9221 An C<isl_schedule_constraints> object can be read from input
9222 using the following functions.
9224 #include <isl/schedule.h>
9225 __isl_give isl_schedule_constraints *
9226 isl_schedule_constraints_read_from_str(isl_ctx *ctx,
9228 __isl_give isl_schedule_constraints *
9229 isl_schedule_constraints_read_from_file(isl_ctx *ctx,
9232 The contents of an C<isl_schedule_constraints> object can be printed
9233 using the following functions.
9235 #include <isl/schedule.h>
9236 __isl_give isl_printer *
9237 isl_printer_print_schedule_constraints(
9238 __isl_take isl_printer *p,
9239 __isl_keep isl_schedule_constraints *sc);
9240 __isl_give char *isl_schedule_constraints_to_str(
9241 __isl_keep isl_schedule_constraints *sc);
9243 The following function computes a schedule directly from
9244 an iteration domain and validity and proximity dependences
9245 and is implemented in terms of the functions described above.
9246 The use of C<isl_union_set_compute_schedule> is discouraged.
9248 #include <isl/schedule.h>
9249 __isl_give isl_schedule *isl_union_set_compute_schedule(
9250 __isl_take isl_union_set *domain,
9251 __isl_take isl_union_map *validity,
9252 __isl_take isl_union_map *proximity);
9254 The generated schedule represents a schedule tree.
9255 For more information on schedule trees, see
9256 L</"Schedule Trees">.
9260 #include <isl/schedule.h>
9261 isl_stat isl_options_set_schedule_max_coefficient(
9262 isl_ctx *ctx, int val);
9263 int isl_options_get_schedule_max_coefficient(
9265 isl_stat isl_options_set_schedule_max_constant_term(
9266 isl_ctx *ctx, int val);
9267 int isl_options_get_schedule_max_constant_term(
9269 isl_stat isl_options_set_schedule_serialize_sccs(
9270 isl_ctx *ctx, int val);
9271 int isl_options_get_schedule_serialize_sccs(isl_ctx *ctx);
9272 isl_stat isl_options_set_schedule_whole_component(
9273 isl_ctx *ctx, int val);
9274 int isl_options_get_schedule_whole_component(
9276 isl_stat isl_options_set_schedule_maximize_band_depth(
9277 isl_ctx *ctx, int val);
9278 int isl_options_get_schedule_maximize_band_depth(
9280 isl_stat isl_options_set_schedule_maximize_coincidence(
9281 isl_ctx *ctx, int val);
9282 int isl_options_get_schedule_maximize_coincidence(
9284 isl_stat isl_options_set_schedule_outer_coincidence(
9285 isl_ctx *ctx, int val);
9286 int isl_options_get_schedule_outer_coincidence(
9288 isl_stat isl_options_set_schedule_split_scaled(
9289 isl_ctx *ctx, int val);
9290 int isl_options_get_schedule_split_scaled(
9292 isl_stat isl_options_set_schedule_treat_coalescing(
9293 isl_ctx *ctx, int val);
9294 int isl_options_get_schedule_treat_coalescing(
9296 isl_stat isl_options_set_schedule_algorithm(
9297 isl_ctx *ctx, int val);
9298 int isl_options_get_schedule_algorithm(
9300 isl_stat isl_options_set_schedule_separate_components(
9301 isl_ctx *ctx, int val);
9302 int isl_options_get_schedule_separate_components(
9307 =item * schedule_max_coefficient
9309 This option enforces that the coefficients for variable and parameter
9310 dimensions in the calculated schedule are not larger than the specified value.
9311 This option can significantly increase the speed of the scheduling calculation
9312 and may also prevent fusing of unrelated dimensions. A value of -1 means that
9313 this option does not introduce bounds on the variable or parameter
9316 =item * schedule_max_constant_term
9318 This option enforces that the constant coefficients in the calculated schedule
9319 are not larger than the maximal constant term. This option can significantly
9320 increase the speed of the scheduling calculation and may also prevent fusing of
9321 unrelated dimensions. A value of -1 means that this option does not introduce
9322 bounds on the constant coefficients.
9324 =item * schedule_serialize_sccs
9326 If this option is set, then all strongly connected components
9327 in the dependence graph are serialized as soon as they are detected.
9328 This means in particular that instances of statements will only
9329 appear in the same band node if these statements belong
9330 to the same strongly connected component at the point where
9331 the band node is constructed.
9333 =item * schedule_whole_component
9335 If this option is set, then entire (weakly) connected
9336 components in the dependence graph are scheduled together
9338 Otherwise, each strongly connected component within
9339 such a weakly connected component is first scheduled separately
9340 and then combined with other strongly connected components.
9341 This option has no effect if C<schedule_serialize_sccs> is set.
9343 =item * schedule_maximize_band_depth
9345 If this option is set, then the scheduler tries to maximize
9346 the width of the bands. Wider bands give more possibilities for tiling.
9347 In particular, if the C<schedule_whole_component> option is set,
9348 then bands are split if this might result in wider bands.
9349 Otherwise, the effect of this option is to only allow
9350 strongly connected components to be combined if this does
9351 not reduce the width of the bands.
9352 Note that if the C<schedule_serialize_sccs> options is set, then
9353 the C<schedule_maximize_band_depth> option therefore has no effect.
9355 =item * schedule_maximize_coincidence
9357 This option is only effective if the C<schedule_whole_component>
9358 option is turned off.
9359 If the C<schedule_maximize_coincidence> option is set, then (clusters of)
9360 strongly connected components are only combined with each other
9361 if this does not reduce the number of coincident band members.
9363 =item * schedule_outer_coincidence
9365 If this option is set, then we try to construct schedules
9366 where the outermost scheduling dimension in each band
9367 satisfies the coincidence constraints.
9369 =item * schedule_algorithm
9371 Selects the scheduling algorithm to be used.
9372 Available scheduling algorithms are C<ISL_SCHEDULE_ALGORITHM_ISL>
9373 and C<ISL_SCHEDULE_ALGORITHM_FEAUTRIER>.
9375 =item * schedule_split_scaled
9377 If this option is set, then we try to construct schedules in which the
9378 constant term is split off from the linear part if the linear parts of
9379 the scheduling rows for all nodes in the graph have a common non-trivial
9381 The constant term is then placed in a separate band and the linear
9383 This option is only effective when the Feautrier style scheduler is
9384 being used, either as the main scheduler or as a fallback for the
9385 Pluto-like scheduler.
9387 =item * schedule_treat_coalescing
9389 If this option is set, then the scheduler will try and avoid
9390 producing schedules that perform loop coalescing.
9391 In particular, for the Pluto-like scheduler, this option places
9392 bounds on the schedule coefficients based on the sizes of the instance sets.
9393 For the Feautrier style scheduler, this option detects potentially
9394 coalescing schedules and then tries to adjust the schedule to avoid
9397 =item * schedule_separate_components
9399 If this option is set then the function C<isl_schedule_get_map>
9400 will treat set nodes in the same way as sequence nodes.
9404 =head2 AST Generation
9406 This section describes the C<isl> functionality for generating
9407 ASTs that visit all the elements
9408 in a domain in an order specified by a schedule tree or
9410 In case the schedule given as a C<isl_union_map>, an AST is generated
9411 that visits all the elements in the domain of the C<isl_union_map>
9412 according to the lexicographic order of the corresponding image
9413 element(s). If the range of the C<isl_union_map> consists of
9414 elements in more than one space, then each of these spaces is handled
9415 separately in an arbitrary order.
9416 It should be noted that the schedule tree or the image elements
9417 in a schedule map only specify the I<order>
9418 in which the corresponding domain elements should be visited.
9419 No direct relation between the partial schedule values
9420 or the image elements on the one hand and the loop iterators
9421 in the generated AST on the other hand should be assumed.
9423 Each AST is generated within a build. The initial build
9424 simply specifies the constraints on the parameters (if any)
9425 and can be created, inspected, copied and freed using the following functions.
9427 #include <isl/ast_build.h>
9428 __isl_give isl_ast_build *isl_ast_build_alloc(
9430 __isl_give isl_ast_build *isl_ast_build_from_context(
9431 __isl_take isl_set *set);
9432 __isl_give isl_ast_build *isl_ast_build_copy(
9433 __isl_keep isl_ast_build *build);
9434 __isl_null isl_ast_build *isl_ast_build_free(
9435 __isl_take isl_ast_build *build);
9437 The C<set> argument is usually a parameter set with zero or more parameters.
9438 In fact, when creating an AST using C<isl_ast_build_node_from_schedule>,
9439 this set is required to be a parameter set.
9440 An C<isl_ast_build> created using C<isl_ast_build_alloc> does not
9441 specify any parameter constraints.
9442 More C<isl_ast_build> functions are described in L</"Nested AST Generation">
9443 and L</"Fine-grained Control over AST Generation">.
9444 Finally, the AST itself can be constructed using one of the following
9447 #include <isl/ast_build.h>
9448 __isl_give isl_ast_node *isl_ast_build_node_from_schedule(
9449 __isl_keep isl_ast_build *build,
9450 __isl_take isl_schedule *schedule);
9451 __isl_give isl_ast_node *
9452 isl_ast_build_node_from_schedule_map(
9453 __isl_keep isl_ast_build *build,
9454 __isl_take isl_union_map *schedule);
9456 =head3 Inspecting the AST
9458 The basic properties of an AST node can be obtained as follows.
9460 #include <isl/ast.h>
9461 enum isl_ast_node_type isl_ast_node_get_type(
9462 __isl_keep isl_ast_node *node);
9464 The type of an AST node is one of
9465 C<isl_ast_node_for>,
9467 C<isl_ast_node_block>,
9468 C<isl_ast_node_mark> or
9469 C<isl_ast_node_user>.
9470 An C<isl_ast_node_for> represents a for node.
9471 An C<isl_ast_node_if> represents an if node.
9472 An C<isl_ast_node_block> represents a compound node.
9473 An C<isl_ast_node_mark> introduces a mark in the AST.
9474 An C<isl_ast_node_user> represents an expression statement.
9475 An expression statement typically corresponds to a domain element, i.e.,
9476 one of the elements that is visited by the AST.
9478 Each type of node has its own additional properties.
9480 #include <isl/ast.h>
9481 __isl_give isl_ast_expr *isl_ast_node_for_get_iterator(
9482 __isl_keep isl_ast_node *node);
9483 __isl_give isl_ast_expr *isl_ast_node_for_get_init(
9484 __isl_keep isl_ast_node *node);
9485 __isl_give isl_ast_expr *isl_ast_node_for_get_cond(
9486 __isl_keep isl_ast_node *node);
9487 __isl_give isl_ast_expr *isl_ast_node_for_get_inc(
9488 __isl_keep isl_ast_node *node);
9489 __isl_give isl_ast_node *isl_ast_node_for_get_body(
9490 __isl_keep isl_ast_node *node);
9491 isl_bool isl_ast_node_for_is_degenerate(
9492 __isl_keep isl_ast_node *node);
9494 An C<isl_ast_for> is considered degenerate if it is known to execute
9497 #include <isl/ast.h>
9498 __isl_give isl_ast_expr *isl_ast_node_if_get_cond(
9499 __isl_keep isl_ast_node *node);
9500 __isl_give isl_ast_node *isl_ast_node_if_get_then(
9501 __isl_keep isl_ast_node *node);
9502 isl_bool isl_ast_node_if_has_else(
9503 __isl_keep isl_ast_node *node);
9504 __isl_give isl_ast_node *isl_ast_node_if_get_else(
9505 __isl_keep isl_ast_node *node);
9507 __isl_give isl_ast_node_list *
9508 isl_ast_node_block_get_children(
9509 __isl_keep isl_ast_node *node);
9511 __isl_give isl_id *isl_ast_node_mark_get_id(
9512 __isl_keep isl_ast_node *node);
9513 __isl_give isl_ast_node *isl_ast_node_mark_get_node(
9514 __isl_keep isl_ast_node *node);
9516 C<isl_ast_node_mark_get_id> returns the identifier of the mark.
9517 C<isl_ast_node_mark_get_node> returns the child node that is being marked.
9519 #include <isl/ast.h>
9520 __isl_give isl_ast_expr *isl_ast_node_user_get_expr(
9521 __isl_keep isl_ast_node *node);
9523 All descendants of a specific node in the AST (including the node itself)
9525 in depth-first pre-order using the following function.
9527 #include <isl/ast.h>
9528 isl_stat isl_ast_node_foreach_descendant_top_down(
9529 __isl_keep isl_ast_node *node,
9530 isl_bool (*fn)(__isl_keep isl_ast_node *node,
9531 void *user), void *user);
9533 The callback function should return C<isl_bool_true> if the children
9534 of the given node should be visited and C<isl_bool_false> if they should not.
9535 It should return C<isl_bool_error> in case of failure, in which case
9536 the entire traversal is aborted.
9538 Each of the returned C<isl_ast_expr>s can in turn be inspected using
9539 the following functions.
9541 #include <isl/ast.h>
9542 enum isl_ast_expr_type isl_ast_expr_get_type(
9543 __isl_keep isl_ast_expr *expr);
9545 The type of an AST expression is one of
9547 C<isl_ast_expr_id> or
9548 C<isl_ast_expr_int>.
9549 An C<isl_ast_expr_op> represents the result of an operation.
9550 An C<isl_ast_expr_id> represents an identifier.
9551 An C<isl_ast_expr_int> represents an integer value.
9553 Each type of expression has its own additional properties.
9555 #include <isl/ast.h>
9556 enum isl_ast_op_type isl_ast_expr_get_op_type(
9557 __isl_keep isl_ast_expr *expr);
9558 int isl_ast_expr_get_op_n_arg(__isl_keep isl_ast_expr *expr);
9559 __isl_give isl_ast_expr *isl_ast_expr_get_op_arg(
9560 __isl_keep isl_ast_expr *expr, int pos);
9561 isl_stat isl_ast_expr_foreach_ast_op_type(
9562 __isl_keep isl_ast_expr *expr,
9563 isl_stat (*fn)(enum isl_ast_op_type type,
9564 void *user), void *user);
9565 isl_stat isl_ast_node_foreach_ast_op_type(
9566 __isl_keep isl_ast_node *node,
9567 isl_stat (*fn)(enum isl_ast_op_type type,
9568 void *user), void *user);
9570 C<isl_ast_expr_get_op_type> returns the type of the operation
9571 performed. C<isl_ast_expr_get_op_n_arg> returns the number of
9572 arguments. C<isl_ast_expr_get_op_arg> returns the specified
9574 C<isl_ast_expr_foreach_ast_op_type> calls C<fn> for each distinct
9575 C<isl_ast_op_type> that appears in C<expr>.
9576 C<isl_ast_node_foreach_ast_op_type> does the same for each distinct
9577 C<isl_ast_op_type> that appears in C<node>.
9578 The operation type is one of the following.
9582 =item C<isl_ast_op_and>
9584 Logical I<and> of two arguments.
9585 Both arguments can be evaluated.
9587 =item C<isl_ast_op_and_then>
9589 Logical I<and> of two arguments.
9590 The second argument can only be evaluated if the first evaluates to true.
9592 =item C<isl_ast_op_or>
9594 Logical I<or> of two arguments.
9595 Both arguments can be evaluated.
9597 =item C<isl_ast_op_or_else>
9599 Logical I<or> of two arguments.
9600 The second argument can only be evaluated if the first evaluates to false.
9602 =item C<isl_ast_op_max>
9604 Maximum of two or more arguments.
9606 =item C<isl_ast_op_min>
9608 Minimum of two or more arguments.
9610 =item C<isl_ast_op_minus>
9614 =item C<isl_ast_op_add>
9616 Sum of two arguments.
9618 =item C<isl_ast_op_sub>
9620 Difference of two arguments.
9622 =item C<isl_ast_op_mul>
9624 Product of two arguments.
9626 =item C<isl_ast_op_div>
9628 Exact division. That is, the result is known to be an integer.
9630 =item C<isl_ast_op_fdiv_q>
9632 Result of integer division, rounded towards negative
9635 =item C<isl_ast_op_pdiv_q>
9637 Result of integer division, where dividend is known to be non-negative.
9639 =item C<isl_ast_op_pdiv_r>
9641 Remainder of integer division, where dividend is known to be non-negative.
9643 =item C<isl_ast_op_zdiv_r>
9645 Equal to zero iff the remainder on integer division is zero.
9647 =item C<isl_ast_op_cond>
9649 Conditional operator defined on three arguments.
9650 If the first argument evaluates to true, then the result
9651 is equal to the second argument. Otherwise, the result
9652 is equal to the third argument.
9653 The second and third argument may only be evaluated if
9654 the first argument evaluates to true and false, respectively.
9655 Corresponds to C<a ? b : c> in C.
9657 =item C<isl_ast_op_select>
9659 Conditional operator defined on three arguments.
9660 If the first argument evaluates to true, then the result
9661 is equal to the second argument. Otherwise, the result
9662 is equal to the third argument.
9663 The second and third argument may be evaluated independently
9664 of the value of the first argument.
9665 Corresponds to C<a * b + (1 - a) * c> in C.
9667 =item C<isl_ast_op_eq>
9671 =item C<isl_ast_op_le>
9673 Less than or equal relation.
9675 =item C<isl_ast_op_lt>
9679 =item C<isl_ast_op_ge>
9681 Greater than or equal relation.
9683 =item C<isl_ast_op_gt>
9685 Greater than relation.
9687 =item C<isl_ast_op_call>
9690 The number of arguments of the C<isl_ast_expr> is one more than
9691 the number of arguments in the function call, the first argument
9692 representing the function being called.
9694 =item C<isl_ast_op_access>
9697 The number of arguments of the C<isl_ast_expr> is one more than
9698 the number of index expressions in the array access, the first argument
9699 representing the array being accessed.
9701 =item C<isl_ast_op_member>
9704 This operation has two arguments, a structure and the name of
9705 the member of the structure being accessed.
9709 #include <isl/ast.h>
9710 __isl_give isl_id *isl_ast_expr_get_id(
9711 __isl_keep isl_ast_expr *expr);
9713 Return the identifier represented by the AST expression.
9715 #include <isl/ast.h>
9716 __isl_give isl_val *isl_ast_expr_get_val(
9717 __isl_keep isl_ast_expr *expr);
9719 Return the integer represented by the AST expression.
9721 =head3 Properties of ASTs
9723 #include <isl/ast.h>
9724 isl_bool isl_ast_expr_is_equal(
9725 __isl_keep isl_ast_expr *expr1,
9726 __isl_keep isl_ast_expr *expr2);
9728 Check if two C<isl_ast_expr>s are equal to each other.
9730 =head3 Manipulating and printing the AST
9732 AST nodes can be copied and freed using the following functions.
9734 #include <isl/ast.h>
9735 __isl_give isl_ast_node *isl_ast_node_copy(
9736 __isl_keep isl_ast_node *node);
9737 __isl_null isl_ast_node *isl_ast_node_free(
9738 __isl_take isl_ast_node *node);
9740 AST expressions can be copied and freed using the following functions.
9742 #include <isl/ast.h>
9743 __isl_give isl_ast_expr *isl_ast_expr_copy(
9744 __isl_keep isl_ast_expr *expr);
9745 __isl_null isl_ast_expr *isl_ast_expr_free(
9746 __isl_take isl_ast_expr *expr);
9748 New AST expressions can be created either directly or within
9749 the context of an C<isl_ast_build>.
9751 #include <isl/ast.h>
9752 __isl_give isl_ast_expr *isl_ast_expr_from_val(
9753 __isl_take isl_val *v);
9754 __isl_give isl_ast_expr *isl_ast_expr_from_id(
9755 __isl_take isl_id *id);
9756 __isl_give isl_ast_expr *isl_ast_expr_neg(
9757 __isl_take isl_ast_expr *expr);
9758 __isl_give isl_ast_expr *isl_ast_expr_address_of(
9759 __isl_take isl_ast_expr *expr);
9760 __isl_give isl_ast_expr *isl_ast_expr_add(
9761 __isl_take isl_ast_expr *expr1,
9762 __isl_take isl_ast_expr *expr2);
9763 __isl_give isl_ast_expr *isl_ast_expr_sub(
9764 __isl_take isl_ast_expr *expr1,
9765 __isl_take isl_ast_expr *expr2);
9766 __isl_give isl_ast_expr *isl_ast_expr_mul(
9767 __isl_take isl_ast_expr *expr1,
9768 __isl_take isl_ast_expr *expr2);
9769 __isl_give isl_ast_expr *isl_ast_expr_div(
9770 __isl_take isl_ast_expr *expr1,
9771 __isl_take isl_ast_expr *expr2);
9772 __isl_give isl_ast_expr *isl_ast_expr_pdiv_q(
9773 __isl_take isl_ast_expr *expr1,
9774 __isl_take isl_ast_expr *expr2);
9775 __isl_give isl_ast_expr *isl_ast_expr_pdiv_r(
9776 __isl_take isl_ast_expr *expr1,
9777 __isl_take isl_ast_expr *expr2);
9778 __isl_give isl_ast_expr *isl_ast_expr_and(
9779 __isl_take isl_ast_expr *expr1,
9780 __isl_take isl_ast_expr *expr2)
9781 __isl_give isl_ast_expr *isl_ast_expr_and_then(
9782 __isl_take isl_ast_expr *expr1,
9783 __isl_take isl_ast_expr *expr2)
9784 __isl_give isl_ast_expr *isl_ast_expr_or(
9785 __isl_take isl_ast_expr *expr1,
9786 __isl_take isl_ast_expr *expr2)
9787 __isl_give isl_ast_expr *isl_ast_expr_or_else(
9788 __isl_take isl_ast_expr *expr1,
9789 __isl_take isl_ast_expr *expr2)
9790 __isl_give isl_ast_expr *isl_ast_expr_eq(
9791 __isl_take isl_ast_expr *expr1,
9792 __isl_take isl_ast_expr *expr2);
9793 __isl_give isl_ast_expr *isl_ast_expr_le(
9794 __isl_take isl_ast_expr *expr1,
9795 __isl_take isl_ast_expr *expr2);
9796 __isl_give isl_ast_expr *isl_ast_expr_lt(
9797 __isl_take isl_ast_expr *expr1,
9798 __isl_take isl_ast_expr *expr2);
9799 __isl_give isl_ast_expr *isl_ast_expr_ge(
9800 __isl_take isl_ast_expr *expr1,
9801 __isl_take isl_ast_expr *expr2);
9802 __isl_give isl_ast_expr *isl_ast_expr_gt(
9803 __isl_take isl_ast_expr *expr1,
9804 __isl_take isl_ast_expr *expr2);
9805 __isl_give isl_ast_expr *isl_ast_expr_access(
9806 __isl_take isl_ast_expr *array,
9807 __isl_take isl_ast_expr_list *indices);
9808 __isl_give isl_ast_expr *isl_ast_expr_call(
9809 __isl_take isl_ast_expr *function,
9810 __isl_take isl_ast_expr_list *arguments);
9812 The function C<isl_ast_expr_address_of> can be applied to an
9813 C<isl_ast_expr> of type C<isl_ast_op_access> only. It is meant
9814 to represent the address of the C<isl_ast_expr_access>. The function
9815 C<isl_ast_expr_and_then> as well as C<isl_ast_expr_or_else> are short-circuit
9816 versions of C<isl_ast_expr_and> and C<isl_ast_expr_or>, respectively.
9818 #include <isl/ast_build.h>
9819 __isl_give isl_ast_expr *isl_ast_build_expr_from_set(
9820 __isl_keep isl_ast_build *build,
9821 __isl_take isl_set *set);
9822 __isl_give isl_ast_expr *isl_ast_build_expr_from_pw_aff(
9823 __isl_keep isl_ast_build *build,
9824 __isl_take isl_pw_aff *pa);
9825 __isl_give isl_ast_expr *
9826 isl_ast_build_access_from_pw_multi_aff(
9827 __isl_keep isl_ast_build *build,
9828 __isl_take isl_pw_multi_aff *pma);
9829 __isl_give isl_ast_expr *
9830 isl_ast_build_access_from_multi_pw_aff(
9831 __isl_keep isl_ast_build *build,
9832 __isl_take isl_multi_pw_aff *mpa);
9833 __isl_give isl_ast_expr *
9834 isl_ast_build_call_from_pw_multi_aff(
9835 __isl_keep isl_ast_build *build,
9836 __isl_take isl_pw_multi_aff *pma);
9837 __isl_give isl_ast_expr *
9838 isl_ast_build_call_from_multi_pw_aff(
9839 __isl_keep isl_ast_build *build,
9840 __isl_take isl_multi_pw_aff *mpa);
9843 the domains of C<pa>, C<mpa> and C<pma> should correspond
9844 to the schedule space of C<build>.
9845 The tuple id of C<mpa> or C<pma> is used as the array being accessed or
9846 the function being called.
9847 If the accessed space is a nested relation, then it is taken
9848 to represent an access of the member specified by the range
9849 of this nested relation of the structure specified by the domain
9850 of the nested relation.
9852 The following functions can be used to modify an C<isl_ast_expr>.
9854 #include <isl/ast.h>
9855 __isl_give isl_ast_expr *isl_ast_expr_set_op_arg(
9856 __isl_take isl_ast_expr *expr, int pos,
9857 __isl_take isl_ast_expr *arg);
9859 Replace the argument of C<expr> at position C<pos> by C<arg>.
9861 #include <isl/ast.h>
9862 __isl_give isl_ast_expr *isl_ast_expr_substitute_ids(
9863 __isl_take isl_ast_expr *expr,
9864 __isl_take isl_id_to_ast_expr *id2expr);
9866 The function C<isl_ast_expr_substitute_ids> replaces the
9867 subexpressions of C<expr> of type C<isl_ast_expr_id>
9868 by the corresponding expression in C<id2expr>, if there is any.
9871 User specified data can be attached to an C<isl_ast_node> and obtained
9872 from the same C<isl_ast_node> using the following functions.
9874 #include <isl/ast.h>
9875 __isl_give isl_ast_node *isl_ast_node_set_annotation(
9876 __isl_take isl_ast_node *node,
9877 __isl_take isl_id *annotation);
9878 __isl_give isl_id *isl_ast_node_get_annotation(
9879 __isl_keep isl_ast_node *node);
9881 Basic printing can be performed using the following functions.
9883 #include <isl/ast.h>
9884 __isl_give isl_printer *isl_printer_print_ast_expr(
9885 __isl_take isl_printer *p,
9886 __isl_keep isl_ast_expr *expr);
9887 __isl_give isl_printer *isl_printer_print_ast_node(
9888 __isl_take isl_printer *p,
9889 __isl_keep isl_ast_node *node);
9890 __isl_give char *isl_ast_expr_to_str(
9891 __isl_keep isl_ast_expr *expr);
9892 __isl_give char *isl_ast_node_to_str(
9893 __isl_keep isl_ast_node *node);
9894 __isl_give char *isl_ast_expr_to_C_str(
9895 __isl_keep isl_ast_expr *expr);
9896 __isl_give char *isl_ast_node_to_C_str(
9897 __isl_keep isl_ast_node *node);
9899 The functions C<isl_ast_expr_to_C_str> and
9900 C<isl_ast_node_to_C_str> are convenience functions
9901 that return a string representation of the input in C format.
9903 More advanced printing can be performed using the following functions.
9905 #include <isl/ast.h>
9906 __isl_give isl_printer *isl_ast_op_type_set_print_name(
9907 __isl_take isl_printer *p,
9908 enum isl_ast_op_type type,
9909 __isl_keep const char *name);
9910 isl_stat isl_options_set_ast_print_macro_once(
9911 isl_ctx *ctx, int val);
9912 int isl_options_get_ast_print_macro_once(isl_ctx *ctx);
9913 __isl_give isl_printer *isl_ast_op_type_print_macro(
9914 enum isl_ast_op_type type,
9915 __isl_take isl_printer *p);
9916 __isl_give isl_printer *isl_ast_expr_print_macros(
9917 __isl_keep isl_ast_expr *expr,
9918 __isl_take isl_printer *p);
9919 __isl_give isl_printer *isl_ast_node_print_macros(
9920 __isl_keep isl_ast_node *node,
9921 __isl_take isl_printer *p);
9922 __isl_give isl_printer *isl_ast_node_print(
9923 __isl_keep isl_ast_node *node,
9924 __isl_take isl_printer *p,
9925 __isl_take isl_ast_print_options *options);
9926 __isl_give isl_printer *isl_ast_node_for_print(
9927 __isl_keep isl_ast_node *node,
9928 __isl_take isl_printer *p,
9929 __isl_take isl_ast_print_options *options);
9930 __isl_give isl_printer *isl_ast_node_if_print(
9931 __isl_keep isl_ast_node *node,
9932 __isl_take isl_printer *p,
9933 __isl_take isl_ast_print_options *options);
9935 While printing an C<isl_ast_node> in C<ISL_FORMAT_C>,
9936 C<isl> may print out an AST that makes use of macros such
9937 as C<floord>, C<min> and C<max>.
9938 The names of these macros may be modified by a call
9939 to C<isl_ast_op_type_set_print_name>. The user-specified
9940 names are associated to the printer object.
9941 C<isl_ast_op_type_print_macro> prints out the macro
9942 corresponding to a specific C<isl_ast_op_type>.
9943 If the print-macro-once option is set, then a given macro definition
9944 is only printed once to any given printer object.
9945 C<isl_ast_expr_print_macros> scans the C<isl_ast_expr>
9946 for subexpressions where these macros would be used and prints
9947 out the required macro definitions.
9948 Essentially, C<isl_ast_expr_print_macros> calls
9949 C<isl_ast_expr_foreach_ast_op_type> with C<isl_ast_op_type_print_macro>
9950 as function argument.
9951 C<isl_ast_node_print_macros> does the same
9952 for expressions in its C<isl_ast_node> argument.
9953 C<isl_ast_node_print>, C<isl_ast_node_for_print> and
9954 C<isl_ast_node_if_print> print an C<isl_ast_node>
9955 in C<ISL_FORMAT_C>, but allow for some extra control
9956 through an C<isl_ast_print_options> object.
9957 This object can be created using the following functions.
9959 #include <isl/ast.h>
9960 __isl_give isl_ast_print_options *
9961 isl_ast_print_options_alloc(isl_ctx *ctx);
9962 __isl_give isl_ast_print_options *
9963 isl_ast_print_options_copy(
9964 __isl_keep isl_ast_print_options *options);
9965 __isl_null isl_ast_print_options *
9966 isl_ast_print_options_free(
9967 __isl_take isl_ast_print_options *options);
9969 __isl_give isl_ast_print_options *
9970 isl_ast_print_options_set_print_user(
9971 __isl_take isl_ast_print_options *options,
9972 __isl_give isl_printer *(*print_user)(
9973 __isl_take isl_printer *p,
9974 __isl_take isl_ast_print_options *options,
9975 __isl_keep isl_ast_node *node, void *user),
9977 __isl_give isl_ast_print_options *
9978 isl_ast_print_options_set_print_for(
9979 __isl_take isl_ast_print_options *options,
9980 __isl_give isl_printer *(*print_for)(
9981 __isl_take isl_printer *p,
9982 __isl_take isl_ast_print_options *options,
9983 __isl_keep isl_ast_node *node, void *user),
9986 The callback set by C<isl_ast_print_options_set_print_user>
9987 is called whenever a node of type C<isl_ast_node_user> needs to
9989 The callback set by C<isl_ast_print_options_set_print_for>
9990 is called whenever a node of type C<isl_ast_node_for> needs to
9992 Note that C<isl_ast_node_for_print> will I<not> call the
9993 callback set by C<isl_ast_print_options_set_print_for> on the node
9994 on which C<isl_ast_node_for_print> is called, but only on nested
9995 nodes of type C<isl_ast_node_for>. It is therefore safe to
9996 call C<isl_ast_node_for_print> from within the callback set by
9997 C<isl_ast_print_options_set_print_for>.
9999 The following option determines the type to be used for iterators
10000 while printing the AST.
10002 isl_stat isl_options_set_ast_iterator_type(
10003 isl_ctx *ctx, const char *val);
10004 const char *isl_options_get_ast_iterator_type(
10007 The AST printer only prints body nodes as blocks if these
10008 blocks cannot be safely omitted.
10009 For example, a C<for> node with one body node will not be
10010 surrounded with braces in C<ISL_FORMAT_C>.
10011 A block will always be printed by setting the following option.
10013 isl_stat isl_options_set_ast_always_print_block(isl_ctx *ctx,
10015 int isl_options_get_ast_always_print_block(isl_ctx *ctx);
10019 #include <isl/ast_build.h>
10020 isl_stat isl_options_set_ast_build_atomic_upper_bound(
10021 isl_ctx *ctx, int val);
10022 int isl_options_get_ast_build_atomic_upper_bound(
10024 isl_stat isl_options_set_ast_build_prefer_pdiv(isl_ctx *ctx,
10026 int isl_options_get_ast_build_prefer_pdiv(isl_ctx *ctx);
10027 isl_stat isl_options_set_ast_build_detect_min_max(
10028 isl_ctx *ctx, int val);
10029 int isl_options_get_ast_build_detect_min_max(
10031 isl_stat isl_options_set_ast_build_exploit_nested_bounds(
10032 isl_ctx *ctx, int val);
10033 int isl_options_get_ast_build_exploit_nested_bounds(
10035 isl_stat isl_options_set_ast_build_group_coscheduled(
10036 isl_ctx *ctx, int val);
10037 int isl_options_get_ast_build_group_coscheduled(
10039 isl_stat isl_options_set_ast_build_scale_strides(
10040 isl_ctx *ctx, int val);
10041 int isl_options_get_ast_build_scale_strides(
10043 isl_stat isl_options_set_ast_build_allow_else(isl_ctx *ctx,
10045 int isl_options_get_ast_build_allow_else(isl_ctx *ctx);
10046 isl_stat isl_options_set_ast_build_allow_or(isl_ctx *ctx,
10048 int isl_options_get_ast_build_allow_or(isl_ctx *ctx);
10052 =item * ast_build_atomic_upper_bound
10054 Generate loop upper bounds that consist of the current loop iterator,
10055 an operator and an expression not involving the iterator.
10056 If this option is not set, then the current loop iterator may appear
10057 several times in the upper bound.
10058 For example, when this option is turned off, AST generation
10061 [n] -> { A[i] -> [i] : 0 <= i <= 100, n }
10065 for (int c0 = 0; c0 <= 100 && n >= c0; c0 += 1)
10068 When the option is turned on, the following AST is generated
10070 for (int c0 = 0; c0 <= min(100, n); c0 += 1)
10073 =item * ast_build_prefer_pdiv
10075 If this option is turned off, then the AST generation will
10076 produce ASTs that may only contain C<isl_ast_op_fdiv_q>
10077 operators, but no C<isl_ast_op_pdiv_q> or
10078 C<isl_ast_op_pdiv_r> operators.
10079 If this option is turned on, then C<isl> will try to convert
10080 some of the C<isl_ast_op_fdiv_q> operators to (expressions containing)
10081 C<isl_ast_op_pdiv_q> or C<isl_ast_op_pdiv_r> operators.
10083 =item * ast_build_detect_min_max
10085 If this option is turned on, then C<isl> will try and detect
10086 min or max-expressions when building AST expressions from
10087 piecewise affine expressions.
10089 =item * ast_build_exploit_nested_bounds
10091 Simplify conditions based on bounds of nested for loops.
10092 In particular, remove conditions that are implied by the fact
10093 that one or more nested loops have at least one iteration,
10094 meaning that the upper bound is at least as large as the lower bound.
10095 For example, when this option is turned off, AST generation
10098 [N,M] -> { A[i,j] -> [i,j] : 0 <= i <= N and
10104 for (int c0 = 0; c0 <= N; c0 += 1)
10105 for (int c1 = 0; c1 <= M; c1 += 1)
10108 When the option is turned on, the following AST is generated
10110 for (int c0 = 0; c0 <= N; c0 += 1)
10111 for (int c1 = 0; c1 <= M; c1 += 1)
10114 =item * ast_build_group_coscheduled
10116 If two domain elements are assigned the same schedule point, then
10117 they may be executed in any order and they may even appear in different
10118 loops. If this options is set, then the AST generator will make
10119 sure that coscheduled domain elements do not appear in separate parts
10120 of the AST. This is useful in case of nested AST generation
10121 if the outer AST generation is given only part of a schedule
10122 and the inner AST generation should handle the domains that are
10123 coscheduled by this initial part of the schedule together.
10124 For example if an AST is generated for a schedule
10126 { A[i] -> [0]; B[i] -> [0] }
10128 then the C<isl_ast_build_set_create_leaf> callback described
10129 below may get called twice, once for each domain.
10130 Setting this option ensures that the callback is only called once
10131 on both domains together.
10133 =item * ast_build_separation_bounds
10135 This option specifies which bounds to use during separation.
10136 If this option is set to C<ISL_AST_BUILD_SEPARATION_BOUNDS_IMPLICIT>
10137 then all (possibly implicit) bounds on the current dimension will
10138 be used during separation.
10139 If this option is set to C<ISL_AST_BUILD_SEPARATION_BOUNDS_EXPLICIT>
10140 then only those bounds that are explicitly available will
10141 be used during separation.
10143 =item * ast_build_scale_strides
10145 This option specifies whether the AST generator is allowed
10146 to scale down iterators of strided loops.
10148 =item * ast_build_allow_else
10150 This option specifies whether the AST generator is allowed
10151 to construct if statements with else branches.
10153 =item * ast_build_allow_or
10155 This option specifies whether the AST generator is allowed
10156 to construct if conditions with disjunctions.
10160 =head3 AST Generation Options (Schedule Tree)
10162 In case of AST construction from a schedule tree, the options
10163 that control how an AST is created from the individual schedule
10164 dimensions are stored in the band nodes of the tree
10165 (see L</"Schedule Trees">).
10167 In particular, a schedule dimension can be handled in four
10168 different ways, atomic, separate, unroll or the default.
10169 This loop AST generation type can be set using
10170 C<isl_schedule_node_band_member_set_ast_loop_type>.
10172 the first three can be selected by including a one-dimensional
10173 element with as value the position of the schedule dimension
10174 within the band and as name one of C<atomic>, C<separate>
10175 or C<unroll> in the options
10176 set by C<isl_schedule_node_band_set_ast_build_options>.
10177 Only one of these three may be specified for
10178 any given schedule dimension within a band node.
10179 If none of these is specified, then the default
10180 is used. The meaning of the options is as follows.
10186 When this option is specified, the AST generator will make
10187 sure that a given domains space only appears in a single
10188 loop at the specified level.
10190 For example, for the schedule tree
10192 domain: "{ a[i] : 0 <= i < 10; b[i] : 0 <= i < 10 }"
10194 schedule: "[{ a[i] -> [i]; b[i] -> [i+1] }]"
10195 options: "{ atomic[x] }"
10197 the following AST will be generated
10199 for (int c0 = 0; c0 <= 10; c0 += 1) {
10206 On the other hand, for the schedule tree
10208 domain: "{ a[i] : 0 <= i < 10; b[i] : 0 <= i < 10 }"
10210 schedule: "[{ a[i] -> [i]; b[i] -> [i+1] }]"
10211 options: "{ separate[x] }"
10213 the following AST will be generated
10217 for (int c0 = 1; c0 <= 9; c0 += 1) {
10224 If neither C<atomic> nor C<separate> is specified, then the AST generator
10225 may produce either of these two results or some intermediate form.
10229 When this option is specified, the AST generator will
10230 split the domain of the specified schedule dimension
10231 into pieces with a fixed set of statements for which
10232 instances need to be executed by the iterations in
10233 the schedule domain part. This option tends to avoid
10234 the generation of guards inside the corresponding loops.
10235 See also the C<atomic> option.
10239 When this option is specified, the AST generator will
10240 I<completely> unroll the corresponding schedule dimension.
10241 It is the responsibility of the user to ensure that such
10242 unrolling is possible.
10243 To obtain a partial unrolling, the user should apply an additional
10244 strip-mining to the schedule and fully unroll the inner schedule
10249 The C<isolate> option is a bit more involved. It allows the user
10250 to isolate a range of schedule dimension values from smaller and
10251 greater values. Additionally, the user may specify a different
10252 atomic/separate/unroll choice for the isolated part and the remaining
10253 parts. The typical use case of the C<isolate> option is to isolate
10254 full tiles from partial tiles.
10255 The part that needs to be isolated may depend on outer schedule dimensions.
10256 The option therefore needs to be able to reference those outer schedule
10257 dimensions. In particular, the space of the C<isolate> option is that
10258 of a wrapped map with as domain the flat product of all outer band nodes
10259 and as range the space of the current band node.
10260 The atomic/separate/unroll choice for the isolated part is determined
10261 by an option that lives in an unnamed wrapped space with as domain
10262 a zero-dimensional C<isolate> space and as range the regular
10263 C<atomic>, C<separate> or C<unroll> space.
10264 This option may also be set directly using
10265 C<isl_schedule_node_band_member_set_isolate_ast_loop_type>.
10266 The atomic/separate/unroll choice for the remaining part is determined
10267 by the regular C<atomic>, C<separate> or C<unroll> option.
10268 Since the C<isolate> option references outer schedule dimensions,
10269 its use in a band node causes any tree containing the node
10270 to be considered anchored.
10272 As an example, consider the isolation of full tiles from partial tiles
10273 in a tiling of a triangular domain. The original schedule is as follows.
10275 domain: "{ A[i,j] : 0 <= i,j and i + j <= 100 }"
10277 schedule: "[{ A[i,j] -> [floor(i/10)] }, \
10278 { A[i,j] -> [floor(j/10)] }, \
10279 { A[i,j] -> [i] }, { A[i,j] -> [j] }]"
10283 for (int c0 = 0; c0 <= 10; c0 += 1)
10284 for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
10285 for (int c2 = 10 * c0;
10286 c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
10287 for (int c3 = 10 * c1;
10288 c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
10291 Isolating the full tiles, we have the following input
10293 domain: "{ A[i,j] : 0 <= i,j and i + j <= 100 }"
10295 schedule: "[{ A[i,j] -> [floor(i/10)] }, \
10296 { A[i,j] -> [floor(j/10)] }, \
10297 { A[i,j] -> [i] }, { A[i,j] -> [j] }]"
10298 options: "{ isolate[[] -> [a,b,c,d]] : 0 <= 10a,10b and \
10299 10a+9+10b+9 <= 100 }"
10304 for (int c0 = 0; c0 <= 8; c0 += 1) {
10305 for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
10306 for (int c2 = 10 * c0;
10307 c2 <= 10 * c0 + 9; c2 += 1)
10308 for (int c3 = 10 * c1;
10309 c3 <= 10 * c1 + 9; c3 += 1)
10311 for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
10312 for (int c2 = 10 * c0;
10313 c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
10314 for (int c3 = 10 * c1;
10315 c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
10318 for (int c0 = 9; c0 <= 10; c0 += 1)
10319 for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
10320 for (int c2 = 10 * c0;
10321 c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
10322 for (int c3 = 10 * c1;
10323 c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
10327 We may then additionally unroll the innermost loop of the isolated part
10329 domain: "{ A[i,j] : 0 <= i,j and i + j <= 100 }"
10331 schedule: "[{ A[i,j] -> [floor(i/10)] }, \
10332 { A[i,j] -> [floor(j/10)] }, \
10333 { A[i,j] -> [i] }, { A[i,j] -> [j] }]"
10334 options: "{ isolate[[] -> [a,b,c,d]] : 0 <= 10a,10b and \
10335 10a+9+10b+9 <= 100; [isolate[] -> unroll[3]] }"
10340 for (int c0 = 0; c0 <= 8; c0 += 1) {
10341 for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
10342 for (int c2 = 10 * c0; c2 <= 10 * c0 + 9; c2 += 1) {
10344 A(c2, 10 * c1 + 1);
10345 A(c2, 10 * c1 + 2);
10346 A(c2, 10 * c1 + 3);
10347 A(c2, 10 * c1 + 4);
10348 A(c2, 10 * c1 + 5);
10349 A(c2, 10 * c1 + 6);
10350 A(c2, 10 * c1 + 7);
10351 A(c2, 10 * c1 + 8);
10352 A(c2, 10 * c1 + 9);
10354 for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
10355 for (int c2 = 10 * c0;
10356 c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
10357 for (int c3 = 10 * c1;
10358 c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
10361 for (int c0 = 9; c0 <= 10; c0 += 1)
10362 for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
10363 for (int c2 = 10 * c0;
10364 c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
10365 for (int c3 = 10 * c1;
10366 c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
10371 =head3 AST Generation Options (Schedule Map)
10373 In case of AST construction using
10374 C<isl_ast_build_node_from_schedule_map>, the options
10375 that control how an AST is created from the individual schedule
10376 dimensions are stored in the C<isl_ast_build>.
10377 They can be set using the following function.
10379 #include <isl/ast_build.h>
10380 __isl_give isl_ast_build *
10381 isl_ast_build_set_options(
10382 __isl_take isl_ast_build *control,
10383 __isl_take isl_union_map *options);
10385 The options are encoded in an C<isl_union_map>.
10386 The domain of this union relation refers to the schedule domain,
10387 i.e., the range of the schedule passed
10388 to C<isl_ast_build_node_from_schedule_map>.
10389 In the case of nested AST generation (see L</"Nested AST Generation">),
10390 the domain of C<options> should refer to the extra piece of the schedule.
10391 That is, it should be equal to the range of the wrapped relation in the
10392 range of the schedule.
10393 The range of the options can consist of elements in one or more spaces,
10394 the names of which determine the effect of the option.
10395 The values of the range typically also refer to the schedule dimension
10396 to which the option applies. In case of nested AST generation
10397 (see L</"Nested AST Generation">), these values refer to the position
10398 of the schedule dimension within the innermost AST generation.
10399 The constraints on the domain elements of
10400 the option should only refer to this dimension and earlier dimensions.
10401 We consider the following spaces.
10405 =item C<separation_class>
10407 B<This option has been deprecated. Use the isolate option on
10408 schedule trees instead.>
10410 This space is a wrapped relation between two one dimensional spaces.
10411 The input space represents the schedule dimension to which the option
10412 applies and the output space represents the separation class.
10413 While constructing a loop corresponding to the specified schedule
10414 dimension(s), the AST generator will try to generate separate loops
10415 for domain elements that are assigned different classes.
10416 If only some of the elements are assigned a class, then those elements
10417 that are not assigned any class will be treated as belonging to a class
10418 that is separate from the explicitly assigned classes.
10419 The typical use case for this option is to separate full tiles from
10421 The other options, described below, are applied after the separation
10424 As an example, consider the separation into full and partial tiles
10425 of a tiling of a triangular domain.
10426 Take, for example, the domain
10428 { A[i,j] : 0 <= i,j and i + j <= 100 }
10430 and a tiling into tiles of 10 by 10. The input to the AST generator
10431 is then the schedule
10433 { A[i,j] -> [([i/10]),[j/10],i,j] : 0 <= i,j and
10436 Without any options, the following AST is generated
10438 for (int c0 = 0; c0 <= 10; c0 += 1)
10439 for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
10440 for (int c2 = 10 * c0;
10441 c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
10443 for (int c3 = 10 * c1;
10444 c3 <= min(10 * c1 + 9, -c2 + 100);
10448 Separation into full and partial tiles can be obtained by assigning
10449 a class, say C<0>, to the full tiles. The full tiles are represented by those
10450 values of the first and second schedule dimensions for which there are
10451 values of the third and fourth dimensions to cover an entire tile.
10452 That is, we need to specify the following option
10454 { [a,b,c,d] -> separation_class[[0]->[0]] :
10455 exists b': 0 <= 10a,10b' and
10456 10a+9+10b'+9 <= 100;
10457 [a,b,c,d] -> separation_class[[1]->[0]] :
10458 0 <= 10a,10b and 10a+9+10b+9 <= 100 }
10460 which simplifies to
10462 { [a, b, c, d] -> separation_class[[1] -> [0]] :
10463 a >= 0 and b >= 0 and b <= 8 - a;
10464 [a, b, c, d] -> separation_class[[0] -> [0]] :
10465 a >= 0 and a <= 8 }
10467 With this option, the generated AST is as follows
10470 for (int c0 = 0; c0 <= 8; c0 += 1) {
10471 for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
10472 for (int c2 = 10 * c0;
10473 c2 <= 10 * c0 + 9; c2 += 1)
10474 for (int c3 = 10 * c1;
10475 c3 <= 10 * c1 + 9; c3 += 1)
10477 for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
10478 for (int c2 = 10 * c0;
10479 c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
10481 for (int c3 = 10 * c1;
10482 c3 <= min(-c2 + 100, 10 * c1 + 9);
10486 for (int c0 = 9; c0 <= 10; c0 += 1)
10487 for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
10488 for (int c2 = 10 * c0;
10489 c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
10491 for (int c3 = 10 * c1;
10492 c3 <= min(10 * c1 + 9, -c2 + 100);
10499 This is a single-dimensional space representing the schedule dimension(s)
10500 to which ``separation'' should be applied. Separation tries to split
10501 a loop into several pieces if this can avoid the generation of guards
10503 See also the C<atomic> option.
10507 This is a single-dimensional space representing the schedule dimension(s)
10508 for which the domains should be considered ``atomic''. That is, the
10509 AST generator will make sure that any given domain space will only appear
10510 in a single loop at the specified level.
10512 Consider the following schedule
10514 { a[i] -> [i] : 0 <= i < 10;
10515 b[i] -> [i+1] : 0 <= i < 10 }
10517 If the following option is specified
10519 { [i] -> separate[x] }
10521 then the following AST will be generated
10525 for (int c0 = 1; c0 <= 9; c0 += 1) {
10532 If, on the other hand, the following option is specified
10534 { [i] -> atomic[x] }
10536 then the following AST will be generated
10538 for (int c0 = 0; c0 <= 10; c0 += 1) {
10545 If neither C<atomic> nor C<separate> is specified, then the AST generator
10546 may produce either of these two results or some intermediate form.
10550 This is a single-dimensional space representing the schedule dimension(s)
10551 that should be I<completely> unrolled.
10552 To obtain a partial unrolling, the user should apply an additional
10553 strip-mining to the schedule and fully unroll the inner loop.
10557 =head3 Fine-grained Control over AST Generation
10559 Besides specifying the constraints on the parameters,
10560 an C<isl_ast_build> object can be used to control
10561 various aspects of the AST generation process.
10562 In case of AST construction using
10563 C<isl_ast_build_node_from_schedule_map>,
10564 the most prominent way of control is through ``options'',
10565 as explained above.
10567 Additional control is available through the following functions.
10569 #include <isl/ast_build.h>
10570 __isl_give isl_ast_build *
10571 isl_ast_build_set_iterators(
10572 __isl_take isl_ast_build *control,
10573 __isl_take isl_id_list *iterators);
10575 The function C<isl_ast_build_set_iterators> allows the user to
10576 specify a list of iterator C<isl_id>s to be used as iterators.
10577 If the input schedule is injective, then
10578 the number of elements in this list should be as large as the dimension
10579 of the schedule space, but no direct correspondence should be assumed
10580 between dimensions and elements.
10581 If the input schedule is not injective, then an additional number
10582 of C<isl_id>s equal to the largest dimension of the input domains
10584 If the number of provided C<isl_id>s is insufficient, then additional
10585 names are automatically generated.
10587 #include <isl/ast_build.h>
10588 __isl_give isl_ast_build *
10589 isl_ast_build_set_create_leaf(
10590 __isl_take isl_ast_build *control,
10591 __isl_give isl_ast_node *(*fn)(
10592 __isl_take isl_ast_build *build,
10593 void *user), void *user);
10596 C<isl_ast_build_set_create_leaf> function allows for the
10597 specification of a callback that should be called whenever the AST
10598 generator arrives at an element of the schedule domain.
10599 The callback should return an AST node that should be inserted
10600 at the corresponding position of the AST. The default action (when
10601 the callback is not set) is to continue generating parts of the AST to scan
10602 all the domain elements associated to the schedule domain element
10603 and to insert user nodes, ``calling'' the domain element, for each of them.
10604 The C<build> argument contains the current state of the C<isl_ast_build>.
10605 To ease nested AST generation (see L</"Nested AST Generation">),
10606 all control information that is
10607 specific to the current AST generation such as the options and
10608 the callbacks has been removed from this C<isl_ast_build>.
10609 The callback would typically return the result of a nested
10610 AST generation or a
10611 user defined node created using the following function.
10613 #include <isl/ast.h>
10614 __isl_give isl_ast_node *isl_ast_node_alloc_user(
10615 __isl_take isl_ast_expr *expr);
10617 #include <isl/ast_build.h>
10618 __isl_give isl_ast_build *
10619 isl_ast_build_set_at_each_domain(
10620 __isl_take isl_ast_build *build,
10621 __isl_give isl_ast_node *(*fn)(
10622 __isl_take isl_ast_node *node,
10623 __isl_keep isl_ast_build *build,
10624 void *user), void *user);
10625 __isl_give isl_ast_build *
10626 isl_ast_build_set_before_each_for(
10627 __isl_take isl_ast_build *build,
10628 __isl_give isl_id *(*fn)(
10629 __isl_keep isl_ast_build *build,
10630 void *user), void *user);
10631 __isl_give isl_ast_build *
10632 isl_ast_build_set_after_each_for(
10633 __isl_take isl_ast_build *build,
10634 __isl_give isl_ast_node *(*fn)(
10635 __isl_take isl_ast_node *node,
10636 __isl_keep isl_ast_build *build,
10637 void *user), void *user);
10638 __isl_give isl_ast_build *
10639 isl_ast_build_set_before_each_mark(
10640 __isl_take isl_ast_build *build,
10641 isl_stat (*fn)(__isl_keep isl_id *mark,
10642 __isl_keep isl_ast_build *build,
10643 void *user), void *user);
10644 __isl_give isl_ast_build *
10645 isl_ast_build_set_after_each_mark(
10646 __isl_take isl_ast_build *build,
10647 __isl_give isl_ast_node *(*fn)(
10648 __isl_take isl_ast_node *node,
10649 __isl_keep isl_ast_build *build,
10650 void *user), void *user);
10652 The callback set by C<isl_ast_build_set_at_each_domain> will
10653 be called for each domain AST node.
10654 The callbacks set by C<isl_ast_build_set_before_each_for>
10655 and C<isl_ast_build_set_after_each_for> will be called
10656 for each for AST node. The first will be called in depth-first
10657 pre-order, while the second will be called in depth-first post-order.
10658 Since C<isl_ast_build_set_before_each_for> is called before the for
10659 node is actually constructed, it is only passed an C<isl_ast_build>.
10660 The returned C<isl_id> will be added as an annotation (using
10661 C<isl_ast_node_set_annotation>) to the constructed for node.
10662 In particular, if the user has also specified an C<after_each_for>
10663 callback, then the annotation can be retrieved from the node passed to
10664 that callback using C<isl_ast_node_get_annotation>.
10665 The callbacks set by C<isl_ast_build_set_before_each_mark>
10666 and C<isl_ast_build_set_after_each_mark> will be called for each
10667 mark AST node that is created, i.e., for each mark schedule node
10668 in the input schedule tree. The first will be called in depth-first
10669 pre-order, while the second will be called in depth-first post-order.
10670 Since the callback set by C<isl_ast_build_set_before_each_mark>
10671 is called before the mark AST node is actually constructed, it is passed
10672 the identifier of the mark node.
10673 All callbacks should C<NULL> (or -1) on failure.
10674 The given C<isl_ast_build> can be used to create new
10675 C<isl_ast_expr> objects using C<isl_ast_build_expr_from_pw_aff>
10676 or C<isl_ast_build_call_from_pw_multi_aff>.
10678 =head3 Nested AST Generation
10680 C<isl> allows the user to create an AST within the context
10681 of another AST. These nested ASTs are created using the
10682 same C<isl_ast_build_node_from_schedule_map> function that is used to create
10683 the outer AST. The C<build> argument should be an C<isl_ast_build>
10684 passed to a callback set by
10685 C<isl_ast_build_set_create_leaf>.
10686 The space of the range of the C<schedule> argument should refer
10687 to this build. In particular, the space should be a wrapped
10688 relation and the domain of this wrapped relation should be the
10689 same as that of the range of the schedule returned by
10690 C<isl_ast_build_get_schedule> below.
10691 In practice, the new schedule is typically
10692 created by calling C<isl_union_map_range_product> on the old schedule
10693 and some extra piece of the schedule.
10694 The space of the schedule domain is also available from
10695 the C<isl_ast_build>.
10697 #include <isl/ast_build.h>
10698 __isl_give isl_union_map *isl_ast_build_get_schedule(
10699 __isl_keep isl_ast_build *build);
10700 __isl_give isl_space *isl_ast_build_get_schedule_space(
10701 __isl_keep isl_ast_build *build);
10702 __isl_give isl_ast_build *isl_ast_build_restrict(
10703 __isl_take isl_ast_build *build,
10704 __isl_take isl_set *set);
10706 The C<isl_ast_build_get_schedule> function returns a (partial)
10707 schedule for the domains elements for which part of the AST still needs to
10708 be generated in the current build.
10709 In particular, the domain elements are mapped to those iterations of the loops
10710 enclosing the current point of the AST generation inside which
10711 the domain elements are executed.
10712 No direct correspondence between
10713 the input schedule and this schedule should be assumed.
10714 The space obtained from C<isl_ast_build_get_schedule_space> can be used
10715 to create a set for C<isl_ast_build_restrict> to intersect
10716 with the current build. In particular, the set passed to
10717 C<isl_ast_build_restrict> can have additional parameters.
10718 The ids of the set dimensions in the space returned by
10719 C<isl_ast_build_get_schedule_space> correspond to the
10720 iterators of the already generated loops.
10721 The user should not rely on the ids of the output dimensions
10722 of the relations in the union relation returned by
10723 C<isl_ast_build_get_schedule> having any particular value.
10725 =head1 Applications
10727 Although C<isl> is mainly meant to be used as a library,
10728 it also contains some basic applications that use some
10729 of the functionality of C<isl>.
10730 For applications that take one or more polytopes or polyhedra
10731 as input, this input may be specified in either the L<isl format>
10732 or the L<PolyLib format>.
10734 =head2 C<isl_polyhedron_sample>
10736 C<isl_polyhedron_sample> takes a polyhedron as input and prints
10737 an integer element of the polyhedron, if there is any.
10738 The first column in the output is the denominator and is always
10739 equal to 1. If the polyhedron contains no integer points,
10740 then a vector of length zero is printed.
10744 C<isl_pip> takes the same input as the C<example> program
10745 from the C<piplib> distribution, i.e., a set of constraints
10746 on the parameters, a line containing only -1 and finally a set
10747 of constraints on a parametric polyhedron.
10748 The coefficients of the parameters appear in the last columns
10749 (but before the final constant column).
10750 The output is the lexicographic minimum of the parametric polyhedron.
10751 As C<isl> currently does not have its own output format, the output
10752 is just a dump of the internal state.
10754 =head2 C<isl_polyhedron_minimize>
10756 C<isl_polyhedron_minimize> computes the minimum of some linear
10757 or affine objective function over the integer points in a polyhedron.
10758 If an affine objective function
10759 is given, then the constant should appear in the last column.
10761 =head2 C<isl_polytope_scan>
10763 Given a polytope, C<isl_polytope_scan> prints
10764 all integer points in the polytope.
10766 =head2 C<isl_codegen>
10768 Given either a schedule tree or a sequence consisting of
10769 a schedule map, a context set and an options relation,
10770 C<isl_codegen> prints out an AST that scans the domain elements
10771 of the schedule in the order of their image(s) taking into account
10772 the constraints in the context set.
10774 =head2 C<isl_schedule>
10776 Given an C<isl_schedule_constraints> object as input,
10777 C<isl_schedule> prints out a schedule that satisfies the given