13047 lines · plain
1=head1 Introduction2 3C<isl> is a thread-safe C library for manipulating4sets and relations of integer points bounded by affine constraints.5The descriptions of the sets and relations may involve6both parameters and existentially quantified variables.7All computations are performed in exact integer arithmetic8using C<GMP> or C<imath>.9The C<isl> library offers functionality that is similar10to that offered by the C<Omega> and C<Omega+> libraries,11but the underlying algorithms are in most cases completely different.12 13The library is by no means complete and some fairly basic14functionality is still missing.15Still, even in its current form, the library has been successfully16used as a backend polyhedral library for the polyhedral17scanner C<CLooG> and as part of an equivalence checker of18static affine programs.19For bug reports, feature requests and questions,20visit the discussion group at21L<http://groups.google.com/group/isl-development>.22 23=head2 Backward Incompatible Changes24 25=head3 Changes since isl-0.0226 27=over28 29=item * The old printing functions have been deprecated30and replaced by C<isl_printer> functions, see L<Input and Output>.31 32=item * Most functions related to dependence analysis have acquired33an extra C<must> argument. To obtain the old behavior, this argument34should be given the value 1. See L<Dependence Analysis>.35 36=back37 38=head3 Changes since isl-0.0339 40=over41 42=item * The function C<isl_pw_qpolynomial_fold_add> has been43renamed to C<isl_pw_qpolynomial_fold_fold>.44Similarly, C<isl_union_pw_qpolynomial_fold_add> has been45renamed to C<isl_union_pw_qpolynomial_fold_fold>.46 47=back48 49=head3 Changes since isl-0.0450 51=over52 53=item * All header files have been renamed from C<isl_header.h>54to C<isl/header.h>.55 56=back57 58=head3 Changes since isl-0.0559 60=over61 62=item * The functions C<isl_printer_print_basic_set> and63C<isl_printer_print_basic_map> no longer print a newline.64 65=item * The functions C<isl_flow_get_no_source>66and C<isl_union_map_compute_flow> now return67the accesses for which no source could be found instead of68the iterations where those accesses occur.69 70=item * The functions C<isl_basic_map_identity> and71C<isl_map_identity> now take a B<map> space as input. An old call72C<isl_map_identity(space)> can be rewritten to73C<isl_map_identity(isl_space_map_from_set(space))>.74 75=item * The function C<isl_map_power> no longer takes76a parameter position as input. Instead, the exponent77is now expressed as the domain of the resulting relation.78 79=back80 81=head3 Changes since isl-0.0682 83=over84 85=item * The format of C<isl_printer_print_qpolynomial>'s86C<ISL_FORMAT_ISL> output has changed.87Use C<ISL_FORMAT_C> to obtain the old output.88 89=item * The C<*_fast_*> functions have been renamed to C<*_plain_*>.90Some of the old names have been kept for backward compatibility,91but they will be removed in the future.92 93=back94 95=head3 Changes since isl-0.0796 97=over98 99=item * The function C<isl_pw_aff_max> has been renamed to100C<isl_pw_aff_union_max>.101Similarly, the function C<isl_pw_aff_add> has been renamed to102C<isl_pw_aff_union_add>.103 104=item * The C<isl_dim> type has been renamed to C<isl_space>105along with the associated functions.106Some of the old names have been kept for backward compatibility,107but they will be removed in the future.108 109=item * Spaces of maps, sets and parameter domains are now110treated differently. The distinction between map spaces and set spaces111has always been made on a conceptual level, but proper use of such spaces112was never checked. Furthermore, up until isl-0.07 there was no way113of explicitly creating a parameter space. These can now be created114directly using C<isl_space_params_alloc> or from other spaces using115C<isl_space_params>.116 117=item * The space in which C<isl_aff>, C<isl_pw_aff>, C<isl_qpolynomial>,118C<isl_pw_qpolynomial>, C<isl_qpolynomial_fold> and C<isl_pw_qpolynomial_fold>119objects live is now a map space120instead of a set space. This means, for example, that the dimensions121of the domain of an C<isl_aff> are now considered to be of type122C<isl_dim_in> instead of C<isl_dim_set>. Extra functions have been123added to obtain the domain space. Some of the constructors still124take a domain space and have therefore been renamed.125 126=item * The functions C<isl_equality_alloc> and C<isl_inequality_alloc>127now take an C<isl_local_space> instead of an C<isl_space>.128An C<isl_local_space> can be created from an C<isl_space>129using C<isl_local_space_from_space>.130 131=item * The C<isl_div> type has been removed. Functions that used132to return an C<isl_div> now return an C<isl_aff>.133Note that the space of an C<isl_aff> is that of relation.134When replacing a call to C<isl_div_get_coefficient> by a call to135C<isl_aff_get_coefficient> any C<isl_dim_set> argument needs136to be replaced by C<isl_dim_in>.137A call to C<isl_aff_from_div> can be replaced by a call138to C<isl_aff_floor>.139A call to C<isl_qpolynomial_div(div)> call be replaced by140the nested call141 142 isl_qpolynomial_from_aff(isl_aff_floor(div))143 144The function C<isl_constraint_div> has also been renamed145to C<isl_constraint_get_div>.146 147=item * The C<nparam> argument has been removed from148C<isl_map_read_from_str> and similar functions.149When reading input in the original PolyLib format,150the result will have no parameters.151If parameters are expected, the caller may want to perform152dimension manipulation on the result.153 154=back155 156=head3 Changes since isl-0.09157 158=over159 160=item * The C<schedule_split_parallel> option has been replaced161by the C<schedule_split_scaled> option.162 163=item * The first argument of C<isl_pw_aff_cond> is now164an C<isl_pw_aff> instead of an C<isl_set>.165A call C<isl_pw_aff_cond(a, b, c)> can be replaced by166 167 isl_pw_aff_cond(isl_set_indicator_function(a), b, c)168 169=back170 171=head3 Changes since isl-0.10172 173=over174 175=item * The functions C<isl_set_dim_has_lower_bound> and176C<isl_set_dim_has_upper_bound> have been renamed to177C<isl_set_dim_has_any_lower_bound> and178C<isl_set_dim_has_any_upper_bound>.179The new C<isl_set_dim_has_lower_bound> and180C<isl_set_dim_has_upper_bound> have slightly different meanings.181 182=back183 184=head3 Changes since isl-0.12185 186=over187 188=item * C<isl_int> has been replaced by C<isl_val>.189Some of the old functions are still available in C<isl/deprecated/*.h>190but they will be removed in the future.191 192=item * The functions C<isl_pw_qpolynomial_eval>,193C<isl_union_pw_qpolynomial_eval>, C<isl_pw_qpolynomial_fold_eval>194and C<isl_union_pw_qpolynomial_fold_eval> have been changed to return195an C<isl_val> instead of an C<isl_qpolynomial>.196 197=item * The function C<isl_band_member_is_zero_distance>198has been removed. Essentially the same functionality is available199through C<isl_band_member_is_coincident>, except that it requires200setting up coincidence constraints.201The option C<schedule_outer_zero_distance> has accordingly been202replaced by the option C<schedule_outer_coincidence>.203 204=item * The function C<isl_vertex_get_expr> has been changed205to return an C<isl_multi_aff> instead of a rational C<isl_basic_set>.206The function C<isl_vertex_get_domain> has been changed to return207a regular basic set, rather than a rational basic set.208 209=back210 211=head3 Changes since isl-0.14212 213=over214 215=item * The function C<isl_union_pw_multi_aff_add> now consistently216computes the sum on the shared definition domain.217The function C<isl_union_pw_multi_aff_union_add> has been added218to compute the sum on the union of definition domains.219The original behavior of C<isl_union_pw_multi_aff_add> was220confused and is no longer available.221 222=item * Band forests have been replaced by schedule trees.223 224=item * The function C<isl_union_map_compute_flow> has been225replaced by the function C<isl_union_access_info_compute_flow>.226Note that the may dependence relation returned by227C<isl_union_flow_get_may_dependence> is the union of228the two dependence relations returned by229C<isl_union_map_compute_flow>. Similarly for the no source relations.230The function C<isl_union_map_compute_flow> is still available231for backward compatibility, but it will be removed in the future.232 233=item * The function C<isl_basic_set_drop_constraint> has been234deprecated.235 236=item * The function C<isl_ast_build_ast_from_schedule> has been237renamed to C<isl_ast_build_node_from_schedule_map>.238The original name is still available239for backward compatibility, but it will be removed in the future.240 241=item * The C<separation_class> AST generation option has been242deprecated.243 244=item * The functions C<isl_equality_alloc> and C<isl_inequality_alloc>245have been renamed to C<isl_constraint_alloc_equality> and246C<isl_constraint_alloc_inequality>. The original names have been247kept for backward compatibility, but they will be removed in the future.248 249=item * The C<schedule_fuse> option has been replaced250by the C<schedule_serialize_sccs> option. The effect251of setting the C<schedule_fuse> option to C<ISL_SCHEDULE_FUSE_MIN>252is now obtained by turning on the C<schedule_serialize_sccs> option.253 254=back255 256=head3 Changes since isl-0.17257 258=over259 260=item * The function C<isl_printer_print_ast_expr> no longer prints261in C format by default. To print in C format, the output format262of the printer needs to have been explicitly set to C<ISL_FORMAT_C>.263As a result, the function C<isl_ast_expr_to_str> no longer prints264the expression in C format. Use C<isl_ast_expr_to_C_str> instead.265 266=item * The functions C<isl_set_align_divs> and C<isl_map_align_divs>267have been deprecated. The function C<isl_set_lift> has an effect268that is similar to C<isl_set_align_divs> and could in some cases269be used as an alternative.270 271=back272 273=head3 Changes since isl-0.19274 275=over276 277=item * Zero-dimensional objects of type C<isl_multi_pw_aff> or278C<isl_multi_union_pw_aff> can now keep track of an explicit domain.279This explicit domain, if present, is taken into account280by various operations that take such objects as input.281 282=back283 284=head3 Changes since isl-0.20285 286=over287 288=item * Several functions that used to return C<unsigned>289now return C<isl_size>. This means that these functions may290now return a negative value in case an error occurred.291The same holds for functions that used to return C<int>,292although some of those were already returning293a negative value in case of error.294 295=item * The C<isl_ast_op_type> enumeration type has been296renamed to C<isl_ast_expr_op_type>. The corresponding297enumeration constants have been similarly renamed.298The old names are defined to the new names for backward299compatibility.300 301=item * Several functions returning an extra boolean value302through an C<int *> argument now do so through an C<isl_bool *>303argument. The returned values are the same, only the type304of the pointer has been changed.305 306=back307 308=head1 License309 310C<isl> is released under the MIT license.311 312=over313 314Permission is hereby granted, free of charge, to any person obtaining a copy of315this software and associated documentation files (the "Software"), to deal in316the Software without restriction, including without limitation the rights to317use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies318of the Software, and to permit persons to whom the Software is furnished to do319so, subject to the following conditions:320 321The above copyright notice and this permission notice shall be included in all322copies or substantial portions of the Software.323 324THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR325IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,326FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE327AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER328LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,329OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE330SOFTWARE.331 332=back333 334Note that by default C<isl> requires C<GMP>, which is released335under the GNU Lesser General Public License (LGPL). This means336that code linked against C<isl> is also linked against LGPL code.337 338When configuring with C<--with-int=imath> or C<--with-int=imath-32>, C<isl>339will link against C<imath>, a library for exact integer arithmetic released340under the MIT license.341 342=head1 Installation343 344The source of C<isl> can be obtained either as a tarball345or from the git repository. Both are available from346L<https://libisl.sourceforge.io/>.347The installation process depends on how you obtained348the source.349 350=head2 Installation from the git repository351 352=over353 354=item 1 Clone or update the repository355 356The first time the source is obtained, you need to clone357the repository.358 359 git clone git://repo.or.cz/isl.git360 361To obtain updates, you need to pull in the latest changes362 363 git pull364 365=item 2 Optionally get C<imath> submodule366 367To build C<isl> with C<imath>, you need to obtain the C<imath>368submodule by running in the git source tree of C<isl>369 370 git submodule init371 git submodule update372 373This will fetch the required version of C<imath> in a subdirectory of C<isl>.374 375=item 2 Generate C<configure>376 377 ./autogen.sh378 379=back380 381After performing the above steps, continue382with the L<Common installation instructions>.383 384=head2 Common installation instructions385 386=over387 388=item 1 Obtain C<GMP>389 390By default, building C<isl> requires C<GMP>, including its headers files.391Your distribution may not provide these header files by default392and you may need to install a package called C<gmp-devel> or something393similar. Alternatively, C<GMP> can be built from394source, available from L<http://gmplib.org/>.395C<GMP> is not needed if you build C<isl> with C<imath>.396 397=item 2 Configure398 399C<isl> uses the standard C<autoconf> C<configure> script.400To run it, just type401 402 ./configure403 404optionally followed by some configure options.405A complete list of options can be obtained by running406 407 ./configure --help408 409Below we discuss some of the more common options.410 411=over412 413=item C<--prefix>414 415Installation prefix for C<isl>416 417=item C<--with-int=[gmp|imath|imath-32]>418 419Select the integer library to be used by C<isl>, the default is C<gmp>.420With C<imath-32>, C<isl> will use 32 bit integers, but fall back to C<imath>421for values out of the 32 bit range. In most applications, C<isl> will run422fastest with the C<imath-32> option, followed by C<gmp> and C<imath>, the423slowest.424 425=item C<--with-gmp-prefix=>I<path>426 427Installation prefix for C<GMP> (architecture-independent files).428 429=item C<--with-gmp-exec-prefix=>I<path>430 431Installation prefix for C<GMP> (architecture-dependent files).432 433=back434 435=item 3 Compile436 437 make438 439=item 4 Test (optional)440 441 make check442 443=item 5 Install (optional)444 445 make install446 447=back448 449=head2 Building the foreign language bindings450 451The tarball already contains the generated foreign language bindings,452but they are not included in the git repository.453Building the C++ and Python bindings relies on the LLVM/clang libraries,454see C<http://clang.llvm.org/get_started.html>.455The C<configure> script will not assume that these are available456on the system.457To enable building the foreign language bindings,458one of the following options needs to be specified.459 460=over461 462=item C<--with-clang=system>463 464Use the system clang libraries (installed in a default location).465 466=item C<--with-clang-prefix=>I<path>467 468Use the system clang libraries installed in I<path>.469 470=back471 472It is best to use the latest release of the clang libraries (14.0),473although any release since 2.9 should work as well.474Note that if you build the clang libraries from source,475then you need to make sure they are also installed (using C<make install>).476If the compiler that was used to compile the clang libraries477is different from the default C++ compiler, then use C<CXX_FOR_BUILD>478to specify this non-default C++ compiler when running C<isl>'s C<./configure>.479 480=head1 Integer Set Library481 482=head2 Memory Management483 484Since a high-level operation on isl objects usually involves485several substeps and since the user is usually not interested in486the intermediate results, most functions that return a new object487will also release all the objects passed as arguments.488If the user still wants to use one or more of these arguments489after the function call, she should pass along a copy of the490object rather than the object itself.491The user is then responsible for making sure that the original492object gets used somewhere else or is explicitly freed.493 494The arguments and return values of all documented functions are495annotated to make clear which arguments are released and which496arguments are preserved. In particular, the following annotations497are used498 499=over500 501=item C<__isl_give>502 503C<__isl_give> means that a new object is returned.504The user should make sure that the returned pointer is505used exactly once as a value for an C<__isl_take> argument.506In between, it can be used as a value for as many507C<__isl_keep> arguments as the user likes.508There is one exception, and that is the case where the509pointer returned is C<NULL>. In this case, the user510is free to use it as an C<__isl_take> argument or not.511When applied to a C<char *>, the returned pointer needs to be512freed using C<free>.513 514=item C<__isl_null>515 516C<__isl_null> means that a C<NULL> value is returned.517 518=item C<__isl_take>519 520C<__isl_take> means that the object the argument points to521is taken over by the function and may no longer be used522by the user as an argument to any other function.523The pointer value must be one returned by a function524returning an C<__isl_give> pointer.525If the user passes in a C<NULL> value, then this will526be treated as an error in the sense that the function will527not perform its usual operation. However, it will still528make sure that all the other C<__isl_take> arguments529are released.530 531=item C<__isl_keep>532 533C<__isl_keep> means that the function will only use the object534temporarily. After the function has finished, the user535can still use it as an argument to other functions.536A C<NULL> value will be treated in the same way as537a C<NULL> value for an C<__isl_take> argument.538This annotation may also be used on return values of539type C<const char *>, in which case the returned pointer should540not be freed by the user and is only valid until the object541from which it was derived is updated or freed.542 543=back544 545=head2 Initialization546 547All manipulations of integer sets and relations occur within548the context of an C<isl_ctx>.549A given C<isl_ctx> can only be used within a single thread.550All arguments of a function are required to have been allocated551within the same context.552There are currently no functions available for moving an object553from one C<isl_ctx> to another C<isl_ctx>. This means that554there is currently no way of safely moving an object from one555thread to another, unless the whole C<isl_ctx> is moved.556 557An C<isl_ctx> can be allocated using C<isl_ctx_alloc> and558freed using C<isl_ctx_free>.559All objects allocated within an C<isl_ctx> should be freed560before the C<isl_ctx> itself is freed.561 562 isl_ctx *isl_ctx_alloc();563 void isl_ctx_free(isl_ctx *ctx);564 565The user can impose a bound on the number of low-level I<operations>566that can be performed by an C<isl_ctx>. This bound can be set and567retrieved using the following functions. A bound of zero means that568no bound is imposed. The number of operations performed can be569reset using C<isl_ctx_reset_operations>. Note that the number570of low-level operations needed to perform a high-level computation571may differ significantly across different versions572of C<isl>, but it should be the same across different platforms573for the same version of C<isl>.574 575Warning: This feature is experimental. C<isl> has good support to abort and576bail out during the computation, but this feature may exercise error code paths577that are normally not used that much. Consequently, it is not unlikely that578hidden bugs will be exposed.579 580 void isl_ctx_set_max_operations(isl_ctx *ctx,581 unsigned long max_operations);582 unsigned long isl_ctx_get_max_operations(isl_ctx *ctx);583 void isl_ctx_reset_operations(isl_ctx *ctx);584 585In order to be able to create an object in the same context586as another object, most object types (described later in587this document) provide a function to obtain the context588in which the object was created.589 590 #include <isl/val.h>591 isl_ctx *isl_val_get_ctx(__isl_keep isl_val *val);592 isl_ctx *isl_multi_val_get_ctx(593 __isl_keep isl_multi_val *mv);594 595 #include <isl/id.h>596 isl_ctx *isl_id_get_ctx(__isl_keep isl_id *id);597 isl_ctx *isl_multi_id_get_ctx(598 __isl_keep isl_multi_id *mi);599 600 #include <isl/local_space.h>601 isl_ctx *isl_local_space_get_ctx(602 __isl_keep isl_local_space *ls);603 604 #include <isl/set.h>605 isl_ctx *isl_set_list_get_ctx(606 __isl_keep isl_set_list *list);607 608 #include <isl/aff.h>609 isl_ctx *isl_aff_get_ctx(__isl_keep isl_aff *aff);610 isl_ctx *isl_multi_aff_get_ctx(611 __isl_keep isl_multi_aff *maff);612 isl_ctx *isl_pw_aff_get_ctx(__isl_keep isl_pw_aff *pa);613 isl_ctx *isl_pw_multi_aff_get_ctx(614 __isl_keep isl_pw_multi_aff *pma);615 isl_ctx *isl_multi_pw_aff_get_ctx(616 __isl_keep isl_multi_pw_aff *mpa);617 isl_ctx *isl_union_pw_aff_get_ctx(618 __isl_keep isl_union_pw_aff *upa);619 isl_ctx *isl_union_pw_multi_aff_get_ctx(620 __isl_keep isl_union_pw_multi_aff *upma);621 isl_ctx *isl_multi_union_pw_aff_get_ctx(622 __isl_keep isl_multi_union_pw_aff *mupa);623 624 #include <isl/id_to_ast_expr.h>625 isl_ctx *isl_id_to_ast_expr_get_ctx(626 __isl_keep isl_id_to_ast_expr *id2expr);627 628 #include <isl/point.h>629 isl_ctx *isl_point_get_ctx(__isl_keep isl_point *pnt);630 631 #include <isl/vec.h>632 isl_ctx *isl_vec_get_ctx(__isl_keep isl_vec *vec);633 634 #include <isl/mat.h>635 isl_ctx *isl_mat_get_ctx(__isl_keep isl_mat *mat);636 637 #include <isl/vertices.h>638 isl_ctx *isl_vertices_get_ctx(639 __isl_keep isl_vertices *vertices);640 isl_ctx *isl_vertex_get_ctx(__isl_keep isl_vertex *vertex);641 isl_ctx *isl_cell_get_ctx(__isl_keep isl_cell *cell);642 643 #include <isl/flow.h>644 isl_ctx *isl_restriction_get_ctx(645 __isl_keep isl_restriction *restr);646 isl_ctx *isl_union_access_info_get_ctx(647 __isl_keep isl_union_access_info *access);648 isl_ctx *isl_union_flow_get_ctx(649 __isl_keep isl_union_flow *flow);650 651 #include <isl/schedule.h>652 isl_ctx *isl_schedule_get_ctx(653 __isl_keep isl_schedule *sched);654 isl_ctx *isl_schedule_constraints_get_ctx(655 __isl_keep isl_schedule_constraints *sc);656 657 #include <isl/schedule_node.h>658 isl_ctx *isl_schedule_node_get_ctx(659 __isl_keep isl_schedule_node *node);660 661 #include <isl/ast_build.h>662 isl_ctx *isl_ast_build_get_ctx(663 __isl_keep isl_ast_build *build);664 665 #include <isl/ast.h>666 isl_ctx *isl_ast_expr_get_ctx(667 __isl_keep isl_ast_expr *expr);668 isl_ctx *isl_ast_node_get_ctx(669 __isl_keep isl_ast_node *node);670 671 #include <isl/stride_info.h>672 isl_ctx *isl_stride_info_get_ctx(673 __isl_keep isl_stride_info *si);674 675 #include <isl/fixed_box.h>676 isl_ctx *isl_fixed_box_get_ctx(677 __isl_keep isl_fixed_box *box);678 679=head2 Return Types680 681C<isl> uses the special return type C<isl_size> for functions682that return a non-negative value, typically a number or a position.683Besides the regular non-negative return values, a special (negative)684value C<isl_size_error> may be returned, indicating that something685went wrong.686 687C<isl> also uses two special return types for functions that either return688a boolean or that in principle do not return anything.689In particular, the C<isl_bool> type has three possible values:690C<isl_bool_true> (a positive integer value), indicating I<true> or I<yes>;691C<isl_bool_false> (the integer value zero), indicating I<false> or I<no>; and692C<isl_bool_error> (a negative integer value), indicating that something693went wrong. The following operations are defined on C<isl_bool>. The function694C<isl_bool_not> can be used to negate an C<isl_bool>, where the negation of695C<isl_bool_error> is C<isl_bool_error> again. The function C<isl_bool_ok>696converts an integer to an C<isl_bool>. Any non-zero values yields697C<isl_bool_true> and zero yields C<isl_bool_false>.698 699 #include <isl/ctx.h>700 isl_bool isl_bool_not(isl_bool b);701 isl_bool isl_bool_ok(int b);702 703The C<isl_stat> type has two possible values:704C<isl_stat_ok> (the integer value zero), indicating a successful705operation; and706C<isl_stat_error> (a negative integer value), indicating that something707went wrong.708The function C<isl_stat_non_null> converts an isl object pointer709to an C<isl_stat>, returning C<isl_stat_ok> if the object pointer is valid and710C<isl_stat_error> if it is C<NULL>.711 712 #include <isl/ctx.h>713 isl_stat isl_stat_non_null(void *obj);714 715See L</"Error Handling"> for more information on716C<isl_size_error>, C<isl_bool_error> and C<isl_stat_error>.717 718=head2 Values719 720An C<isl_val> represents an integer value, a rational value721or one of three special values, infinity, negative infinity and NaN.722Some predefined values can be created using the following functions.723 724 #include <isl/val.h>725 __isl_give isl_val *isl_val_zero(isl_ctx *ctx);726 __isl_give isl_val *isl_val_one(isl_ctx *ctx);727 __isl_give isl_val *isl_val_negone(isl_ctx *ctx);728 __isl_give isl_val *isl_val_nan(isl_ctx *ctx);729 __isl_give isl_val *isl_val_infty(isl_ctx *ctx);730 __isl_give isl_val *isl_val_neginfty(isl_ctx *ctx);731 732Specific integer values can be created using the following functions.733 734 #include <isl/val.h>735 __isl_give isl_val *isl_val_int_from_si(isl_ctx *ctx,736 long i);737 __isl_give isl_val *isl_val_int_from_ui(isl_ctx *ctx,738 unsigned long u);739 __isl_give isl_val *isl_val_int_from_chunks(isl_ctx *ctx,740 size_t n, size_t size, const void *chunks);741 742The function C<isl_val_int_from_chunks> constructs an C<isl_val>743from the C<n> I<digits>, each consisting of C<size> bytes, stored at C<chunks>.744The least significant digit is assumed to be stored first.745 746Value objects can be copied and freed using the following functions.747 748 #include <isl/val.h>749 __isl_give isl_val *isl_val_copy(__isl_keep isl_val *v);750 __isl_null isl_val *isl_val_free(__isl_take isl_val *v);751 752They can be inspected using the following functions.753 754 #include <isl/val.h>755 long isl_val_get_num_si(__isl_keep isl_val *v);756 long isl_val_get_den_si(__isl_keep isl_val *v);757 __isl_give isl_val *isl_val_get_den_val(758 __isl_keep isl_val *v);759 double isl_val_get_d(__isl_keep isl_val *v);760 isl_size isl_val_n_abs_num_chunks(__isl_keep isl_val *v,761 size_t size);762 isl_stat isl_val_get_abs_num_chunks(__isl_keep isl_val *v,763 size_t size, void *chunks);764 765C<isl_val_n_abs_num_chunks> returns the number of I<digits>766of C<size> bytes needed to store the absolute value of the767numerator of C<v>.768C<isl_val_get_abs_num_chunks> stores these digits at C<chunks>,769which is assumed to have been preallocated by the caller.770The least significant digit is stored first.771Note that C<isl_val_get_num_si>, C<isl_val_get_den_si>,772C<isl_val_get_d>, C<isl_val_n_abs_num_chunks>773and C<isl_val_get_abs_num_chunks> can only be applied to rational values.774 775An C<isl_val> can be modified using the following function.776 777 #include <isl/val.h>778 __isl_give isl_val *isl_val_set_si(__isl_take isl_val *v,779 long i);780 781The following unary properties are defined on C<isl_val>s.782 783 #include <isl/val.h>784 int isl_val_sgn(__isl_keep isl_val *v);785 isl_bool isl_val_is_zero(__isl_keep isl_val *v);786 isl_bool isl_val_is_one(__isl_keep isl_val *v);787 isl_bool isl_val_is_negone(__isl_keep isl_val *v);788 isl_bool isl_val_is_nonneg(__isl_keep isl_val *v);789 isl_bool isl_val_is_nonpos(__isl_keep isl_val *v);790 isl_bool isl_val_is_pos(__isl_keep isl_val *v);791 isl_bool isl_val_is_neg(__isl_keep isl_val *v);792 isl_bool isl_val_is_int(__isl_keep isl_val *v);793 isl_bool isl_val_is_rat(__isl_keep isl_val *v);794 isl_bool isl_val_is_nan(__isl_keep isl_val *v);795 isl_bool isl_val_is_infty(__isl_keep isl_val *v);796 isl_bool isl_val_is_neginfty(__isl_keep isl_val *v);797 798Note that the sign of NaN is undefined.799 800The following binary properties are defined on pairs of C<isl_val>s.801 802 #include <isl/val.h>803 isl_bool isl_val_lt(__isl_keep isl_val *v1,804 __isl_keep isl_val *v2);805 isl_bool isl_val_le(__isl_keep isl_val *v1,806 __isl_keep isl_val *v2);807 isl_bool isl_val_gt(__isl_keep isl_val *v1,808 __isl_keep isl_val *v2);809 isl_bool isl_val_ge(__isl_keep isl_val *v1,810 __isl_keep isl_val *v2);811 isl_bool isl_val_eq(__isl_keep isl_val *v1,812 __isl_keep isl_val *v2);813 isl_bool isl_val_ne(__isl_keep isl_val *v1,814 __isl_keep isl_val *v2);815 isl_bool isl_val_abs_eq(__isl_keep isl_val *v1,816 __isl_keep isl_val *v2);817 818Comparisons to NaN always return false.819That is, a NaN is not considered to hold any relative position820with respect to any value. In particular, a NaN821is neither considered to be equal to nor to be different from822any value (including another NaN).823The function C<isl_val_abs_eq> checks whether its two arguments824are equal in absolute value.825 826For integer C<isl_val>s we additionally have the following binary property.827 828 #include <isl/val.h>829 isl_bool isl_val_is_divisible_by(__isl_keep isl_val *v1,830 __isl_keep isl_val *v2);831 832An C<isl_val> can also be compared to an integer using the following833functions. The result of C<isl_val_cmp_si> is undefined for NaN.834 835 #include <isl/val.h>836 isl_bool isl_val_gt_si(__isl_keep isl_val *v, long i);837 isl_bool isl_val_eq_si(__isl_keep isl_val *v, long i);838 int isl_val_cmp_si(__isl_keep isl_val *v, long i);839 840The following unary operations are available on C<isl_val>s.841 842 #include <isl/val.h>843 __isl_give isl_val *isl_val_abs(__isl_take isl_val *v);844 __isl_give isl_val *isl_val_neg(__isl_take isl_val *v);845 __isl_give isl_val *isl_val_floor(__isl_take isl_val *v);846 __isl_give isl_val *isl_val_ceil(__isl_take isl_val *v);847 __isl_give isl_val *isl_val_trunc(__isl_take isl_val *v);848 __isl_give isl_val *isl_val_inv(__isl_take isl_val *v);849 850The following binary operations are available on C<isl_val>s.851 852 #include <isl/val.h>853 __isl_give isl_val *isl_val_min(__isl_take isl_val *v1,854 __isl_take isl_val *v2);855 __isl_give isl_val *isl_val_max(__isl_take isl_val *v1,856 __isl_take isl_val *v2);857 __isl_give isl_val *isl_val_add(__isl_take isl_val *v1,858 __isl_take isl_val *v2);859 __isl_give isl_val *isl_val_add_ui(__isl_take isl_val *v1,860 unsigned long v2);861 __isl_give isl_val *isl_val_sub(__isl_take isl_val *v1,862 __isl_take isl_val *v2);863 __isl_give isl_val *isl_val_sub_ui(__isl_take isl_val *v1,864 unsigned long v2);865 __isl_give isl_val *isl_val_mul(__isl_take isl_val *v1,866 __isl_take isl_val *v2);867 __isl_give isl_val *isl_val_mul_ui(__isl_take isl_val *v1,868 unsigned long v2);869 __isl_give isl_val *isl_val_div(__isl_take isl_val *v1,870 __isl_take isl_val *v2);871 __isl_give isl_val *isl_val_div_ui(__isl_take isl_val *v1,872 unsigned long v2);873 874On integer values, we additionally have the following operations.875 876 #include <isl/val.h>877 __isl_give isl_val *isl_val_pow2(__isl_take isl_val *v);878 __isl_give isl_val *isl_val_2exp(__isl_take isl_val *v);879 __isl_give isl_val *isl_val_mod(__isl_take isl_val *v1,880 __isl_take isl_val *v2);881 __isl_give isl_val *isl_val_gcd(__isl_take isl_val *v1,882 __isl_take isl_val *v2);883 __isl_give isl_val *isl_val_gcdext(__isl_take isl_val *v1,884 __isl_take isl_val *v2, __isl_give isl_val **x,885 __isl_give isl_val **y);886 887C<isl_val_2exp> is an alternative name for C<isl_val_pow2>.888The function C<isl_val_gcdext> returns the greatest common divisor g889of C<v1> and C<v2> as well as two integers C<*x> and C<*y> such890that C<*x> * C<v1> + C<*y> * C<v2> = g.891 892=head3 GMP specific functions893 894These functions are only available if C<isl> has been compiled with C<GMP>895support.896 897Specific integer and rational values can be created from C<GMP> values using898the following functions.899 900 #include <isl/val_gmp.h>901 __isl_give isl_val *isl_val_int_from_gmp(isl_ctx *ctx,902 mpz_t z);903 __isl_give isl_val *isl_val_from_gmp(isl_ctx *ctx,904 const mpz_t n, const mpz_t d);905 906The numerator and denominator of a rational value can be extracted as907C<GMP> values using the following functions.908 909 #include <isl/val_gmp.h>910 int isl_val_get_num_gmp(__isl_keep isl_val *v, mpz_t z);911 int isl_val_get_den_gmp(__isl_keep isl_val *v, mpz_t z);912 913=head2 Sets and Relations914 915C<isl> uses six types of objects for representing sets and relations,916C<isl_basic_set>, C<isl_basic_map>, C<isl_set>, C<isl_map>,917C<isl_union_set> and C<isl_union_map>.918C<isl_basic_set> and C<isl_basic_map> represent sets and relations that919can be described as a conjunction of affine constraints, while920C<isl_set> and C<isl_map> represent unions of921C<isl_basic_set>s and C<isl_basic_map>s, respectively.922However, all C<isl_basic_set>s or C<isl_basic_map>s in the union need923to live in the same space. C<isl_union_set>s and C<isl_union_map>s924represent unions of C<isl_set>s or C<isl_map>s in I<different> spaces,925where spaces are considered different if they have a different number926of dimensions and/or different names (see L<"Spaces">).927The difference between sets and relations (maps) is that sets have928one set of variables, while relations have two sets of variables,929input variables and output variables.930 931=head2 Error Handling932 933C<isl> supports different ways to react in case a runtime error is triggered.934Runtime errors arise, e.g., if a function such as C<isl_map_intersect> is called935with two maps that have incompatible spaces. There are three possible ways936to react on error: to warn, to continue or to abort.937 938The default behavior is to warn. In this mode, C<isl> prints a warning, stores939the last error in the corresponding C<isl_ctx> and the function in which the940error was triggered returns a value indicating that some error has941occurred. In case of functions returning a pointer, this value is942C<NULL>. In case of functions returning an C<isl_size>, C<isl_bool> or an943C<isl_stat>, this value is C<isl_size_error>,944C<isl_bool_error> or C<isl_stat_error>.945An error does not corrupt internal state,946such that isl can continue to be used. C<isl> also provides functions to947read the last error, including the specific error message,948the isl source file where the error occurred and the line number,949and to reset all information about the last error. The950last error is only stored for information purposes. Its presence does not951change the behavior of C<isl>. Hence, resetting an error is not required to952continue to use isl, but only to observe new errors.953 954 #include <isl/ctx.h>955 enum isl_error isl_ctx_last_error(isl_ctx *ctx);956 const char *isl_ctx_last_error_msg(isl_ctx *ctx);957 const char *isl_ctx_last_error_file(isl_ctx *ctx);958 int isl_ctx_last_error_line(isl_ctx *ctx);959 void isl_ctx_reset_error(isl_ctx *ctx);960 961If no error has occurred since the last call to C<isl_ctx_reset_error>,962then the functions C<isl_ctx_last_error_msg> and963C<isl_ctx_last_error_file> return C<NULL>.964 965Another option is to continue on error. This is similar to warn on error mode,966except that C<isl> does not print any warning. This allows a program to967implement its own error reporting.968 969The last option is to directly abort the execution of the program from within970the isl library. This makes it obviously impossible to recover from an error,971but it allows to directly spot the error location. By aborting on error,972debuggers break at the location the error occurred and can provide a stack973trace. Other tools that automatically provide stack traces on abort or that do974not want to continue execution after an error was triggered may also prefer to975abort on error.976 977The on error behavior of isl can be specified by calling978C<isl_options_set_on_error> or by setting the command line option979C<--isl-on-error>. Valid arguments for the function call are980C<ISL_ON_ERROR_WARN>, C<ISL_ON_ERROR_CONTINUE> and C<ISL_ON_ERROR_ABORT>. The981choices for the command line option are C<warn>, C<continue> and C<abort>.982It is also possible to query the current error mode.983 984 #include <isl/options.h>985 isl_stat isl_options_set_on_error(isl_ctx *ctx, int val);986 int isl_options_get_on_error(isl_ctx *ctx);987 988=head2 Identifiers989 990Identifiers are used to identify both individual dimensions991and tuples of dimensions. They consist of an optional name and an optional992user pointer. The name and the user pointer cannot both be C<NULL>, however.993Identifiers with the same name but different pointer values994are considered to be distinct.995Similarly, identifiers with different names but the same pointer value996are also considered to be distinct.997Equal identifiers are represented using the same object.998Pairs of identifiers can therefore be tested for equality using the999C<==> operator.1000Identifiers can be constructed, copied, freed, inspected and printed1001using the following functions.1002 1003 #include <isl/id.h>1004 __isl_give isl_id *isl_id_alloc(isl_ctx *ctx,1005 __isl_keep const char *name, void *user);1006 __isl_give isl_id *isl_id_set_free_user(1007 __isl_take isl_id *id,1008 void (*free_user)(void *user));1009 void (*isl_id_get_free_user(__isl_keep isl_id *id))1010 (void *user);1011 __isl_give isl_id *isl_id_copy(isl_id *id);1012 __isl_null isl_id *isl_id_free(__isl_take isl_id *id);1013 1014 void *isl_id_get_user(__isl_keep isl_id *id);1015 __isl_keep const char *isl_id_get_name(__isl_keep isl_id *id);1016 1017 __isl_give isl_printer *isl_printer_print_id(1018 __isl_take isl_printer *p, __isl_keep isl_id *id);1019 1020The callback set by C<isl_id_set_free_user> is called on the user1021pointer when the last reference to the C<isl_id> is freed.1022This callback can be retrieved using C<isl_id_get_free_user>.1023Note that C<isl_id_get_name> returns a pointer to some internal1024data structure, so the result can only be used while the1025corresponding C<isl_id> is alive.1026 1027=head2 Spaces1028 1029Whenever a new set, relation or similar object is created from scratch,1030the space in which it lives needs to be specified using an C<isl_space>.1031Each space involves zero or more parameters and zero, one or two1032tuples of set or input/output dimensions. The parameters and dimensions1033are identified by an C<isl_dim_type> and a position.1034The type C<isl_dim_param> refers to parameters,1035the type C<isl_dim_set> refers to set dimensions (for spaces1036with a single tuple of dimensions) and the types C<isl_dim_in>1037and C<isl_dim_out> refer to input and output dimensions1038(for spaces with two tuples of dimensions).1039Local spaces (see L</"Local Spaces">) also contain dimensions1040of type C<isl_dim_div>.1041Note that parameters are only identified by their position within1042a given object. Across different objects, parameters are (usually)1043identified by their names or identifiers. Only unnamed parameters1044are identified by their positions across objects. The use of unnamed1045parameters is discouraged.1046 1047 #include <isl/space.h>1048 __isl_give isl_space *isl_space_unit(isl_ctx *ctx);1049 __isl_give isl_space *isl_space_alloc(isl_ctx *ctx,1050 unsigned nparam, unsigned n_in, unsigned n_out);1051 __isl_give isl_space *isl_space_params_alloc(isl_ctx *ctx,1052 unsigned nparam);1053 __isl_give isl_space *isl_space_set_alloc(isl_ctx *ctx,1054 unsigned nparam, unsigned dim);1055 __isl_give isl_space *isl_space_copy(__isl_keep isl_space *space);1056 __isl_null isl_space *isl_space_free(__isl_take isl_space *space);1057 1058The space used for creating a parameter domain1059needs to be created using C<isl_space_unit> or C<isl_space_params_alloc>.1060For other sets, the space1061needs to be created using C<isl_space_set_alloc>, while1062for a relation, the space1063needs to be created using C<isl_space_alloc>.1064The use of C<isl_space_params_alloc>,1065C<isl_space_set_alloc> and C<isl_space_alloc> is discouraged as they allow1066for the introduction of unnamed parameters.1067 1068To check whether a given space is that of a set or a map1069or whether it is a parameter space, use these functions:1070 1071 #include <isl/space.h>1072 isl_bool isl_space_is_params(__isl_keep isl_space *space);1073 isl_bool isl_space_is_set(__isl_keep isl_space *space);1074 isl_bool isl_space_is_map(__isl_keep isl_space *space);1075 1076Spaces can be compared using the following functions:1077 1078 #include <isl/space.h>1079 isl_bool isl_space_is_equal(__isl_keep isl_space *space1,1080 __isl_keep isl_space *space2);1081 isl_bool isl_space_has_equal_params(1082 __isl_keep isl_space *space1,1083 __isl_keep isl_space *space2);1084 isl_bool isl_space_has_equal_tuples(1085 __isl_keep isl_space *space1,1086 __isl_keep isl_space *space2);1087 isl_bool isl_space_is_domain(__isl_keep isl_space *space1,1088 __isl_keep isl_space *space2);1089 isl_bool isl_space_is_range(__isl_keep isl_space *space1,1090 __isl_keep isl_space *space2);1091 isl_bool isl_space_tuple_is_equal(1092 __isl_keep isl_space *space1,1093 enum isl_dim_type type1,1094 __isl_keep isl_space *space2,1095 enum isl_dim_type type2);1096 1097C<isl_space_is_domain> checks whether the first argument is equal1098to the domain of the second argument. This requires in particular that1099the first argument is a set space and that the second argument1100is a map space. C<isl_space_tuple_is_equal> checks whether the given1101tuples (C<isl_dim_in>, C<isl_dim_out> or C<isl_dim_set>) of the given1102spaces are the same. That is, it checks if they have the same1103identifier (if any), the same dimension and the same internal structure1104(if any).1105The function1106C<isl_space_has_equal_params> checks whether two spaces1107have the same parameters in the same order.1108C<isl_space_has_equal_tuples> check whether two spaces have1109the same tuples. In contrast to C<isl_space_is_equal> below,1110it does not check the1111parameters. This is useful because many C<isl> functions align the1112parameters before they perform their operations, such that equivalence1113is not necessary.1114C<isl_space_is_equal> checks whether two spaces are identical,1115meaning that they have the same parameters and the same tuples.1116That is, it checks whether both C<isl_space_has_equal_params> and1117C<isl_space_has_equal_tuples> hold.1118 1119It is often useful to create objects that live in the1120same space as some other object. This can be accomplished1121by creating the new objects1122(see L</"Creating New Sets and Relations"> or1123L</"Functions">) based on the space1124of the original object.1125 1126 #include <isl/set.h>1127 __isl_give isl_space *isl_basic_set_get_space(1128 __isl_keep isl_basic_set *bset);1129 __isl_give isl_space *isl_set_get_space(__isl_keep isl_set *set);1130 1131 #include <isl/union_set.h>1132 __isl_give isl_space *isl_union_set_get_space(1133 __isl_keep isl_union_set *uset);1134 1135 #include <isl/map.h>1136 __isl_give isl_space *isl_basic_map_get_space(1137 __isl_keep isl_basic_map *bmap);1138 __isl_give isl_space *isl_map_get_space(__isl_keep isl_map *map);1139 1140 #include <isl/union_map.h>1141 __isl_give isl_space *isl_union_map_get_space(1142 __isl_keep isl_union_map *umap);1143 1144 #include <isl/constraint.h>1145 __isl_give isl_space *isl_constraint_get_space(1146 __isl_keep isl_constraint *constraint);1147 1148 #include <isl/polynomial.h>1149 __isl_give isl_space *isl_qpolynomial_get_domain_space(1150 __isl_keep isl_qpolynomial *qp);1151 __isl_give isl_space *isl_qpolynomial_get_space(1152 __isl_keep isl_qpolynomial *qp);1153 __isl_give isl_space *1154 isl_qpolynomial_fold_get_domain_space(1155 __isl_keep isl_qpolynomial_fold *fold);1156 __isl_give isl_space *isl_qpolynomial_fold_get_space(1157 __isl_keep isl_qpolynomial_fold *fold);1158 __isl_give isl_space *isl_pw_qpolynomial_get_domain_space(1159 __isl_keep isl_pw_qpolynomial *pwqp);1160 __isl_give isl_space *isl_pw_qpolynomial_get_space(1161 __isl_keep isl_pw_qpolynomial *pwqp);1162 __isl_give isl_space *isl_pw_qpolynomial_fold_get_domain_space(1163 __isl_keep isl_pw_qpolynomial_fold *pwf);1164 __isl_give isl_space *isl_pw_qpolynomial_fold_get_space(1165 __isl_keep isl_pw_qpolynomial_fold *pwf);1166 __isl_give isl_space *isl_union_pw_qpolynomial_get_space(1167 __isl_keep isl_union_pw_qpolynomial *upwqp);1168 __isl_give isl_space *isl_union_pw_qpolynomial_fold_get_space(1169 __isl_keep isl_union_pw_qpolynomial_fold *upwf);1170 1171 #include <isl/id.h>1172 __isl_give isl_space *isl_multi_id_get_space(1173 __isl_keep isl_multi_id *mi);1174 1175 #include <isl/val.h>1176 __isl_give isl_space *isl_multi_val_get_space(1177 __isl_keep isl_multi_val *mv);1178 1179 #include <isl/aff.h>1180 __isl_give isl_space *isl_aff_get_domain_space(1181 __isl_keep isl_aff *aff);1182 __isl_give isl_space *isl_aff_get_space(1183 __isl_keep isl_aff *aff);1184 __isl_give isl_space *isl_pw_aff_get_domain_space(1185 __isl_keep isl_pw_aff *pwaff);1186 __isl_give isl_space *isl_pw_aff_get_space(1187 __isl_keep isl_pw_aff *pwaff);1188 __isl_give isl_space *isl_multi_aff_get_domain_space(1189 __isl_keep isl_multi_aff *maff);1190 __isl_give isl_space *isl_multi_aff_get_space(1191 __isl_keep isl_multi_aff *maff);1192 __isl_give isl_space *isl_pw_multi_aff_get_domain_space(1193 __isl_keep isl_pw_multi_aff *pma);1194 __isl_give isl_space *isl_pw_multi_aff_get_space(1195 __isl_keep isl_pw_multi_aff *pma);1196 __isl_give isl_space *isl_union_pw_aff_get_space(1197 __isl_keep isl_union_pw_aff *upa);1198 __isl_give isl_space *isl_union_pw_multi_aff_get_space(1199 __isl_keep isl_union_pw_multi_aff *upma);1200 __isl_give isl_space *isl_multi_pw_aff_get_domain_space(1201 __isl_keep isl_multi_pw_aff *mpa);1202 __isl_give isl_space *isl_multi_pw_aff_get_space(1203 __isl_keep isl_multi_pw_aff *mpa);1204 __isl_give isl_space *1205 isl_multi_union_pw_aff_get_domain_space(1206 __isl_keep isl_multi_union_pw_aff *mupa);1207 __isl_give isl_space *1208 isl_multi_union_pw_aff_get_space(1209 __isl_keep isl_multi_union_pw_aff *mupa);1210 1211 #include <isl/point.h>1212 __isl_give isl_space *isl_point_get_space(1213 __isl_keep isl_point *pnt);1214 1215 #include <isl/fixed_box.h>1216 __isl_give isl_space *isl_fixed_box_get_space(1217 __isl_keep isl_fixed_box *box);1218 1219The number of dimensions of a given type of space1220may be read off from a space or an object that lives1221in a space using the following functions.1222In case of C<isl_space_dim>, type may be1223C<isl_dim_param>, C<isl_dim_in> (only for relations),1224C<isl_dim_out> (only for relations), C<isl_dim_set>1225(only for sets) or C<isl_dim_all>.1226 1227 #include <isl/space.h>1228 isl_size isl_space_dim(__isl_keep isl_space *space,1229 enum isl_dim_type type);1230 1231 #include <isl/local_space.h>1232 isl_size isl_local_space_dim(__isl_keep isl_local_space *ls,1233 enum isl_dim_type type);1234 1235 #include <isl/set.h>1236 isl_size isl_basic_set_dim(__isl_keep isl_basic_set *bset,1237 enum isl_dim_type type);1238 isl_size isl_set_tuple_dim(__isl_keep isl_set *set);1239 isl_size isl_set_dim(__isl_keep isl_set *set,1240 enum isl_dim_type type);1241 1242 #include <isl/union_set.h>1243 isl_size isl_union_set_dim(__isl_keep isl_union_set *uset,1244 enum isl_dim_type type);1245 1246 #include <isl/map.h>1247 isl_size isl_basic_map_dim(__isl_keep isl_basic_map *bmap,1248 enum isl_dim_type type);1249 isl_size isl_map_domain_tuple_dim(1250 __isl_keep isl_map *map);1251 isl_size isl_map_range_tuple_dim(1252 __isl_keep isl_map *map);1253 isl_size isl_map_dim(__isl_keep isl_map *map,1254 enum isl_dim_type type);1255 1256 #include <isl/union_map.h>1257 isl_size isl_union_map_dim(__isl_keep isl_union_map *umap,1258 enum isl_dim_type type);1259 1260 #include <isl/val.h>1261 isl_size isl_multi_val_dim(__isl_keep isl_multi_val *mv,1262 enum isl_dim_type type);1263 1264 #include <isl/aff.h>1265 isl_size isl_aff_dim(__isl_keep isl_aff *aff,1266 enum isl_dim_type type);1267 isl_size isl_multi_aff_dim(__isl_keep isl_multi_aff *maff,1268 enum isl_dim_type type);1269 isl_size isl_pw_aff_dim(__isl_keep isl_pw_aff *pwaff,1270 enum isl_dim_type type);1271 isl_size isl_pw_multi_aff_dim(1272 __isl_keep isl_pw_multi_aff *pma,1273 enum isl_dim_type type);1274 isl_size isl_multi_pw_aff_dim(1275 __isl_keep isl_multi_pw_aff *mpa,1276 enum isl_dim_type type);1277 isl_size isl_union_pw_aff_dim(1278 __isl_keep isl_union_pw_aff *upa,1279 enum isl_dim_type type);1280 isl_size isl_union_pw_multi_aff_dim(1281 __isl_keep isl_union_pw_multi_aff *upma,1282 enum isl_dim_type type);1283 isl_size isl_multi_union_pw_aff_dim(1284 __isl_keep isl_multi_union_pw_aff *mupa,1285 enum isl_dim_type type);1286 1287 #include <isl/polynomial.h>1288 isl_size isl_union_pw_qpolynomial_dim(1289 __isl_keep isl_union_pw_qpolynomial *upwqp,1290 enum isl_dim_type type);1291 isl_size isl_union_pw_qpolynomial_fold_dim(1292 __isl_keep isl_union_pw_qpolynomial_fold *upwf,1293 enum isl_dim_type type);1294 1295Note that an C<isl_union_set>, an C<isl_union_map>,1296an C<isl_union_pw_multi_aff>,1297an C<isl_union_pw_qpolynomial> and1298an C<isl_union_pw_qpolynomial_fold>1299only have parameters.1300 1301Additional parameters can be added to a space using the following function.1302 1303 #include <isl/space.h>1304 __isl_give isl_space *isl_space_add_param_id(1305 __isl_take isl_space *space,1306 __isl_take isl_id *id);1307 1308If a parameter with the given identifier already appears in the space,1309then it is not added again.1310 1311Conversely, all parameters can be removed from a space1312using the following function.1313 1314 #include <isl/space.h>1315 __isl_give isl_space *isl_space_drop_all_params(1316 __isl_take isl_space *space);1317 1318The identifiers or names of the individual dimensions of spaces1319may be set or read off using the following functions on spaces1320or objects that live in spaces.1321These functions are mostly useful to obtain the identifiers, positions1322or names of the parameters. Identifiers of individual dimensions are1323essentially only useful for printing. They are ignored by all other1324operations and may not be preserved across those operations.1325To keep track of a space along with names/identifiers of1326the set dimensions, use an C<isl_multi_id> as described in1327L</"Functions">.1328 1329 #include <isl/space.h>1330 __isl_give isl_space *isl_space_set_dim_id(1331 __isl_take isl_space *space,1332 enum isl_dim_type type, unsigned pos,1333 __isl_take isl_id *id);1334 isl_bool isl_space_has_dim_id(__isl_keep isl_space *space,1335 enum isl_dim_type type, unsigned pos);1336 __isl_give isl_id *isl_space_get_dim_id(1337 __isl_keep isl_space *space,1338 enum isl_dim_type type, unsigned pos);1339 __isl_give isl_space *isl_space_set_dim_name(1340 __isl_take isl_space *space,1341 enum isl_dim_type type, unsigned pos,1342 __isl_keep const char *name);1343 isl_bool isl_space_has_dim_name(__isl_keep isl_space *space,1344 enum isl_dim_type type, unsigned pos);1345 __isl_keep const char *isl_space_get_dim_name(1346 __isl_keep isl_space *space,1347 enum isl_dim_type type, unsigned pos);1348 1349 #include <isl/local_space.h>1350 __isl_give isl_local_space *isl_local_space_set_dim_id(1351 __isl_take isl_local_space *ls,1352 enum isl_dim_type type, unsigned pos,1353 __isl_take isl_id *id);1354 isl_bool isl_local_space_has_dim_id(1355 __isl_keep isl_local_space *ls,1356 enum isl_dim_type type, unsigned pos);1357 __isl_give isl_id *isl_local_space_get_dim_id(1358 __isl_keep isl_local_space *ls,1359 enum isl_dim_type type, unsigned pos);1360 __isl_give isl_local_space *isl_local_space_set_dim_name(1361 __isl_take isl_local_space *ls,1362 enum isl_dim_type type, unsigned pos, const char *s);1363 isl_bool isl_local_space_has_dim_name(1364 __isl_keep isl_local_space *ls,1365 enum isl_dim_type type, unsigned pos)1366 const char *isl_local_space_get_dim_name(1367 __isl_keep isl_local_space *ls,1368 enum isl_dim_type type, unsigned pos);1369 1370 #include <isl/constraint.h>1371 const char *isl_constraint_get_dim_name(1372 __isl_keep isl_constraint *constraint,1373 enum isl_dim_type type, unsigned pos);1374 1375 #include <isl/set.h>1376 __isl_give isl_id *isl_basic_set_get_dim_id(1377 __isl_keep isl_basic_set *bset,1378 enum isl_dim_type type, unsigned pos);1379 __isl_give isl_set *isl_set_set_dim_id(1380 __isl_take isl_set *set, enum isl_dim_type type,1381 unsigned pos, __isl_take isl_id *id);1382 isl_bool isl_set_has_dim_id(__isl_keep isl_set *set,1383 enum isl_dim_type type, unsigned pos);1384 __isl_give isl_id *isl_set_get_dim_id(1385 __isl_keep isl_set *set, enum isl_dim_type type,1386 unsigned pos);1387 const char *isl_basic_set_get_dim_name(1388 __isl_keep isl_basic_set *bset,1389 enum isl_dim_type type, unsigned pos);1390 isl_bool isl_set_has_dim_name(__isl_keep isl_set *set,1391 enum isl_dim_type type, unsigned pos);1392 const char *isl_set_get_dim_name(1393 __isl_keep isl_set *set,1394 enum isl_dim_type type, unsigned pos);1395 1396 #include <isl/map.h>1397 __isl_give isl_map *isl_map_set_dim_id(1398 __isl_take isl_map *map, enum isl_dim_type type,1399 unsigned pos, __isl_take isl_id *id);1400 isl_bool isl_basic_map_has_dim_id(1401 __isl_keep isl_basic_map *bmap,1402 enum isl_dim_type type, unsigned pos);1403 isl_bool isl_map_has_dim_id(__isl_keep isl_map *map,1404 enum isl_dim_type type, unsigned pos);1405 __isl_give isl_id *isl_map_get_dim_id(1406 __isl_keep isl_map *map, enum isl_dim_type type,1407 unsigned pos);1408 __isl_give isl_id *isl_union_map_get_dim_id(1409 __isl_keep isl_union_map *umap,1410 enum isl_dim_type type, unsigned pos);1411 const char *isl_basic_map_get_dim_name(1412 __isl_keep isl_basic_map *bmap,1413 enum isl_dim_type type, unsigned pos);1414 isl_bool isl_map_has_dim_name(__isl_keep isl_map *map,1415 enum isl_dim_type type, unsigned pos);1416 const char *isl_map_get_dim_name(1417 __isl_keep isl_map *map,1418 enum isl_dim_type type, unsigned pos);1419 1420 #include <isl/val.h>1421 __isl_give isl_multi_val *isl_multi_val_set_dim_id(1422 __isl_take isl_multi_val *mv,1423 enum isl_dim_type type, unsigned pos,1424 __isl_take isl_id *id);1425 __isl_give isl_id *isl_multi_val_get_dim_id(1426 __isl_keep isl_multi_val *mv,1427 enum isl_dim_type type, unsigned pos);1428 __isl_give isl_multi_val *isl_multi_val_set_dim_name(1429 __isl_take isl_multi_val *mv,1430 enum isl_dim_type type, unsigned pos, const char *s);1431 1432 #include <isl/aff.h>1433 __isl_give isl_aff *isl_aff_set_dim_id(1434 __isl_take isl_aff *aff, enum isl_dim_type type,1435 unsigned pos, __isl_take isl_id *id);1436 __isl_give isl_multi_aff *isl_multi_aff_set_dim_id(1437 __isl_take isl_multi_aff *maff,1438 enum isl_dim_type type, unsigned pos,1439 __isl_take isl_id *id);1440 __isl_give isl_pw_aff *isl_pw_aff_set_dim_id(1441 __isl_take isl_pw_aff *pma,1442 enum isl_dim_type type, unsigned pos,1443 __isl_take isl_id *id);1444 __isl_give isl_multi_pw_aff *1445 isl_multi_pw_aff_set_dim_id(1446 __isl_take isl_multi_pw_aff *mpa,1447 enum isl_dim_type type, unsigned pos,1448 __isl_take isl_id *id);1449 __isl_give isl_multi_union_pw_aff *1450 isl_multi_union_pw_aff_set_dim_id(1451 __isl_take isl_multi_union_pw_aff *mupa,1452 enum isl_dim_type type, unsigned pos,1453 __isl_take isl_id *id);1454 __isl_give isl_id *isl_multi_aff_get_dim_id(1455 __isl_keep isl_multi_aff *ma,1456 enum isl_dim_type type, unsigned pos);1457 isl_bool isl_pw_aff_has_dim_id(__isl_keep isl_pw_aff *pa,1458 enum isl_dim_type type, unsigned pos);1459 __isl_give isl_id *isl_pw_aff_get_dim_id(1460 __isl_keep isl_pw_aff *pa,1461 enum isl_dim_type type, unsigned pos);1462 __isl_give isl_id *isl_pw_multi_aff_get_dim_id(1463 __isl_keep isl_pw_multi_aff *pma,1464 enum isl_dim_type type, unsigned pos);1465 __isl_give isl_id *isl_multi_pw_aff_get_dim_id(1466 __isl_keep isl_multi_pw_aff *mpa,1467 enum isl_dim_type type, unsigned pos);1468 __isl_give isl_id *isl_multi_union_pw_aff_get_dim_id(1469 __isl_keep isl_multi_union_pw_aff *mupa,1470 enum isl_dim_type type, unsigned pos);1471 __isl_give isl_aff *isl_aff_set_dim_name(1472 __isl_take isl_aff *aff, enum isl_dim_type type,1473 unsigned pos, const char *s);1474 __isl_give isl_multi_aff *isl_multi_aff_set_dim_name(1475 __isl_take isl_multi_aff *maff,1476 enum isl_dim_type type, unsigned pos, const char *s);1477 __isl_give isl_multi_pw_aff *1478 isl_multi_pw_aff_set_dim_name(1479 __isl_take isl_multi_pw_aff *mpa,1480 enum isl_dim_type type, unsigned pos, const char *s);1481 __isl_give isl_union_pw_aff *1482 isl_union_pw_aff_set_dim_name(1483 __isl_take isl_union_pw_aff *upa,1484 enum isl_dim_type type, unsigned pos,1485 const char *s);1486 __isl_give isl_union_pw_multi_aff *1487 isl_union_pw_multi_aff_set_dim_name(1488 __isl_take isl_union_pw_multi_aff *upma,1489 enum isl_dim_type type, unsigned pos,1490 const char *s);1491 __isl_give isl_multi_union_pw_aff *1492 isl_multi_union_pw_aff_set_dim_name(1493 __isl_take isl_multi_union_pw_aff *mupa,1494 enum isl_dim_type type, unsigned pos,1495 const char *s);1496 const char *isl_aff_get_dim_name(__isl_keep isl_aff *aff,1497 enum isl_dim_type type, unsigned pos);1498 const char *isl_pw_aff_get_dim_name(1499 __isl_keep isl_pw_aff *pa,1500 enum isl_dim_type type, unsigned pos);1501 const char *isl_pw_multi_aff_get_dim_name(1502 __isl_keep isl_pw_multi_aff *pma,1503 enum isl_dim_type type, unsigned pos);1504 1505 #include <isl/polynomial.h>1506 __isl_give isl_qpolynomial *isl_qpolynomial_set_dim_name(1507 __isl_take isl_qpolynomial *qp,1508 enum isl_dim_type type, unsigned pos,1509 const char *s);1510 __isl_give isl_pw_qpolynomial *1511 isl_pw_qpolynomial_set_dim_name(1512 __isl_take isl_pw_qpolynomial *pwqp,1513 enum isl_dim_type type, unsigned pos,1514 const char *s);1515 __isl_give isl_pw_qpolynomial_fold *1516 isl_pw_qpolynomial_fold_set_dim_name(1517 __isl_take isl_pw_qpolynomial_fold *pwf,1518 enum isl_dim_type type, unsigned pos,1519 const char *s);1520 __isl_give isl_union_pw_qpolynomial *1521 isl_union_pw_qpolynomial_set_dim_name(1522 __isl_take isl_union_pw_qpolynomial *upwqp,1523 enum isl_dim_type type, unsigned pos,1524 const char *s);1525 __isl_give isl_union_pw_qpolynomial_fold *1526 isl_union_pw_qpolynomial_fold_set_dim_name(1527 __isl_take isl_union_pw_qpolynomial_fold *upwf,1528 enum isl_dim_type type, unsigned pos,1529 const char *s);1530 1531Note that C<isl_space_get_name> returns a pointer to some internal1532data structure, so the result can only be used while the1533corresponding C<isl_space> is alive.1534Also note that every function that operates on two sets or relations1535requires that both arguments have the same parameters. This also1536means that if one of the arguments has named parameters, then the1537other needs to have named parameters too and the names need to match.1538Pairs of C<isl_set>, C<isl_map>, C<isl_union_set> and/or C<isl_union_map>1539arguments may have different parameters (as long as they are named),1540in which case the result will have as parameters the union of the parameters of1541the arguments.1542 1543Given the identifier or name of a dimension (typically a parameter),1544its position can be obtained from the following functions.1545 1546 #include <isl/space.h>1547 int isl_space_find_dim_by_id(__isl_keep isl_space *space,1548 enum isl_dim_type type, __isl_keep isl_id *id);1549 int isl_space_find_dim_by_name(__isl_keep isl_space *space,1550 enum isl_dim_type type, const char *name);1551 1552 #include <isl/local_space.h>1553 int isl_local_space_find_dim_by_name(1554 __isl_keep isl_local_space *ls,1555 enum isl_dim_type type, const char *name);1556 1557 #include <isl/val.h>1558 int isl_multi_val_find_dim_by_id(1559 __isl_keep isl_multi_val *mv,1560 enum isl_dim_type type, __isl_keep isl_id *id);1561 int isl_multi_val_find_dim_by_name(1562 __isl_keep isl_multi_val *mv,1563 enum isl_dim_type type, const char *name);1564 1565 #include <isl/set.h>1566 int isl_set_find_dim_by_id(__isl_keep isl_set *set,1567 enum isl_dim_type type, __isl_keep isl_id *id);1568 int isl_set_find_dim_by_name(__isl_keep isl_set *set,1569 enum isl_dim_type type, const char *name);1570 1571 #include <isl/map.h>1572 int isl_map_find_dim_by_id(__isl_keep isl_map *map,1573 enum isl_dim_type type, __isl_keep isl_id *id);1574 int isl_basic_map_find_dim_by_name(1575 __isl_keep isl_basic_map *bmap,1576 enum isl_dim_type type, const char *name);1577 int isl_map_find_dim_by_name(__isl_keep isl_map *map,1578 enum isl_dim_type type, const char *name);1579 int isl_union_map_find_dim_by_name(1580 __isl_keep isl_union_map *umap,1581 enum isl_dim_type type, const char *name);1582 1583 #include <isl/aff.h>1584 int isl_multi_aff_find_dim_by_id(1585 __isl_keep isl_multi_aff *ma,1586 enum isl_dim_type type, __isl_keep isl_id *id);1587 int isl_multi_pw_aff_find_dim_by_id(1588 __isl_keep isl_multi_pw_aff *mpa,1589 enum isl_dim_type type, __isl_keep isl_id *id);1590 int isl_multi_union_pw_aff_find_dim_by_id(1591 __isl_keep isl_multi_union_pw_aff *mupa,1592 enum isl_dim_type type, __isl_keep isl_id *id);1593 int isl_aff_find_dim_by_name(__isl_keep isl_aff *aff,1594 enum isl_dim_type type, const char *name);1595 int isl_multi_aff_find_dim_by_name(1596 __isl_keep isl_multi_aff *ma,1597 enum isl_dim_type type, const char *name);1598 int isl_pw_aff_find_dim_by_name(__isl_keep isl_pw_aff *pa,1599 enum isl_dim_type type, const char *name);1600 int isl_multi_pw_aff_find_dim_by_name(1601 __isl_keep isl_multi_pw_aff *mpa,1602 enum isl_dim_type type, const char *name);1603 int isl_pw_multi_aff_find_dim_by_name(1604 __isl_keep isl_pw_multi_aff *pma,1605 enum isl_dim_type type, const char *name);1606 int isl_union_pw_aff_find_dim_by_name(1607 __isl_keep isl_union_pw_aff *upa,1608 enum isl_dim_type type, const char *name);1609 int isl_union_pw_multi_aff_find_dim_by_name(1610 __isl_keep isl_union_pw_multi_aff *upma,1611 enum isl_dim_type type, const char *name);1612 int isl_multi_union_pw_aff_find_dim_by_name(1613 __isl_keep isl_multi_union_pw_aff *mupa,1614 enum isl_dim_type type, const char *name);1615 1616 #include <isl/polynomial.h>1617 int isl_pw_qpolynomial_find_dim_by_name(1618 __isl_keep isl_pw_qpolynomial *pwqp,1619 enum isl_dim_type type, const char *name);1620 int isl_pw_qpolynomial_fold_find_dim_by_name(1621 __isl_keep isl_pw_qpolynomial_fold *pwf,1622 enum isl_dim_type type, const char *name);1623 int isl_union_pw_qpolynomial_find_dim_by_name(1624 __isl_keep isl_union_pw_qpolynomial *upwqp,1625 enum isl_dim_type type, const char *name);1626 int isl_union_pw_qpolynomial_fold_find_dim_by_name(1627 __isl_keep isl_union_pw_qpolynomial_fold *upwf,1628 enum isl_dim_type type, const char *name);1629 1630The identifiers or names of entire spaces may be set or read off1631using the following functions.1632 1633 #include <isl/space.h>1634 __isl_give isl_space *isl_space_set_domain_tuple_id(1635 __isl_take isl_space *space,1636 __isl_take isl_id *id);1637 __isl_give isl_space *isl_space_set_range_tuple_id(1638 __isl_take isl_space *space,1639 __isl_take isl_id *id);1640 __isl_give isl_space *isl_space_set_tuple_id(1641 __isl_take isl_space *space,1642 enum isl_dim_type type, __isl_take isl_id *id);1643 __isl_give isl_space *isl_space_reset_tuple_id(1644 __isl_take isl_space *space, enum isl_dim_type type);1645 isl_bool isl_space_has_domain_tuple_id(1646 __isl_keep isl_space *space);1647 isl_bool isl_space_has_range_tuple_id(1648 __isl_keep isl_space *space);1649 isl_bool isl_space_has_tuple_id(1650 __isl_keep isl_space *space,1651 enum isl_dim_type type);1652 __isl_give isl_id *isl_space_get_domain_tuple_id(1653 __isl_keep isl_space *space);1654 __isl_give isl_id *isl_space_get_range_tuple_id(1655 __isl_keep isl_space *space);1656 __isl_give isl_id *isl_space_get_tuple_id(1657 __isl_keep isl_space *space, enum isl_dim_type type);1658 __isl_give isl_space *isl_space_set_tuple_name(1659 __isl_take isl_space *space,1660 enum isl_dim_type type, const char *s);1661 isl_bool isl_space_has_tuple_name(1662 __isl_keep isl_space *space,1663 enum isl_dim_type type);1664 __isl_keep const char *isl_space_get_tuple_name(1665 __isl_keep isl_space *space,1666 enum isl_dim_type type);1667 1668 #include <isl/local_space.h>1669 __isl_give isl_local_space *isl_local_space_set_tuple_id(1670 __isl_take isl_local_space *ls,1671 enum isl_dim_type type, __isl_take isl_id *id);1672 1673 #include <isl/set.h>1674 __isl_give isl_basic_set *isl_basic_set_set_tuple_id(1675 __isl_take isl_basic_set *bset,1676 __isl_take isl_id *id);1677 __isl_give isl_set *isl_set_set_tuple_id(1678 __isl_take isl_set *set, __isl_take isl_id *id);1679 __isl_give isl_set *isl_set_reset_tuple_id(1680 __isl_take isl_set *set);1681 isl_bool isl_set_has_tuple_id(__isl_keep isl_set *set);1682 __isl_give isl_id *isl_set_get_tuple_id(1683 __isl_keep isl_set *set);1684 __isl_give isl_basic_set *isl_basic_set_set_tuple_name(1685 __isl_take isl_basic_set *set, const char *s);1686 __isl_give isl_set *isl_set_set_tuple_name(1687 __isl_take isl_set *set, const char *s);1688 const char *isl_basic_set_get_tuple_name(1689 __isl_keep isl_basic_set *bset);1690 isl_bool isl_set_has_tuple_name(__isl_keep isl_set *set);1691 const char *isl_set_get_tuple_name(1692 __isl_keep isl_set *set);1693 1694 #include <isl/map.h>1695 __isl_give isl_basic_map *isl_basic_map_set_tuple_id(1696 __isl_take isl_basic_map *bmap,1697 enum isl_dim_type type, __isl_take isl_id *id);1698 __isl_give isl_map *isl_map_set_domain_tuple_id(1699 __isl_take isl_map *map, __isl_take isl_id *id);1700 __isl_give isl_map *isl_map_set_range_tuple_id(1701 __isl_take isl_map *map, __isl_take isl_id *id);1702 __isl_give isl_map *isl_map_set_tuple_id(1703 __isl_take isl_map *map, enum isl_dim_type type,1704 __isl_take isl_id *id);1705 __isl_give isl_map *isl_map_reset_tuple_id(1706 __isl_take isl_map *map, enum isl_dim_type type);1707 isl_bool isl_map_has_domain_tuple_id(1708 __isl_keep isl_map *map);1709 isl_bool isl_map_has_range_tuple_id(1710 __isl_keep isl_map *map);1711 isl_bool isl_map_has_tuple_id(__isl_keep isl_map *map,1712 enum isl_dim_type type);1713 __isl_give isl_id *isl_map_get_domain_tuple_id(1714 __isl_keep isl_map *map);1715 __isl_give isl_id *isl_map_get_range_tuple_id(1716 __isl_keep isl_map *map);1717 __isl_give isl_id *isl_map_get_tuple_id(1718 __isl_keep isl_map *map, enum isl_dim_type type);1719 __isl_give isl_map *isl_map_set_tuple_name(1720 __isl_take isl_map *map,1721 enum isl_dim_type type, const char *s);1722 const char *isl_basic_map_get_tuple_name(1723 __isl_keep isl_basic_map *bmap,1724 enum isl_dim_type type);1725 __isl_give isl_basic_map *isl_basic_map_set_tuple_name(1726 __isl_take isl_basic_map *bmap,1727 enum isl_dim_type type, const char *s);1728 isl_bool isl_map_has_tuple_name(__isl_keep isl_map *map,1729 enum isl_dim_type type);1730 const char *isl_map_get_tuple_name(1731 __isl_keep isl_map *map,1732 enum isl_dim_type type);1733 1734 #include <isl/val.h>1735 __isl_give isl_multi_val *isl_multi_val_set_range_tuple_id(1736 __isl_take isl_multi_val *mv,1737 __isl_take isl_id *id);1738 __isl_give isl_multi_val *isl_multi_val_set_tuple_id(1739 __isl_take isl_multi_val *mv,1740 enum isl_dim_type type, __isl_take isl_id *id);1741 __isl_give isl_multi_val *1742 isl_multi_val_reset_range_tuple_id(1743 __isl_take isl_multi_val *mv);1744 __isl_give isl_multi_val *isl_multi_val_reset_tuple_id(1745 __isl_take isl_multi_val *mv,1746 enum isl_dim_type type);1747 isl_bool isl_multi_val_has_range_tuple_id(1748 __isl_keep isl_multi_val *mv);1749 __isl_give isl_id *isl_multi_val_get_range_tuple_id(1750 __isl_keep isl_multi_val *mv);1751 isl_bool isl_multi_val_has_tuple_id(1752 __isl_keep isl_multi_val *mv,1753 enum isl_dim_type type);1754 __isl_give isl_id *isl_multi_val_get_tuple_id(1755 __isl_keep isl_multi_val *mv,1756 enum isl_dim_type type);1757 __isl_give isl_multi_val *isl_multi_val_set_tuple_name(1758 __isl_take isl_multi_val *mv,1759 enum isl_dim_type type, const char *s);1760 const char *isl_multi_val_get_tuple_name(1761 __isl_keep isl_multi_val *mv,1762 enum isl_dim_type type);1763 1764 #include <isl/aff.h>1765 __isl_give isl_aff *isl_aff_set_tuple_id(1766 __isl_take isl_aff *aff,1767 enum isl_dim_type type, __isl_take isl_id *id);1768 __isl_give isl_multi_aff *isl_multi_aff_set_range_tuple_id(1769 __isl_take isl_multi_aff *ma,1770 __isl_take isl_id *id);1771 __isl_give isl_multi_aff *isl_multi_aff_set_tuple_id(1772 __isl_take isl_multi_aff *maff,1773 enum isl_dim_type type, __isl_take isl_id *id);1774 __isl_give isl_pw_aff *isl_pw_aff_set_tuple_id(1775 __isl_take isl_pw_aff *pwaff,1776 enum isl_dim_type type, __isl_take isl_id *id);1777 __isl_give isl_pw_multi_aff *1778 isl_pw_multi_aff_set_range_tuple_id(1779 __isl_take isl_pw_multi_aff *pma,1780 __isl_take isl_id *id);1781 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_tuple_id(1782 __isl_take isl_pw_multi_aff *pma,1783 enum isl_dim_type type, __isl_take isl_id *id);1784 __isl_give isl_multi_pw_aff *1785 isl_multi_pw_aff_set_range_tuple_id(1786 __isl_take isl_multi_pw_aff *mpa,1787 __isl_take isl_id *id);1788 __isl_give isl_multi_union_pw_aff *1789 isl_multi_union_pw_aff_set_range_tuple_id(1790 __isl_take isl_multi_union_pw_aff *mupa,1791 __isl_take isl_id *id);1792 __isl_give isl_multi_union_pw_aff *1793 isl_multi_union_pw_aff_set_tuple_id(1794 __isl_take isl_multi_union_pw_aff *mupa,1795 enum isl_dim_type type, __isl_take isl_id *id);1796 __isl_give isl_multi_aff *1797 isl_multi_aff_reset_range_tuple_id(1798 __isl_take isl_multi_aff *ma);1799 __isl_give isl_multi_pw_aff *1800 isl_multi_pw_aff_reset_range_tuple_id(1801 __isl_take isl_multi_pw_aff *mpa);1802 __isl_give isl_multi_union_pw_aff *1803 isl_multi_union_pw_aff_reset_range_tuple_id(1804 __isl_take isl_multi_union_pw_aff *mupa);1805 __isl_give isl_multi_aff *isl_multi_aff_reset_tuple_id(1806 __isl_take isl_multi_aff *ma,1807 enum isl_dim_type type);1808 __isl_give isl_pw_aff *isl_pw_aff_reset_tuple_id(1809 __isl_take isl_pw_aff *pa,1810 enum isl_dim_type type);1811 __isl_give isl_multi_pw_aff *1812 isl_multi_pw_aff_reset_tuple_id(1813 __isl_take isl_multi_pw_aff *mpa,1814 enum isl_dim_type type);1815 __isl_give isl_pw_multi_aff *1816 isl_pw_multi_aff_reset_tuple_id(1817 __isl_take isl_pw_multi_aff *pma,1818 enum isl_dim_type type);1819 __isl_give isl_multi_union_pw_aff *1820 isl_multi_union_pw_aff_reset_tuple_id(1821 __isl_take isl_multi_union_pw_aff *mupa,1822 enum isl_dim_type type);1823 isl_bool isl_multi_aff_has_range_tuple_id(1824 __isl_keep isl_multi_aff *ma);1825 __isl_give isl_id *isl_multi_aff_get_range_tuple_id(1826 __isl_keep isl_multi_aff *ma);1827 isl_bool isl_multi_aff_has_tuple_id(1828 __isl_keep isl_multi_aff *ma,1829 enum isl_dim_type type);1830 __isl_give isl_id *isl_multi_aff_get_tuple_id(1831 __isl_keep isl_multi_aff *ma,1832 enum isl_dim_type type);1833 isl_bool isl_pw_aff_has_tuple_id(__isl_keep isl_pw_aff *pa,1834 enum isl_dim_type type);1835 __isl_give isl_id *isl_pw_aff_get_tuple_id(1836 __isl_keep isl_pw_aff *pa,1837 enum isl_dim_type type);1838 isl_bool isl_pw_multi_aff_has_range_tuple_id(1839 __isl_keep isl_pw_multi_aff *pma);1840 isl_bool isl_pw_multi_aff_has_tuple_id(1841 __isl_keep isl_pw_multi_aff *pma,1842 enum isl_dim_type type);1843 __isl_give isl_id *isl_pw_multi_aff_get_range_tuple_id(1844 __isl_keep isl_pw_multi_aff *pma);1845 __isl_give isl_id *isl_pw_multi_aff_get_tuple_id(1846 __isl_keep isl_pw_multi_aff *pma,1847 enum isl_dim_type type);1848 isl_bool isl_multi_pw_aff_has_range_tuple_id(1849 __isl_keep isl_multi_pw_aff *mpa);1850 __isl_give isl_id *isl_multi_pw_aff_get_range_tuple_id(1851 __isl_keep isl_multi_pw_aff *mpa);1852 isl_bool isl_multi_pw_aff_has_tuple_id(1853 __isl_keep isl_multi_pw_aff *mpa,1854 enum isl_dim_type type);1855 __isl_give isl_id *isl_multi_pw_aff_get_tuple_id(1856 __isl_keep isl_multi_pw_aff *mpa,1857 enum isl_dim_type type);1858 isl_bool isl_multi_union_pw_aff_has_range_tuple_id(1859 __isl_keep isl_multi_union_pw_aff *mupa);1860 __isl_give isl_id *1861 isl_multi_union_pw_aff_get_range_tuple_id(1862 __isl_keep isl_multi_union_pw_aff *mupa);1863 isl_bool isl_multi_union_pw_aff_has_tuple_id(1864 __isl_keep isl_multi_union_pw_aff *mupa,1865 enum isl_dim_type type);1866 __isl_give isl_id *isl_multi_union_pw_aff_get_tuple_id(1867 __isl_keep isl_multi_union_pw_aff *mupa,1868 enum isl_dim_type type);1869 __isl_give isl_multi_aff *isl_multi_aff_set_tuple_name(1870 __isl_take isl_multi_aff *maff,1871 enum isl_dim_type type, const char *s);1872 __isl_give isl_multi_pw_aff *1873 isl_multi_pw_aff_set_tuple_name(1874 __isl_take isl_multi_pw_aff *mpa,1875 enum isl_dim_type type, const char *s);1876 __isl_give isl_multi_union_pw_aff *1877 isl_multi_union_pw_aff_set_tuple_name(1878 __isl_take isl_multi_union_pw_aff *mupa,1879 enum isl_dim_type type, const char *s);1880 const char *isl_multi_aff_get_tuple_name(1881 __isl_keep isl_multi_aff *multi,1882 enum isl_dim_type type);1883 isl_bool isl_pw_multi_aff_has_tuple_name(1884 __isl_keep isl_pw_multi_aff *pma,1885 enum isl_dim_type type);1886 const char *isl_pw_multi_aff_get_tuple_name(1887 __isl_keep isl_pw_multi_aff *pma,1888 enum isl_dim_type type);1889 const char *isl_multi_union_pw_aff_get_tuple_name(1890 __isl_keep isl_multi_union_pw_aff *mupa,1891 enum isl_dim_type type);1892 1893The C<type> argument needs to be one of C<isl_dim_in>, C<isl_dim_out>1894or C<isl_dim_set>. As with C<isl_space_get_name>,1895the C<isl_space_get_tuple_name> function returns a pointer to some internal1896data structure.1897Binary operations require the corresponding spaces of their arguments1898to have the same name.1899 1900To keep the names of all parameters and tuples, but reset the user pointers1901of all the corresponding identifiers, use the following function.1902 1903 #include <isl/space.h>1904 __isl_give isl_space *isl_space_reset_user(1905 __isl_take isl_space *space);1906 1907 #include <isl/set.h>1908 __isl_give isl_set *isl_set_reset_user(1909 __isl_take isl_set *set);1910 1911 #include <isl/map.h>1912 __isl_give isl_map *isl_map_reset_user(1913 __isl_take isl_map *map);1914 1915 #include <isl/union_set.h>1916 __isl_give isl_union_set *isl_union_set_reset_user(1917 __isl_take isl_union_set *uset);1918 1919 #include <isl/union_map.h>1920 __isl_give isl_union_map *isl_union_map_reset_user(1921 __isl_take isl_union_map *umap);1922 1923 #include <isl/id.h>1924 __isl_give isl_multi_id *isl_multi_id_reset_user(1925 __isl_take isl_multi_id *mi);1926 1927 #include <isl/val.h>1928 __isl_give isl_multi_val *isl_multi_val_reset_user(1929 __isl_take isl_multi_val *mv);1930 1931 #include <isl/aff.h>1932 __isl_give isl_multi_aff *isl_multi_aff_reset_user(1933 __isl_take isl_multi_aff *ma);1934 __isl_give isl_pw_aff *isl_pw_aff_reset_user(1935 __isl_take isl_pw_aff *pa);1936 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_reset_user(1937 __isl_take isl_multi_pw_aff *mpa);1938 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_reset_user(1939 __isl_take isl_pw_multi_aff *pma);1940 __isl_give isl_union_pw_aff *isl_union_pw_aff_reset_user(1941 __isl_take isl_union_pw_aff *upa);1942 __isl_give isl_multi_union_pw_aff *1943 isl_multi_union_pw_aff_reset_user(1944 __isl_take isl_multi_union_pw_aff *mupa);1945 __isl_give isl_union_pw_multi_aff *1946 isl_union_pw_multi_aff_reset_user(1947 __isl_take isl_union_pw_multi_aff *upma);1948 1949 #include <isl/polynomial.h>1950 __isl_give isl_pw_qpolynomial *1951 isl_pw_qpolynomial_reset_user(1952 __isl_take isl_pw_qpolynomial *pwqp);1953 __isl_give isl_union_pw_qpolynomial *1954 isl_union_pw_qpolynomial_reset_user(1955 __isl_take isl_union_pw_qpolynomial *upwqp);1956 __isl_give isl_pw_qpolynomial_fold *1957 isl_pw_qpolynomial_fold_reset_user(1958 __isl_take isl_pw_qpolynomial_fold *pwf);1959 __isl_give isl_union_pw_qpolynomial_fold *1960 isl_union_pw_qpolynomial_fold_reset_user(1961 __isl_take isl_union_pw_qpolynomial_fold *upwf);1962 1963Spaces can be nested. In particular, the domain of a set or1964the domain or range of a relation can be a nested relation.1965This process is also called I<wrapping>.1966The functions for detecting, constructing and deconstructing1967such nested spaces can be found in the wrapping properties1968of L</"Unary Properties">, the wrapping operations1969of L</"Unary Operations"> and the Cartesian product operations1970of L</"Basic Operations">.1971 1972Spaces can be created from other spaces1973using the functions described in L</"Unary Operations">1974and L</"Binary Operations">.1975 1976=head2 Local Spaces1977 1978A local space is essentially a space with1979zero or more existentially quantified variables.1980The local space of various objects can be obtained1981using the following functions.1982 1983 #include <isl/constraint.h>1984 __isl_give isl_local_space *isl_constraint_get_local_space(1985 __isl_keep isl_constraint *constraint);1986 1987 #include <isl/set.h>1988 __isl_give isl_local_space *isl_basic_set_get_local_space(1989 __isl_keep isl_basic_set *bset);1990 1991 #include <isl/map.h>1992 __isl_give isl_local_space *isl_basic_map_get_local_space(1993 __isl_keep isl_basic_map *bmap);1994 1995 #include <isl/aff.h>1996 __isl_give isl_local_space *isl_aff_get_domain_local_space(1997 __isl_keep isl_aff *aff);1998 __isl_give isl_local_space *isl_aff_get_local_space(1999 __isl_keep isl_aff *aff);2000 2001A new local space can be created from a space using2002 2003 #include <isl/local_space.h>2004 __isl_give isl_local_space *isl_local_space_from_space(2005 __isl_take isl_space *space);2006 2007They can be inspected, modified, copied and freed using the following functions.2008 2009 #include <isl/local_space.h>2010 isl_bool isl_local_space_is_params(2011 __isl_keep isl_local_space *ls);2012 isl_bool isl_local_space_is_set(2013 __isl_keep isl_local_space *ls);2014 __isl_give isl_space *isl_local_space_get_space(2015 __isl_keep isl_local_space *ls);2016 __isl_give isl_aff *isl_local_space_get_div(2017 __isl_keep isl_local_space *ls, int pos);2018 __isl_give isl_local_space *isl_local_space_copy(2019 __isl_keep isl_local_space *ls);2020 __isl_null isl_local_space *isl_local_space_free(2021 __isl_take isl_local_space *ls);2022 2023Note that C<isl_local_space_get_div> can only be used on local spaces2024of sets.2025 2026Two local spaces can be compared using2027 2028 isl_bool isl_local_space_is_equal(2029 __isl_keep isl_local_space *ls1,2030 __isl_keep isl_local_space *ls2);2031 2032Local spaces can be created from other local spaces2033using the functions described in L</"Unary Operations">2034and L</"Binary Operations">.2035 2036=head2 Creating New Sets and Relations2037 2038C<isl> has functions for creating some standard sets and relations.2039 2040=over2041 2042=item * Empty sets and relations2043 2044 __isl_give isl_basic_set *isl_basic_set_empty(2045 __isl_take isl_space *space);2046 __isl_give isl_basic_map *isl_basic_map_empty(2047 __isl_take isl_space *space);2048 __isl_give isl_set *isl_set_empty(2049 __isl_take isl_space *space);2050 __isl_give isl_map *isl_map_empty(2051 __isl_take isl_space *space);2052 __isl_give isl_union_set *isl_union_set_empty_ctx(2053 isl_ctx *ctx);2054 __isl_give isl_union_set *isl_union_set_empty_space(2055 __isl_take isl_space *space);2056 __isl_give isl_union_set *isl_union_set_empty(2057 __isl_take isl_space *space);2058 __isl_give isl_union_map *isl_union_map_empty_ctx(2059 isl_ctx *ctx);2060 __isl_give isl_union_map *isl_union_map_empty_space(2061 __isl_take isl_space *space);2062 __isl_give isl_union_map *isl_union_map_empty(2063 __isl_take isl_space *space);2064 2065For C<isl_union_set>s and C<isl_union_map>s, the space2066is only used to specify the parameters.2067C<isl_union_set_empty> is an alternative name for2068C<isl_union_set_empty_space>.2069Similarly for the other pair of functions.2070 2071=item * Universe sets and relations2072 2073 #include <isl/set.h>2074 __isl_give isl_basic_set *isl_basic_set_universe(2075 __isl_take isl_space *space);2076 __isl_give isl_set *isl_set_universe(2077 __isl_take isl_space *space);2078 __isl_give isl_set *isl_space_universe_set(2079 __isl_take isl_space *space);2080 2081 #include <isl/map.h>2082 __isl_give isl_basic_map *isl_basic_map_universe(2083 __isl_take isl_space *space);2084 __isl_give isl_map *isl_map_universe(2085 __isl_take isl_space *space);2086 __isl_give isl_map *isl_space_universe_map(2087 __isl_take isl_space *space);2088 2089 #include <isl/union_set.h>2090 __isl_give isl_union_set *isl_union_set_universe(2091 __isl_take isl_union_set *uset);2092 2093 #include <isl/union_map.h>2094 __isl_give isl_union_map *isl_union_map_universe(2095 __isl_take isl_union_map *umap);2096 2097C<isl_set_universe> and C<isl_space_universe_set>2098perform the same operation.2099Similarly2100for the pair C<isl_map_universe> and C<isl_space_universe_map>.2101 2102The sets and relations constructed by the functions above2103contain all integer values, while those constructed by the2104functions below only contain non-negative values.2105 2106 __isl_give isl_basic_set *isl_basic_set_nat_universe(2107 __isl_take isl_space *space);2108 __isl_give isl_basic_map *isl_basic_map_nat_universe(2109 __isl_take isl_space *space);2110 __isl_give isl_set *isl_set_nat_universe(2111 __isl_take isl_space *space);2112 __isl_give isl_map *isl_map_nat_universe(2113 __isl_take isl_space *space);2114 2115=item * Identity relations2116 2117 __isl_give isl_basic_map *isl_basic_map_identity(2118 __isl_take isl_space *space);2119 __isl_give isl_map *isl_map_identity(2120 __isl_take isl_space *space);2121 2122The number of input and output dimensions in C<space> needs2123to be the same.2124 2125=item * Lexicographic order2126 2127 __isl_give isl_map *isl_map_lex_lt(2128 __isl_take isl_space *set_space);2129 __isl_give isl_map *isl_map_lex_le(2130 __isl_take isl_space *set_space);2131 __isl_give isl_map *isl_map_lex_gt(2132 __isl_take isl_space *set_space);2133 __isl_give isl_map *isl_map_lex_ge(2134 __isl_take isl_space *set_space);2135 __isl_give isl_map *isl_map_lex_lt_first(2136 __isl_take isl_space *space, unsigned n);2137 __isl_give isl_map *isl_map_lex_le_first(2138 __isl_take isl_space *space, unsigned n);2139 __isl_give isl_map *isl_map_lex_gt_first(2140 __isl_take isl_space *space, unsigned n);2141 __isl_give isl_map *isl_map_lex_ge_first(2142 __isl_take isl_space *space, unsigned n);2143 2144The first four functions take a space for a B<set>2145and return relations that express that the elements in the domain2146are lexicographically less2147(C<isl_map_lex_lt>), less or equal (C<isl_map_lex_le>),2148greater (C<isl_map_lex_gt>) or greater or equal (C<isl_map_lex_ge>)2149than the elements in the range.2150The last four functions take a space for a map2151and return relations that express that the first C<n> dimensions2152in the domain are lexicographically less2153(C<isl_map_lex_lt_first>), less or equal (C<isl_map_lex_le_first>),2154greater (C<isl_map_lex_gt_first>) or greater or equal (C<isl_map_lex_ge_first>)2155than the first C<n> dimensions in the range.2156 2157=back2158 2159A basic set or relation can be converted to a set or relation2160using the following functions.2161 2162 __isl_give isl_set *isl_basic_set_to_set(2163 __isl_take isl_basic_set *bset);2164 __isl_give isl_set *isl_set_from_basic_set(2165 __isl_take isl_basic_set *bset);2166 __isl_give isl_map *isl_map_from_basic_map(2167 __isl_take isl_basic_map *bmap);2168 2169C<isl_basic_set_to_set> and C<isl_set_from_basic_set> perform2170the same operation.2171 2172Sets and relations can be converted to union sets and relations2173using the following functions.2174 2175 __isl_give isl_union_set *isl_union_set_from_basic_set(2176 __isl_take isl_basic_set *bset);2177 __isl_give isl_union_map *isl_union_map_from_basic_map(2178 __isl_take isl_basic_map *bmap);2179 __isl_give isl_union_set *isl_set_to_union_set(2180 __isl_take isl_set *set);2181 __isl_give isl_union_set *isl_union_set_from_set(2182 __isl_take isl_set *set);2183 __isl_give isl_union_map *isl_map_to_union_map(2184 __isl_take isl_map *map);2185 __isl_give isl_union_map *isl_union_map_from_map(2186 __isl_take isl_map *map);2187 2188C<isl_map_to_union_map> and C<isl_union_map_from_map> perform2189the same operation.2190Similarly for C<isl_set_to_union_set> and C<isl_union_set_from_set>.2191 2192The inverse conversions below can only be used if the input2193union set or relation is known to contain elements in exactly one2194space.2195 2196 #include <isl/union_set.h>2197 isl_bool isl_union_set_isa_set(2198 __isl_keep isl_union_set *uset);2199 __isl_give isl_set *isl_union_set_as_set(2200 __isl_take isl_union_set *uset);2201 __isl_give isl_set *isl_set_from_union_set(2202 __isl_take isl_union_set *uset);2203 2204 #include <isl/union_map.h>2205 isl_bool isl_union_map_isa_map(2206 __isl_keep isl_union_map *umap);2207 __isl_give isl_map *isl_union_map_as_map(2208 __isl_take isl_union_map *umap);2209 __isl_give isl_map *isl_map_from_union_map(2210 __isl_take isl_union_map *umap);2211 2212C<isl_union_map_as_map> and C<isl_map_from_union_map> perform2213the same operation.2214Similarly for C<isl_union_set_as_set> and C<isl_set_from_union_set>.2215 2216Sets and relations can be copied and freed again using the following2217functions.2218 2219 __isl_give isl_basic_set *isl_basic_set_copy(2220 __isl_keep isl_basic_set *bset);2221 __isl_give isl_set *isl_set_copy(__isl_keep isl_set *set);2222 __isl_give isl_union_set *isl_union_set_copy(2223 __isl_keep isl_union_set *uset);2224 __isl_give isl_basic_map *isl_basic_map_copy(2225 __isl_keep isl_basic_map *bmap);2226 __isl_give isl_map *isl_map_copy(__isl_keep isl_map *map);2227 __isl_give isl_union_map *isl_union_map_copy(2228 __isl_keep isl_union_map *umap);2229 __isl_null isl_basic_set *isl_basic_set_free(2230 __isl_take isl_basic_set *bset);2231 __isl_null isl_set *isl_set_free(__isl_take isl_set *set);2232 __isl_null isl_union_set *isl_union_set_free(2233 __isl_take isl_union_set *uset);2234 __isl_null isl_basic_map *isl_basic_map_free(2235 __isl_take isl_basic_map *bmap);2236 __isl_null isl_map *isl_map_free(__isl_take isl_map *map);2237 __isl_null isl_union_map *isl_union_map_free(2238 __isl_take isl_union_map *umap);2239 2240Other sets and relations can be constructed by starting2241from a universe set or relation, adding equality and/or2242inequality constraints and then projecting out the2243existentially quantified variables, if any.2244Constraints can be constructed, manipulated and2245added to (or removed from) (basic) sets and relations2246using the following functions.2247 2248 #include <isl/constraint.h>2249 __isl_give isl_constraint *isl_constraint_alloc_equality(2250 __isl_take isl_local_space *ls);2251 __isl_give isl_constraint *isl_constraint_alloc_inequality(2252 __isl_take isl_local_space *ls);2253 __isl_give isl_constraint *isl_constraint_set_constant_si(2254 __isl_take isl_constraint *constraint, int v);2255 __isl_give isl_constraint *isl_constraint_set_constant_val(2256 __isl_take isl_constraint *constraint,2257 __isl_take isl_val *v);2258 __isl_give isl_constraint *isl_constraint_set_coefficient_si(2259 __isl_take isl_constraint *constraint,2260 enum isl_dim_type type, int pos, int v);2261 __isl_give isl_constraint *2262 isl_constraint_set_coefficient_val(2263 __isl_take isl_constraint *constraint,2264 enum isl_dim_type type, int pos,2265 __isl_take isl_val *v);2266 __isl_give isl_basic_map *isl_basic_map_add_constraint(2267 __isl_take isl_basic_map *bmap,2268 __isl_take isl_constraint *constraint);2269 __isl_give isl_basic_set *isl_basic_set_add_constraint(2270 __isl_take isl_basic_set *bset,2271 __isl_take isl_constraint *constraint);2272 __isl_give isl_map *isl_map_add_constraint(2273 __isl_take isl_map *map,2274 __isl_take isl_constraint *constraint);2275 __isl_give isl_set *isl_set_add_constraint(2276 __isl_take isl_set *set,2277 __isl_take isl_constraint *constraint);2278 2279For example, to create a set containing the even integers2280between 10 and 42, you could use the following code.2281 2282 isl_space *space;2283 isl_local_space *ls;2284 isl_constraint *c;2285 isl_basic_set *bset;2286 2287 space = isl_space_set_alloc(ctx, 0, 2);2288 bset = isl_basic_set_universe(isl_space_copy(space));2289 ls = isl_local_space_from_space(space);2290 2291 c = isl_constraint_alloc_equality(isl_local_space_copy(ls));2292 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);2293 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 2);2294 bset = isl_basic_set_add_constraint(bset, c);2295 2296 c = isl_constraint_alloc_inequality(isl_local_space_copy(ls));2297 c = isl_constraint_set_constant_si(c, -10);2298 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);2299 bset = isl_basic_set_add_constraint(bset, c);2300 2301 c = isl_constraint_alloc_inequality(ls);2302 c = isl_constraint_set_constant_si(c, 42);2303 c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);2304 bset = isl_basic_set_add_constraint(bset, c);2305 2306 bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 1);2307 2308However, this is considered to be a fairly low-level approach.2309It is more appropriate to construct a (basic) set by means2310of affine expressions (defined below in L</"Functions">).2311For example, the same set could be constructed as follows.2312 2313 isl_val *v, *two;2314 isl_space *space;2315 isl_multi_aff *ma;2316 isl_aff *var, *cst;2317 isl_basic_set *bset;2318 2319 space = isl_space_unit(ctx);2320 space = isl_space_add_unnamed_tuple_ui(space, 1);2321 ma = isl_multi_aff_identity_on_domain_space(2322 isl_space_copy(space));2323 var = isl_multi_aff_get_at(ma, 0);2324 v = isl_val_int_from_si(ctx, 10);2325 cst = isl_aff_val_on_domain_space(isl_space_copy(space), v);2326 bset = isl_aff_ge_basic_set(isl_aff_copy(var), cst);2327 2328 v = isl_val_int_from_si(ctx, 42);2329 cst = isl_aff_val_on_domain_space(space, v);2330 bset = isl_basic_set_intersect(bset,2331 isl_aff_le_basic_set(var, cst));2332 2333 two = isl_val_int_from_si(ctx, 2);2334 ma = isl_multi_aff_scale_val(ma, isl_val_copy(two));2335 bset = isl_basic_set_preimage_multi_aff(bset,2336 isl_multi_aff_copy(ma));2337 ma = isl_multi_aff_scale_down_val(ma, isl_val_copy(two));2338 ma = isl_multi_aff_scale_down_val(ma, two);2339 bset = isl_basic_set_preimage_multi_aff(bset, ma);2340 2341Alternatively, the set can be parsed from a string representation.2342 2343 isl_basic_set *bset;2344 bset = isl_basic_set_read_from_str(ctx,2345 "{[i] : exists (a : i = 2a and i >= 10 and i <= 42)}");2346 2347A basic set or relation can also be constructed from two matrices2348describing the equalities and the inequalities.2349 2350 __isl_give isl_basic_set *isl_basic_set_from_constraint_matrices(2351 __isl_take isl_space *space,2352 __isl_take isl_mat *eq, __isl_take isl_mat *ineq,2353 enum isl_dim_type c1,2354 enum isl_dim_type c2, enum isl_dim_type c3,2355 enum isl_dim_type c4);2356 __isl_give isl_basic_map *isl_basic_map_from_constraint_matrices(2357 __isl_take isl_space *space,2358 __isl_take isl_mat *eq, __isl_take isl_mat *ineq,2359 enum isl_dim_type c1,2360 enum isl_dim_type c2, enum isl_dim_type c3,2361 enum isl_dim_type c4, enum isl_dim_type c5);2362 2363The C<isl_dim_type> arguments indicate the order in which2364different kinds of variables appear in the input matrices2365and should be a permutation of C<isl_dim_cst> (the constant term),2366C<isl_dim_param>, C<isl_dim_set> and C<isl_dim_div> for sets and2367of C<isl_dim_cst>, C<isl_dim_param>,2368C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div> for relations.2369 2370A (basic or union) set or relation can also be constructed from a2371(union) (piecewise) (multiple) affine expression2372or a list of affine expressions2373(See L</"Functions">), provided these affine expressions do not2374involve any NaN.2375 2376 #include <isl/set.h>2377 __isl_give isl_basic_set *isl_basic_set_from_multi_aff(2378 __isl_take isl_multi_aff *ma);2379 __isl_give isl_set *isl_multi_aff_as_set(2380 __isl_take isl_multi_aff *ma);2381 __isl_give isl_set *isl_set_from_multi_aff(2382 __isl_take isl_multi_aff *ma);2383 2384 #include <isl/map.h>2385 __isl_give isl_basic_map *isl_basic_map_from_aff(2386 __isl_take isl_aff *aff);2387 __isl_give isl_map *isl_map_from_aff(2388 __isl_take isl_aff *aff);2389 __isl_give isl_basic_map *isl_basic_map_from_aff_list(2390 __isl_take isl_space *domain_space,2391 __isl_take isl_aff_list *list);2392 __isl_give isl_basic_map *isl_basic_map_from_multi_aff(2393 __isl_take isl_multi_aff *maff)2394 __isl_give isl_map *isl_multi_aff_as_map(2395 __isl_take isl_multi_aff *ma);2396 __isl_give isl_map *isl_map_from_multi_aff(2397 __isl_take isl_multi_aff *maff)2398 2399 #include <isl/aff.h>2400 __isl_give isl_set *isl_set_from_pw_aff(2401 __isl_take isl_pw_aff *pwaff);2402 __isl_give isl_map *isl_pw_aff_as_map(2403 __isl_take isl_pw_aff *pa);2404 __isl_give isl_map *isl_map_from_pw_aff(2405 __isl_take isl_pw_aff *pwaff);2406 __isl_give isl_set *isl_pw_multi_aff_as_set(2407 __isl_take isl_pw_multi_aff *pma);2408 __isl_give isl_set *isl_set_from_pw_multi_aff(2409 __isl_take isl_pw_multi_aff *pma);2410 __isl_give isl_map *isl_pw_multi_aff_as_map(2411 __isl_take isl_pw_multi_aff *pma);2412 __isl_give isl_map *isl_map_from_pw_multi_aff(2413 __isl_take isl_pw_multi_aff *pma);2414 __isl_give isl_set *isl_multi_pw_aff_as_set(2415 __isl_take isl_multi_pw_aff *mpa);2416 __isl_give isl_set *isl_set_from_multi_pw_aff(2417 __isl_take isl_multi_pw_aff *mpa);2418 __isl_give isl_map *isl_multi_pw_aff_as_map(2419 __isl_take isl_multi_pw_aff *mpa);2420 __isl_give isl_map *isl_map_from_multi_pw_aff(2421 __isl_take isl_multi_pw_aff *mpa);2422 __isl_give isl_union_map *isl_union_map_from_union_pw_aff(2423 __isl_take isl_union_pw_aff *upa);2424 __isl_give isl_union_map *2425 isl_union_pw_multi_aff_as_union_map(2426 __isl_take isl_union_pw_multi_aff *upma);2427 __isl_give isl_union_map *2428 isl_union_map_from_union_pw_multi_aff(2429 __isl_take isl_union_pw_multi_aff *upma);2430 __isl_give isl_union_map *2431 isl_union_map_from_multi_union_pw_aff(2432 __isl_take isl_multi_union_pw_aff *mupa);2433 2434The C<domain_space> argument describes the domain of the resulting2435basic relation. It is required because the C<list> may consist2436of zero affine expressions.2437The C<mupa> passed to C<isl_union_map_from_multi_union_pw_aff>2438is not allowed to be zero-dimensional. The domain of the result2439is the shared domain of the union piecewise affine elements.2440C<isl_multi_aff_as_set> and C<isl_set_from_multi_aff> perform2441the same operation.2442Similarly for the pair C<isl_multi_aff_as_map> and C<isl_map_from_multi_aff>,2443for the pair C<isl_pw_aff_as_map> and C<isl_map_from_pw_aff>,2444for the pair C<isl_pw_multi_aff_as_set> and C<isl_set_from_pw_multi_aff>,2445for the pair C<isl_pw_multi_aff_as_map> and C<isl_map_from_pw_multi_aff>,2446the pair C<isl_multi_pw_aff_as_set> and C<isl_set_from_multi_pw_aff>,2447the pair C<isl_multi_pw_aff_as_map> and C<isl_map_from_multi_pw_aff>,2448and2449C<isl_union_pw_multi_aff_as_union_map> and2450C<isl_union_map_from_union_pw_multi_aff>.2451 2452=head2 Inspecting Sets and Relations2453 2454Usually, the user should not have to care about the actual constraints2455of the sets and maps, but should instead apply the abstract operations2456explained in the following sections.2457Occasionally, however, it may be required to inspect the individual2458coefficients of the constraints. This section explains how to do so.2459In these cases, it may also be useful to have C<isl> compute2460an explicit representation of the existentially quantified variables.2461 2462 __isl_give isl_set *isl_set_compute_divs(2463 __isl_take isl_set *set);2464 __isl_give isl_map *isl_map_compute_divs(2465 __isl_take isl_map *map);2466 __isl_give isl_union_set *isl_union_set_compute_divs(2467 __isl_take isl_union_set *uset);2468 __isl_give isl_union_map *isl_union_map_compute_divs(2469 __isl_take isl_union_map *umap);2470 2471This explicit representation defines the existentially quantified2472variables as integer divisions of the other variables, possibly2473including earlier existentially quantified variables.2474An explicitly represented existentially quantified variable therefore2475has a unique value when the values of the other variables are known.2476 2477Alternatively, the existentially quantified variables can be removed2478using the following functions, which compute an overapproximation.2479 2480 #include <isl/set.h>2481 __isl_give isl_basic_set *isl_basic_set_remove_divs(2482 __isl_take isl_basic_set *bset);2483 __isl_give isl_set *isl_set_remove_divs(2484 __isl_take isl_set *set);2485 2486 #include <isl/map.h>2487 __isl_give isl_basic_map *isl_basic_map_remove_divs(2488 __isl_take isl_basic_map *bmap);2489 __isl_give isl_map *isl_map_remove_divs(2490 __isl_take isl_map *map);2491 2492 #include <isl/union_set.h>2493 __isl_give isl_union_set *isl_union_set_remove_divs(2494 __isl_take isl_union_set *bset);2495 2496 #include <isl/union_map.h>2497 __isl_give isl_union_map *isl_union_map_remove_divs(2498 __isl_take isl_union_map *bmap);2499 2500It is also possible to only remove those divs that are defined2501in terms of a given range of dimensions or only those for which2502no explicit representation is known.2503 2504 __isl_give isl_basic_set *2505 isl_basic_set_remove_divs_involving_dims(2506 __isl_take isl_basic_set *bset,2507 enum isl_dim_type type,2508 unsigned first, unsigned n);2509 __isl_give isl_basic_map *2510 isl_basic_map_remove_divs_involving_dims(2511 __isl_take isl_basic_map *bmap,2512 enum isl_dim_type type,2513 unsigned first, unsigned n);2514 __isl_give isl_set *isl_set_remove_divs_involving_dims(2515 __isl_take isl_set *set, enum isl_dim_type type,2516 unsigned first, unsigned n);2517 __isl_give isl_map *isl_map_remove_divs_involving_dims(2518 __isl_take isl_map *map, enum isl_dim_type type,2519 unsigned first, unsigned n);2520 2521 __isl_give isl_basic_set *2522 isl_basic_set_remove_unknown_divs(2523 __isl_take isl_basic_set *bset);2524 __isl_give isl_set *isl_set_remove_unknown_divs(2525 __isl_take isl_set *set);2526 __isl_give isl_map *isl_map_remove_unknown_divs(2527 __isl_take isl_map *map);2528 2529To iterate over all the sets or maps in a union set or map, use2530 2531 #include <isl/union_set.h>2532 isl_stat isl_union_set_foreach_set(2533 __isl_keep isl_union_set *uset,2534 isl_stat (*fn)(__isl_take isl_set *set, void *user),2535 void *user);2536 isl_bool isl_union_set_every_set(2537 __isl_keep isl_union_set *uset,2538 isl_bool (*test)(__isl_keep isl_set *set,2539 void *user),2540 void *user);2541 2542 #include <isl/union_map.h>2543 isl_stat isl_union_map_foreach_map(2544 __isl_keep isl_union_map *umap,2545 isl_stat (*fn)(__isl_take isl_map *map, void *user),2546 void *user);2547 isl_bool isl_union_map_every_map(2548 __isl_keep isl_union_map *umap,2549 isl_bool (*test)(__isl_keep isl_map *map,2550 void *user),2551 void *user);2552 2553These functions call the callback function once for each2554(pair of) space(s) for which there are elements in the input.2555The argument to the callback contains all elements in the input2556with that (pair of) space(s).2557The C<isl_union_set_every_set> and2558C<isl_union_map_every_map> variants check whether each2559call to the callback returns true and stops checking as soon as one2560of these calls returns false.2561 2562The number of sets or maps in a union set or map can be obtained2563from2564 2565 isl_size isl_union_set_n_set(__isl_keep isl_union_set *uset);2566 isl_size isl_union_map_n_map(__isl_keep isl_union_map *umap);2567 2568To extract the set or map in a given space from a union, use2569 2570 __isl_give isl_set *isl_union_set_extract_set(2571 __isl_keep isl_union_set *uset,2572 __isl_take isl_space *space);2573 __isl_give isl_map *isl_union_map_extract_map(2574 __isl_keep isl_union_map *umap,2575 __isl_take isl_space *space);2576 2577To iterate over all the basic sets or maps in a set or map, use2578 2579 isl_stat isl_set_foreach_basic_set(__isl_keep isl_set *set,2580 isl_stat (*fn)(__isl_take isl_basic_set *bset,2581 void *user),2582 void *user);2583 isl_stat isl_map_foreach_basic_map(__isl_keep isl_map *map,2584 isl_stat (*fn)(__isl_take isl_basic_map *bmap,2585 void *user),2586 void *user);2587 2588The callback function C<fn> should return C<isl_stat_ok> if successful and2589C<isl_stat_error> if an error occurs. In the latter case, or if any other error2590occurs, the above functions will return C<isl_stat_error>.2591 2592It should be noted that C<isl> does not guarantee that2593the basic sets or maps passed to C<fn> are disjoint.2594If this is required, then the user should call one of2595the following functions first.2596 2597 __isl_give isl_set *isl_set_make_disjoint(2598 __isl_take isl_set *set);2599 __isl_give isl_map *isl_map_make_disjoint(2600 __isl_take isl_map *map);2601 2602The number of basic sets in a set can be obtained2603or the number of basic maps in a map can be obtained2604from2605 2606 #include <isl/set.h>2607 isl_size isl_set_n_basic_set(__isl_keep isl_set *set);2608 2609 #include <isl/map.h>2610 isl_size isl_map_n_basic_map(__isl_keep isl_map *map);2611 2612It is also possible to obtain a list of (basic) sets from a set2613or union set, a list of basic maps from a map and a list of maps from a union2614map.2615 2616 #include <isl/set.h>2617 __isl_give isl_basic_set_list *isl_set_get_basic_set_list(2618 __isl_keep isl_set *set);2619 2620 #include <isl/union_set.h>2621 __isl_give isl_basic_set_list *2622 isl_union_set_get_basic_set_list(2623 __isl_keep isl_union_set *uset);2624 __isl_give isl_set_list *isl_union_set_get_set_list(2625 __isl_keep isl_union_set *uset);2626 2627 #include <isl/map.h>2628 __isl_give isl_basic_map_list *isl_map_get_basic_map_list(2629 __isl_keep isl_map *map);2630 2631 #include <isl/union_map.h>2632 __isl_give isl_map_list *isl_union_map_get_map_list(2633 __isl_keep isl_union_map *umap);2634 2635The returned list can be manipulated using the functions in L<"Lists">.2636 2637To iterate over the constraints of a basic set or map, use2638 2639 #include <isl/constraint.h>2640 2641 isl_size isl_basic_set_n_constraint(2642 __isl_keep isl_basic_set *bset);2643 isl_stat isl_basic_set_foreach_constraint(2644 __isl_keep isl_basic_set *bset,2645 isl_stat (*fn)(__isl_take isl_constraint *c,2646 void *user),2647 void *user);2648 isl_size isl_basic_map_n_constraint(2649 __isl_keep isl_basic_map *bmap);2650 isl_stat isl_basic_map_foreach_constraint(2651 __isl_keep isl_basic_map *bmap,2652 isl_stat (*fn)(__isl_take isl_constraint *c,2653 void *user),2654 void *user);2655 __isl_null isl_constraint *isl_constraint_free(2656 __isl_take isl_constraint *c);2657 2658Again, the callback function C<fn> should return C<isl_stat_ok>2659if successful and2660C<isl_stat_error> if an error occurs. In the latter case, or if any other error2661occurs, the above functions will return C<isl_stat_error>.2662The constraint C<c> represents either an equality or an inequality.2663Use the following function to find out whether a constraint2664represents an equality. If not, it represents an inequality.2665 2666 isl_bool isl_constraint_is_equality(2667 __isl_keep isl_constraint *constraint);2668 2669It is also possible to obtain a list of constraints from a basic2670map or set2671 2672 #include <isl/constraint.h>2673 __isl_give isl_constraint_list *2674 isl_basic_map_get_constraint_list(2675 __isl_keep isl_basic_map *bmap);2676 __isl_give isl_constraint_list *2677 isl_basic_set_get_constraint_list(2678 __isl_keep isl_basic_set *bset);2679 2680These functions require that all existentially quantified variables2681have an explicit representation.2682The returned list can be manipulated using the functions in L<"Lists">.2683 2684The coefficients of the constraints can be inspected using2685the following functions.2686 2687 isl_bool isl_constraint_is_lower_bound(2688 __isl_keep isl_constraint *constraint,2689 enum isl_dim_type type, unsigned pos);2690 isl_bool isl_constraint_is_upper_bound(2691 __isl_keep isl_constraint *constraint,2692 enum isl_dim_type type, unsigned pos);2693 __isl_give isl_val *isl_constraint_get_constant_val(2694 __isl_keep isl_constraint *constraint);2695 __isl_give isl_val *isl_constraint_get_coefficient_val(2696 __isl_keep isl_constraint *constraint,2697 enum isl_dim_type type, int pos);2698 2699The explicit representations of the existentially quantified2700variables can be inspected using the following function.2701Note that the user is only allowed to use this function2702if the inspected set or map is the result of a call2703to C<isl_set_compute_divs> or C<isl_map_compute_divs>.2704The existentially quantified variable is equal to the floor2705of the returned affine expression. The affine expression2706itself can be inspected using the functions in2707L</"Functions">.2708 2709 __isl_give isl_aff *isl_constraint_get_div(2710 __isl_keep isl_constraint *constraint, int pos);2711 2712To obtain the constraints of a basic set or map in matrix2713form, use the following functions.2714 2715 __isl_give isl_mat *isl_basic_set_equalities_matrix(2716 __isl_keep isl_basic_set *bset,2717 enum isl_dim_type c1, enum isl_dim_type c2,2718 enum isl_dim_type c3, enum isl_dim_type c4);2719 __isl_give isl_mat *isl_basic_set_inequalities_matrix(2720 __isl_keep isl_basic_set *bset,2721 enum isl_dim_type c1, enum isl_dim_type c2,2722 enum isl_dim_type c3, enum isl_dim_type c4);2723 __isl_give isl_mat *isl_basic_map_equalities_matrix(2724 __isl_keep isl_basic_map *bmap,2725 enum isl_dim_type c1,2726 enum isl_dim_type c2, enum isl_dim_type c3,2727 enum isl_dim_type c4, enum isl_dim_type c5);2728 __isl_give isl_mat *isl_basic_map_inequalities_matrix(2729 __isl_keep isl_basic_map *bmap,2730 enum isl_dim_type c1,2731 enum isl_dim_type c2, enum isl_dim_type c3,2732 enum isl_dim_type c4, enum isl_dim_type c5);2733 2734The C<isl_dim_type> arguments dictate the order in which2735different kinds of variables appear in the resulting matrix.2736For set inputs, they should be a permutation of2737C<isl_dim_cst> (the constant term), C<isl_dim_param>, C<isl_dim_set> and2738C<isl_dim_div>.2739For map inputs, they should be a permutation of2740C<isl_dim_cst>, C<isl_dim_param>,2741C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div>.2742 2743=head2 Points2744 2745Points are elements of a set. They can be used to construct2746simple sets (boxes) or they can be used to represent the2747individual elements of a set.2748The zero point (the origin) can be created using2749 2750 __isl_give isl_point *isl_point_zero(__isl_take isl_space *space);2751 2752The coordinates of a point can be inspected, set and changed2753using2754 2755 #include <isl/point.h>2756 __isl_give isl_multi_val *isl_point_get_multi_val(2757 __isl_keep isl_point *pnt);2758 __isl_give isl_val *isl_point_get_coordinate_val(2759 __isl_keep isl_point *pnt,2760 enum isl_dim_type type, int pos);2761 __isl_give isl_point *isl_point_set_coordinate_val(2762 __isl_take isl_point *pnt,2763 enum isl_dim_type type, int pos,2764 __isl_take isl_val *v);2765 2766 __isl_give isl_point *isl_point_add_ui(2767 __isl_take isl_point *pnt,2768 enum isl_dim_type type, int pos, unsigned val);2769 __isl_give isl_point *isl_point_sub_ui(2770 __isl_take isl_point *pnt,2771 enum isl_dim_type type, int pos, unsigned val);2772 2773Points can be copied or freed using2774 2775 __isl_give isl_point *isl_point_copy(2776 __isl_keep isl_point *pnt);2777 __isl_null isl_point *isl_point_free(2778 __isl_take isl_point *pnt);2779 2780A singleton set can be created from a point using the following functions.2781 2782 __isl_give isl_basic_set *isl_basic_set_from_point(2783 __isl_take isl_point *pnt);2784 __isl_give isl_set *isl_point_to_set(2785 __isl_take isl_point *pnt);2786 __isl_give isl_set *isl_set_from_point(2787 __isl_take isl_point *pnt);2788 __isl_give isl_union_set *isl_union_set_from_point(2789 __isl_take isl_point *pnt);2790 2791C<isl_point_to_set> and C<isl_set_from_point> perform2792the same operation.2793 2794A box can be created from two opposite extremal points using2795 2796 __isl_give isl_basic_set *isl_basic_set_box_from_points(2797 __isl_take isl_point *pnt1,2798 __isl_take isl_point *pnt2);2799 __isl_give isl_set *isl_set_box_from_points(2800 __isl_take isl_point *pnt1,2801 __isl_take isl_point *pnt2);2802 2803All elements of a B<bounded> (union) set can be enumerated using2804the following functions.2805 2806 isl_stat isl_set_foreach_point(__isl_keep isl_set *set,2807 isl_stat (*fn)(__isl_take isl_point *pnt,2808 void *user),2809 void *user);2810 isl_stat isl_union_set_foreach_point(2811 __isl_keep isl_union_set *uset,2812 isl_stat (*fn)(__isl_take isl_point *pnt,2813 void *user),2814 void *user);2815 2816The function C<fn> is called for each integer point in2817C<set> with as second argument the last argument of2818the C<isl_set_foreach_point> call. The function C<fn>2819should return C<isl_stat_ok> on success and C<isl_stat_error> on failure.2820In the latter case, C<isl_set_foreach_point> will stop2821enumerating and return C<isl_stat_error> as well.2822If the enumeration is performed successfully and to completion,2823then C<isl_set_foreach_point> returns C<isl_stat_ok>.2824 2825To obtain a single point of a (basic or union) set, use2826 2827 __isl_give isl_point *isl_basic_set_sample_point(2828 __isl_take isl_basic_set *bset);2829 __isl_give isl_point *isl_set_sample_point(2830 __isl_take isl_set *set);2831 __isl_give isl_point *isl_union_set_sample_point(2832 __isl_take isl_union_set *uset);2833 2834If C<set> does not contain any (integer) points, then the2835resulting point will be ``void'', a property that can be2836tested using2837 2838 isl_bool isl_point_is_void(__isl_keep isl_point *pnt);2839 2840=head2 Functions2841 2842Besides sets and relation, C<isl> also supports various types of functions.2843Each of these types is derived from the value type (see L</"Values">)2844or from one of two primitive function types2845through the application of zero or more type constructors.2846As a special case, a multiple expression can also be derived2847from an identifier (see L</"Identifiers">) although the result2848is not really a function.2849We first describe the primitive type and then we describe2850the types derived from these primitive types.2851 2852=head3 Primitive Functions2853 2854C<isl> support two primitive function types, quasi-affine2855expressions and quasipolynomials.2856A quasi-affine expression is defined either over a parameter2857space or over a set and is composed of integer constants,2858parameters and set variables, addition, subtraction and2859integer division by an integer constant.2860For example, the quasi-affine expression2861 2862 [n] -> { [x] -> [2*floor((4 n + x)/9)] }2863 2864maps C<x> to C<2*floor((4 n + x)/9>.2865A quasipolynomial is a polynomial expression in quasi-affine2866expression. That is, it additionally allows for multiplication.2867Note, though, that it is not allowed to construct an integer2868division of an expression involving multiplications.2869Here is an example of a quasipolynomial that is not2870quasi-affine expression2871 2872 [n] -> { [x] -> (n*floor((4 n + x)/9)) }2873 2874Note that the external representations of quasi-affine expressions2875and quasipolynomials are different. Quasi-affine expressions2876use a notation with square brackets just like binary relations,2877while quasipolynomials do not. This might change at some point.2878 2879If a primitive function is defined over a parameter space,2880then the space of the function itself is that of a set.2881If it is defined over a set, then the space of the function2882is that of a relation. In both cases, the set space (or2883the output space) is single-dimensional, anonymous and unstructured.2884To create functions with multiple dimensions or with other kinds2885of set or output spaces, use multiple expressions2886(see L</"Multiple Expressions">).2887 2888=over2889 2890=item * Quasi-affine Expressions2891 2892Besides the expressions described above, a quasi-affine2893expression can also be set to NaN. Such expressions2894typically represent a failure to represent a result2895as a quasi-affine expression.2896 2897The zero quasi affine expression or the quasi affine expression2898that is equal to a given value, parameter or2899a specified dimension on a given domain can be created using2900 2901 #include <isl/aff.h>2902 __isl_give isl_aff *isl_aff_zero_on_domain_space(2903 __isl_take isl_space *space);2904 __isl_give isl_aff *isl_space_zero_aff_on_domain(2905 __isl_take isl_space *space);2906 __isl_give isl_aff *isl_aff_zero_on_domain(2907 __isl_take isl_local_space *ls);2908 __isl_give isl_aff *isl_aff_val_on_domain_space(2909 __isl_take isl_space *space,2910 __isl_take isl_val *val);2911 __isl_give isl_aff *isl_aff_val_on_domain(2912 __isl_take isl_local_space *ls,2913 __isl_take isl_val *val);2914 __isl_give isl_aff *isl_aff_param_on_domain_space_id(2915 __isl_take isl_space *space,2916 __isl_take isl_id *id);2917 __isl_give isl_aff *isl_space_param_aff_on_domain_id(2918 __isl_take isl_space *space,2919 __isl_take isl_id *id);2920 __isl_give isl_aff *isl_aff_var_on_domain(2921 __isl_take isl_local_space *ls,2922 enum isl_dim_type type, unsigned pos);2923 __isl_give isl_aff *isl_aff_nan_on_domain_space(2924 __isl_take isl_space *space);2925 __isl_give isl_aff *isl_aff_nan_on_domain(2926 __isl_take isl_local_space *ls);2927 2928The space passed to C<isl_aff_param_on_domain_space_id>2929is required to have a parameter with the given identifier.2930C<isl_aff_param_on_domain_space_id> and2931C<isl_space_param_aff_on_domain_id> perform the same operation.2932 2933C<isl_aff_zero_on_domain_space> and C<isl_space_zero_aff_on_domain>2934perform the same operation.2935 2936Quasi affine expressions can be copied and freed using2937 2938 #include <isl/aff.h>2939 __isl_give isl_aff *isl_aff_copy(2940 __isl_keep isl_aff *aff);2941 __isl_null isl_aff *isl_aff_free(2942 __isl_take isl_aff *aff);2943 2944A (rational) bound on a dimension can be extracted from an C<isl_constraint>2945using the following function. The constraint is required to have2946a non-zero coefficient for the specified dimension.2947 2948 #include <isl/constraint.h>2949 __isl_give isl_aff *isl_constraint_get_bound(2950 __isl_keep isl_constraint *constraint,2951 enum isl_dim_type type, int pos);2952 2953The entire affine expression of the constraint can also be extracted2954using the following function.2955 2956 #include <isl/constraint.h>2957 __isl_give isl_aff *isl_constraint_get_aff(2958 __isl_keep isl_constraint *constraint);2959 2960Conversely, an equality constraint equating2961the affine expression to zero or an inequality constraint enforcing2962the affine expression to be non-negative, can be constructed using2963 2964 __isl_give isl_constraint *isl_equality_from_aff(2965 __isl_take isl_aff *aff);2966 __isl_give isl_constraint *isl_inequality_from_aff(2967 __isl_take isl_aff *aff);2968 2969The coefficients and the integer divisions of an affine expression2970can be inspected using the following functions.2971 2972 #include <isl/aff.h>2973 __isl_give isl_val *isl_aff_get_constant_val(2974 __isl_keep isl_aff *aff);2975 __isl_give isl_val *isl_aff_get_coefficient_val(2976 __isl_keep isl_aff *aff,2977 enum isl_dim_type type, int pos);2978 int isl_aff_coefficient_sgn(__isl_keep isl_aff *aff,2979 enum isl_dim_type type, int pos);2980 __isl_give isl_val *isl_aff_get_denominator_val(2981 __isl_keep isl_aff *aff);2982 __isl_give isl_aff *isl_aff_get_div(2983 __isl_keep isl_aff *aff, int pos);2984 2985They can be modified using the following functions.2986 2987 #include <isl/aff.h>2988 __isl_give isl_aff *isl_aff_set_constant_si(2989 __isl_take isl_aff *aff, int v);2990 __isl_give isl_aff *isl_aff_set_constant_val(2991 __isl_take isl_aff *aff, __isl_take isl_val *v);2992 __isl_give isl_aff *isl_aff_set_coefficient_si(2993 __isl_take isl_aff *aff,2994 enum isl_dim_type type, int pos, int v);2995 __isl_give isl_aff *isl_aff_set_coefficient_val(2996 __isl_take isl_aff *aff,2997 enum isl_dim_type type, int pos,2998 __isl_take isl_val *v);2999 3000 __isl_give isl_aff *isl_aff_add_constant_si(3001 __isl_take isl_aff *aff, int v);3002 __isl_give isl_aff *isl_aff_add_constant_val(3003 __isl_take isl_aff *aff, __isl_take isl_val *v);3004 __isl_give isl_aff *isl_aff_add_constant_num_si(3005 __isl_take isl_aff *aff, int v);3006 __isl_give isl_aff *isl_aff_add_coefficient_si(3007 __isl_take isl_aff *aff,3008 enum isl_dim_type type, int pos, int v);3009 __isl_give isl_aff *isl_aff_add_coefficient_val(3010 __isl_take isl_aff *aff,3011 enum isl_dim_type type, int pos,3012 __isl_take isl_val *v);3013 3014Note that C<isl_aff_set_constant_si> and C<isl_aff_set_coefficient_si>3015set the I<numerator> of the constant or coefficient, while3016C<isl_aff_set_constant_val> and C<isl_aff_set_coefficient_val> set3017the constant or coefficient as a whole.3018The C<add_constant> and C<add_coefficient> functions add an integer3019or rational value to3020the possibly rational constant or coefficient.3021The C<add_constant_num> functions add an integer value to3022the numerator.3023 3024=item * Quasipolynomials3025 3026Some simple quasipolynomials can be created using the following functions.3027 3028 #include <isl/polynomial.h>3029 __isl_give isl_qpolynomial *isl_qpolynomial_zero_on_domain(3030 __isl_take isl_space *domain);3031 __isl_give isl_qpolynomial *isl_qpolynomial_one_on_domain(3032 __isl_take isl_space *domain);3033 __isl_give isl_qpolynomial *isl_qpolynomial_infty_on_domain(3034 __isl_take isl_space *domain);3035 __isl_give isl_qpolynomial *isl_qpolynomial_neginfty_on_domain(3036 __isl_take isl_space *domain);3037 __isl_give isl_qpolynomial *isl_qpolynomial_nan_on_domain(3038 __isl_take isl_space *domain);3039 __isl_give isl_qpolynomial *isl_qpolynomial_val_on_domain(3040 __isl_take isl_space *domain,3041 __isl_take isl_val *val);3042 __isl_give isl_qpolynomial *isl_qpolynomial_var_on_domain(3043 __isl_take isl_space *domain,3044 enum isl_dim_type type, unsigned pos);3045 __isl_give isl_qpolynomial *isl_qpolynomial_from_aff(3046 __isl_take isl_aff *aff);3047 3048Recall that the space in which a quasipolynomial lives is a map space3049with a one-dimensional range. The C<domain> argument in some of3050the functions above corresponds to the domain of this map space.3051 3052Quasipolynomials can be copied and freed again using the following3053functions.3054 3055 #include <isl/polynomial.h>3056 __isl_give isl_qpolynomial *isl_qpolynomial_copy(3057 __isl_keep isl_qpolynomial *qp);3058 __isl_null isl_qpolynomial *isl_qpolynomial_free(3059 __isl_take isl_qpolynomial *qp);3060 3061The constant term of a quasipolynomial can be extracted using3062 3063 __isl_give isl_val *isl_qpolynomial_get_constant_val(3064 __isl_keep isl_qpolynomial *qp);3065 3066To iterate over all terms in a quasipolynomial,3067use3068 3069 isl_stat isl_qpolynomial_foreach_term(3070 __isl_keep isl_qpolynomial *qp,3071 isl_stat (*fn)(__isl_take isl_term *term,3072 void *user), void *user);3073 3074The terms themselves can be inspected and freed using3075these functions3076 3077 isl_size isl_term_dim(__isl_keep isl_term *term,3078 enum isl_dim_type type);3079 __isl_give isl_val *isl_term_get_coefficient_val(3080 __isl_keep isl_term *term);3081 isl_size isl_term_get_exp(__isl_keep isl_term *term,3082 enum isl_dim_type type, unsigned pos);3083 __isl_give isl_aff *isl_term_get_div(3084 __isl_keep isl_term *term, unsigned pos);3085 __isl_null isl_term *isl_term_free(3086 __isl_take isl_term *term);3087 3088Each term is a product of parameters, set variables and3089integer divisions. The function C<isl_term_get_exp>3090returns the exponent of a given dimensions in the given term.3091 3092=back3093 3094=head3 Reductions3095 3096A reduction represents a maximum or a minimum of its3097base expressions.3098The only reduction type defined by C<isl> is3099C<isl_qpolynomial_fold>.3100 3101There are currently no functions to directly create such3102objects, but they do appear in the piecewise quasipolynomial3103reductions returned by the C<isl_pw_qpolynomial_bound> function.3104See3105L</"Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions">.3106 3107Reductions can be copied and freed using3108the following functions.3109 3110 #include <isl/polynomial.h>3111 __isl_give isl_qpolynomial_fold *3112 isl_qpolynomial_fold_copy(3113 __isl_keep isl_qpolynomial_fold *fold);3114 __isl_null isl_qpolynomial_fold *3115 isl_qpolynomial_fold_free(3116 __isl_take isl_qpolynomial_fold *fold);3117 3118The type of a (union piecewise) reduction3119can be obtained using the following functions.3120 3121 #include <isl/polynomial.h>3122 enum isl_fold isl_qpolynomial_fold_get_type(3123 __isl_keep isl_qpolynomial_fold *fold);3124 enum isl_fold isl_pw_qpolynomial_fold_get_type(3125 __isl_keep isl_pw_qpolynomial_fold *pwf);3126 enum isl_fold isl_union_pw_qpolynomial_fold_get_type(3127 __isl_keep isl_union_pw_qpolynomial_fold *upwf);3128 3129The type may be either C<isl_fold_min> or C<isl_fold_max>3130(or C<isl_fold_error> in case of error).3131 3132To iterate over all quasipolynomials in a reduction, use3133 3134 isl_stat isl_qpolynomial_fold_foreach_qpolynomial(3135 __isl_keep isl_qpolynomial_fold *fold,3136 isl_stat (*fn)(__isl_take isl_qpolynomial *qp,3137 void *user), void *user);3138 3139=head3 Multiple Expressions3140 3141A multiple expression represents a sequence of zero or3142more base expressions, all defined on the same domain space.3143The domain space of the multiple expression is the same3144as that of the base expressions, but the range space3145can be any space. In case the base expressions have3146a set space, the corresponding multiple expression3147also has a set space.3148Objects of the value or identifier type do not have an associated space.3149The space of a multiple value or3150multiple identifier is therefore always a set space.3151Similarly, the space of a multiple union piecewise3152affine expression is always a set space.3153If the base expressions are not total, then3154a corresponding zero-dimensional multiple expression may3155have an explicit domain that keeps track of the domain3156outside of any base expressions.3157 3158The multiple expression types defined by C<isl>3159are C<isl_multi_val>, C<isl_multi_id>, C<isl_multi_aff>, C<isl_multi_pw_aff>,3160C<isl_multi_union_pw_aff>.3161 3162A multiple expression with the value zero for3163each output (or set) dimension can be created3164using the following functions.3165 3166 #include <isl/val.h>3167 __isl_give isl_multi_val *isl_multi_val_zero(3168 __isl_take isl_space *space);3169 __isl_give isl_multi_val *isl_space_zero_multi_val(3170 __isl_take isl_space *space);3171 3172 #include <isl/aff.h>3173 __isl_give isl_multi_aff *isl_multi_aff_zero(3174 __isl_take isl_space *space);3175 __isl_give isl_multi_aff *isl_space_zero_multi_aff(3176 __isl_take isl_space *space);3177 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_zero(3178 __isl_take isl_space *space);3179 __isl_give isl_multi_pw_aff *isl_space_zero_multi_pw_aff(3180 __isl_take isl_space *space);3181 __isl_give isl_multi_union_pw_aff *3182 isl_multi_union_pw_aff_zero(3183 __isl_take isl_space *space);3184 __isl_give isl_multi_union_pw_aff *3185 isl_space_zero_multi_union_pw_aff(3186 __isl_take isl_space *space);3187 3188Since there is no canonical way of representing a zero3189value of type C<isl_union_pw_aff>, the space passed3190to C<isl_multi_union_pw_aff_zero> needs to be zero-dimensional.3191C<isl_multi_val_zero> and C<isl_space_zero_multi_val>3192perform the same operation.3193Similarly3194for the pair C<isl_multi_aff_zero> and C<isl_space_zero_multi_aff>,3195for the pair C<isl_multi_pw_aff_zero> and C<isl_space_zero_multi_pw_aff> and3196for the pair C<isl_multi_union_pw_aff_zero> and3197C<isl_space_zero_multi_union_pw_aff>.3198 3199 3200An identity function can be created using the following3201functions.3202For the first group of functions, the space needs to be that of a set.3203For the second group,3204the space needs to be that of a relation3205with the same number of input and output dimensions.3206For the third group, the input function needs to live in a space3207with the same number of input and output dimensions and3208the identity function is created in that space.3209 3210 #include <isl/aff.h>3211 __isl_give isl_multi_aff *3212 isl_multi_aff_identity_on_domain_space(3213 __isl_take isl_space *space);3214 __isl_give isl_multi_aff *3215 isl_space_identity_multi_aff_on_domain(3216 __isl_take isl_space *space);3217 __isl_give isl_multi_pw_aff *3218 isl_multi_pw_aff_identity_on_domain_space(3219 __isl_take isl_space *space);3220 __isl_give isl_multi_pw_aff *3221 isl_space_identity_multi_pw_aff_on_domain(3222 __isl_take isl_space *space);3223 __isl_give isl_multi_aff *isl_multi_aff_identity(3224 __isl_take isl_space *space);3225 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_identity(3226 __isl_take isl_space *space);3227 __isl_give isl_multi_aff *3228 isl_multi_aff_identity_multi_aff(3229 __isl_take isl_multi_aff *ma);3230 __isl_give isl_multi_pw_aff *3231 isl_multi_pw_aff_identity_multi_pw_aff(3232 __isl_take isl_multi_pw_aff *mpa);3233 3234C<isl_multi_aff_identity_on_domain_space> and3235C<isl_space_identity_multi_aff_on_domain>3236perform the same operation.3237Similarly3238for the pair C<isl_multi_pw_aff_identity_on_domain_space> and3239C<isl_space_identity_multi_pw_aff_on_domain>.3240 3241A function that performs a projection on a universe3242relation or set can be created using the following functions.3243See also the corresponding3244projection operations in L</"Unary Operations">.3245 3246 #include <isl/aff.h>3247 __isl_give isl_multi_aff *isl_multi_aff_domain_map(3248 __isl_take isl_space *space);3249 __isl_give isl_multi_aff *isl_space_domain_map_multi_aff(3250 __isl_take isl_space *space);3251 __isl_give isl_multi_aff *isl_multi_aff_range_map(3252 __isl_take isl_space *space);3253 __isl_give isl_multi_aff *isl_space_range_map_multi_aff(3254 __isl_take isl_space *space);3255 __isl_give isl_multi_aff *isl_multi_aff_project_out_map(3256 __isl_take isl_space *space,3257 enum isl_dim_type type,3258 unsigned first, unsigned n);3259 3260C<isl_multi_aff_domain_map> and C<isl_space_domain_map_multi_aff> perform3261the same operation.3262Similarly3263for the pair C<isl_multi_aff_range_map> and C<isl_space_range_map_multi_aff>.3264 3265A multiple expression can be created from a single3266base expression using the following functions.3267The space of the created multiple expression is the same3268as that of the base expression, except for3269C<isl_multi_union_pw_aff_from_union_pw_aff> where the input3270lives in a parameter space and the output lives3271in a single-dimensional set space.3272 3273 #include <isl/aff.h>3274 __isl_give isl_multi_aff *isl_multi_aff_from_aff(3275 __isl_take isl_aff *aff);3276 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_pw_aff(3277 __isl_take isl_pw_aff *pa);3278 __isl_give isl_multi_union_pw_aff *3279 isl_multi_union_pw_aff_from_union_pw_aff(3280 __isl_take isl_union_pw_aff *upa);3281 3282A multiple expression can be created from a list3283of base expression in a specified space.3284The domain of this space needs to be the same3285as the domains of the base expressions in the list.3286If the base expressions have a set space (or no associated space),3287then this space also needs to be a set space.3288 3289 #include <isl/id.h>3290 __isl_give isl_multi_id *isl_multi_id_from_id_list(3291 __isl_take isl_space *space,3292 __isl_take isl_id_list *list);3293 __isl_give isl_multi_id *isl_space_multi_id(3294 __isl_take isl_space *space,3295 __isl_take isl_id_list *list);3296 3297 #include <isl/val.h>3298 __isl_give isl_multi_val *isl_multi_val_from_val_list(3299 __isl_take isl_space *space,3300 __isl_take isl_val_list *list);3301 __isl_give isl_multi_val *isl_space_multi_val(3302 __isl_take isl_space *space,3303 __isl_take isl_val_list *list);3304 3305 #include <isl/aff.h>3306 __isl_give isl_multi_aff *isl_multi_aff_from_aff_list(3307 __isl_take isl_space *space,3308 __isl_take isl_aff_list *list);3309 __isl_give isl_multi_aff *isl_space_multi_aff(3310 __isl_take isl_space *space,3311 __isl_take isl_aff_list *list);3312 __isl_give isl_multi_pw_aff *3313 isl_multi_pw_aff_from_pw_aff_list(3314 __isl_take isl_space *space,3315 __isl_take isl_pw_aff_list *list);3316 __isl_give isl_multi_pw_aff *3317 isl_space_multi_pw_aff(3318 __isl_take isl_space *space,3319 __isl_take isl_pw_aff_list *list);3320 __isl_give isl_multi_union_pw_aff *3321 isl_multi_union_pw_aff_from_union_pw_aff_list(3322 __isl_take isl_space *space,3323 __isl_take isl_union_pw_aff_list *list);3324 __isl_give isl_multi_union_pw_aff *3325 isl_space_multi_union_pw_aff(3326 __isl_take isl_space *space,3327 __isl_take isl_union_pw_aff_list *list);3328 3329C<isl_multi_id_from_id_list> and C<isl_space_multi_id> perform3330the same operation.3331Similarly for the pair C<isl_multi_val_from_val_list> and3332C<isl_space_multi_val>,3333for the pair C<isl_multi_aff_from_aff_list> and3334C<isl_space_multi_aff>,3335for the pair C<isl_multi_pw_aff_from_pw_aff_list> and3336C<isl_space_multi_pw_aff> and3337for the pair C<isl_multi_union_pw_aff_from_union_pw_aff_list> and3338C<isl_space_multi_union_pw_aff>.3339 3340As a convenience, a multiple piecewise expression can3341also be created from a multiple expression,3342or even directly from a single base expression.3343Each piecewise expression in the result has a single3344universe cell.3345 3346 #include <isl/aff.h>3347 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_aff(3348 __isl_take isl_aff *aff);3349 __isl_give isl_multi_pw_aff *3350 isl_multi_aff_to_multi_pw_aff(3351 __isl_take isl_multi_aff *ma);3352 __isl_give isl_multi_pw_aff *3353 isl_multi_pw_aff_from_multi_aff(3354 __isl_take isl_multi_aff *ma);3355 3356C<isl_multi_aff_to_multi_pw_aff> and3357C<isl_multi_pw_aff_from_multi_aff> perform the same operation.3358 3359Similarly, a multiple union expression can be3360created from a multiple expression.3361 3362 #include <isl/aff.h>3363 __isl_give isl_multi_union_pw_aff *3364 isl_multi_union_pw_aff_from_multi_aff(3365 __isl_take isl_multi_aff *ma);3366 __isl_give isl_multi_union_pw_aff *3367 isl_multi_aff_to_multi_union_pw_aff(3368 __isl_take isl_multi_aff *ma);3369 __isl_give isl_multi_union_pw_aff *3370 isl_multi_union_pw_aff_from_multi_pw_aff(3371 __isl_take isl_multi_pw_aff *mpa);3372 3373C<isl_multi_aff_to_multi_union_pw_aff> and3374C<isl_multi_union_pw_aff_from_multi_aff> perform the same operation.3375 3376A multiple quasi-affine expression can be created from3377a multiple value with a given domain space using the following3378function.3379 3380 #include <isl/aff.h>3381 __isl_give isl_multi_aff *3382 isl_multi_aff_multi_val_on_domain_space(3383 __isl_take isl_space *space,3384 __isl_take isl_multi_val *mv);3385 __isl_give isl_multi_aff *3386 isl_space_multi_aff_on_domain_multi_val(3387 __isl_take isl_space *space,3388 __isl_take isl_multi_val *mv);3389 __isl_give isl_multi_aff *3390 isl_multi_aff_multi_val_on_space(3391 __isl_take isl_space *space,3392 __isl_take isl_multi_val *mv);3393 3394C<isl_space_multi_aff_on_domain_multi_val> and3395C<isl_multi_aff_multi_val_on_space> are alternative names3396for C<isl_multi_aff_multi_val_on_domain_space>.3397 3398Similarly,3399a multiple union piecewise affine expression can be created from3400a multiple value with a given domain or3401a (piecewise) multiple affine expression with a given domain3402using the following functions.3403 3404 #include <isl/aff.h>3405 __isl_give isl_multi_union_pw_aff *3406 isl_multi_union_pw_aff_multi_val_on_domain(3407 __isl_take isl_union_set *domain,3408 __isl_take isl_multi_val *mv);3409 __isl_give isl_multi_union_pw_aff *3410 isl_multi_union_pw_aff_multi_aff_on_domain(3411 __isl_take isl_union_set *domain,3412 __isl_take isl_multi_aff *ma);3413 __isl_give isl_multi_union_pw_aff *3414 isl_multi_union_pw_aff_pw_multi_aff_on_domain(3415 __isl_take isl_union_set *domain,3416 __isl_take isl_pw_multi_aff *pma);3417 3418Multiple expressions can be copied and freed using3419the following functions.3420 3421 #include <isl/id.h>3422 __isl_give isl_multi_id *isl_multi_id_copy(3423 __isl_keep isl_multi_id *mi);3424 __isl_null isl_multi_id *isl_multi_id_free(3425 __isl_take isl_multi_id *mi);3426 3427 #include <isl/val.h>3428 __isl_give isl_multi_val *isl_multi_val_copy(3429 __isl_keep isl_multi_val *mv);3430 __isl_null isl_multi_val *isl_multi_val_free(3431 __isl_take isl_multi_val *mv);3432 3433 #include <isl/aff.h>3434 __isl_give isl_multi_aff *isl_multi_aff_copy(3435 __isl_keep isl_multi_aff *maff);3436 __isl_null isl_multi_aff *isl_multi_aff_free(3437 __isl_take isl_multi_aff *maff);3438 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_copy(3439 __isl_keep isl_multi_pw_aff *mpa);3440 __isl_null isl_multi_pw_aff *isl_multi_pw_aff_free(3441 __isl_take isl_multi_pw_aff *mpa);3442 __isl_give isl_multi_union_pw_aff *3443 isl_multi_union_pw_aff_copy(3444 __isl_keep isl_multi_union_pw_aff *mupa);3445 __isl_null isl_multi_union_pw_aff *3446 isl_multi_union_pw_aff_free(3447 __isl_take isl_multi_union_pw_aff *mupa);3448 3449The number of base expressions in a multiple3450expression can be obtained using the following functions.3451 3452 #include <isl/id.h>3453 int isl_multi_id_size(__isl_keep isl_multi_id *mi);3454 3455 #include <isl/val.h>3456 isl_size isl_multi_val_size(__isl_keep isl_multi_val *mv);3457 3458 #include <isl/aff.h>3459 isl_size isl_multi_aff_size(3460 __isl_keep isl_multi_aff *multi);3461 isl_size isl_multi_pw_aff_size(3462 __isl_keep isl_multi_pw_aff *mpa);3463 isl_size isl_multi_union_pw_aff_size(3464 __isl_keep isl_multi_union_pw_aff *mupa);3465 3466The base expression at a given position of a multiple3467expression can be extracted using the following functions.3468 3469 #include <isl/id.h>3470 __isl_give isl_id *isl_multi_id_get_at(3471 __isl_keep isl_multi_id *mi, int pos);3472 __isl_give isl_id *isl_multi_id_get_id(3473 __isl_keep isl_multi_id *mi, int pos);3474 3475 #include <isl/val.h>3476 __isl_give isl_val *isl_multi_val_get_at(3477 __isl_keep isl_multi_val *mv, int pos);3478 __isl_give isl_val *isl_multi_val_get_val(3479 __isl_keep isl_multi_val *mv, int pos);3480 3481 #include <isl/aff.h>3482 __isl_give isl_aff *isl_multi_aff_get_at(3483 __isl_keep isl_multi_aff *ma, int pos);3484 __isl_give isl_aff *isl_multi_aff_get_aff(3485 __isl_keep isl_multi_aff *multi, int pos);3486 __isl_give isl_pw_aff *isl_multi_pw_aff_get_at(3487 __isl_keep isl_multi_pw_aff *mpa, int pos);3488 __isl_give isl_pw_aff *isl_multi_pw_aff_get_pw_aff(3489 __isl_keep isl_multi_pw_aff *mpa, int pos);3490 __isl_give isl_union_pw_aff *3491 isl_multi_union_pw_aff_get_at(3492 __isl_keep isl_multi_union_pw_aff *mupa, int pos);3493 __isl_give isl_union_pw_aff *3494 isl_multi_union_pw_aff_get_union_pw_aff(3495 __isl_keep isl_multi_union_pw_aff *mupa, int pos);3496 3497C<isl_multi_id_get_id> is an alternative name for C<isl_multi_id_get_at>.3498Similarly for the other pairs of functions.3499 3500The base expression can be replaced using the following functions.3501 3502 #include <isl/id.h>3503 __isl_give isl_multi_id *isl_multi_id_set_at(3504 __isl_take isl_multi_id *mi, int pos,3505 __isl_take isl_id *id);3506 __isl_give isl_multi_id *isl_multi_id_set_id(3507 __isl_take isl_multi_id *mi, int pos,3508 __isl_take isl_id *id);3509 3510 #include <isl/val.h>3511 __isl_give isl_multi_val *isl_multi_val_set_at(3512 __isl_take isl_multi_val *mv, int pos,3513 __isl_take isl_val *val);3514 __isl_give isl_multi_val *isl_multi_val_set_val(3515 __isl_take isl_multi_val *mv, int pos,3516 __isl_take isl_val *val);3517 3518 #include <isl/aff.h>3519 __isl_give isl_multi_aff *isl_multi_aff_set_at(3520 __isl_take isl_multi_aff *ma, int pos,3521 __isl_take isl_aff *aff);3522 __isl_give isl_multi_aff *isl_multi_aff_set_aff(3523 __isl_take isl_multi_aff *multi, int pos,3524 __isl_take isl_aff *aff);3525 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_set_at(3526 __isl_take isl_multi_pw_aff *mpa, int pos,3527 __isl_take isl_pw_aff *pa);3528 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_set_pw_aff(3529 __isl_take isl_multi_pw_aff *mpa, int pos,3530 __isl_take isl_pw_aff *pa);3531 __isl_give isl_multi_union_pw_aff *3532 isl_multi_union_pw_aff_set_at(3533 __isl_take isl_multi_union_pw_aff *mupa, int pos,3534 __isl_take isl_union_pw_aff *upa);3535 __isl_give isl_multi_union_pw_aff *3536 isl_multi_union_pw_aff_set_union_pw_aff(3537 __isl_take isl_multi_union_pw_aff *mupa, int pos,3538 __isl_take isl_union_pw_aff *upa);3539 3540C<isl_multi_id_set_id> is an alternative name for C<isl_multi_id_set_at>.3541Similarly for the other pairs of functions.3542 3543A list of all base expressions of a multiple3544expression can be extracted using the following functions.3545 3546 #include <isl/id.h>3547 __isl_give isl_id_list *isl_multi_id_get_list(3548 __isl_keep isl_multi_id *mi);3549 3550 #include <isl/val.h>3551 __isl_give isl_val_list *isl_multi_val_get_list(3552 __isl_keep isl_multi_val *mv);3553 3554 #include <isl/aff.h>3555 __isl_give isl_aff_list *isl_multi_aff_get_list(3556 __isl_keep isl_multi_aff *multi);3557 __isl_give isl_pw_aff_list *isl_multi_pw_aff_get_list(3558 __isl_keep isl_multi_pw_aff *mpa);3559 __isl_give isl_union_pw_aff_list *3560 isl_multi_union_pw_aff_list(3561 __isl_keep isl_multi_union_pw_aff *mupa);3562 3563The constant terms of the base expressions can be obtained using3564the following function.3565 3566 #include <isl/aff.h>3567 __isl_give isl_multi_val *3568 isl_multi_aff_get_constant_multi_val(3569 __isl_keep isl_multi_aff *ma);3570 3571As a convenience, a sequence of base expressions that have3572their domains in a given space can be extracted from a sequence3573of union expressions using the following function.3574 3575 #include <isl/aff.h>3576 __isl_give isl_multi_pw_aff *3577 isl_multi_union_pw_aff_extract_multi_pw_aff(3578 __isl_keep isl_multi_union_pw_aff *mupa,3579 __isl_take isl_space *space);3580 3581Note that there is a difference between C<isl_multi_union_pw_aff>3582and C<isl_union_pw_multi_aff> objects. The first is a sequence3583of unions of piecewise expressions, while the second is a union3584of piecewise sequences. In particular, multiple affine expressions3585in an C<isl_union_pw_multi_aff> may live in different spaces,3586while there is only a single multiple expression in3587an C<isl_multi_union_pw_aff>, which can therefore only live3588in a single space. This means that not every3589C<isl_union_pw_multi_aff> can be converted to3590an C<isl_multi_union_pw_aff>. Conversely, the elements3591of an C<isl_multi_union_pw_aff> may be defined over different domains,3592while each multiple expression inside an C<isl_union_pw_multi_aff>3593has a single domain. The conversion of an C<isl_union_pw_multi_aff>3594of dimension greater than one may therefore not be exact.3595The following functions can3596be used to perform these conversions when they are possible.3597 3598 #include <isl/aff.h>3599 __isl_give isl_multi_union_pw_aff *3600 isl_union_pw_multi_aff_as_multi_union_pw_aff(3601 __isl_take isl_union_pw_multi_aff *upma);3602 __isl_give isl_multi_union_pw_aff *3603 isl_multi_union_pw_aff_from_union_pw_multi_aff(3604 __isl_take isl_union_pw_multi_aff *upma);3605 __isl_give isl_union_pw_multi_aff *3606 isl_union_pw_multi_aff_from_multi_union_pw_aff(3607 __isl_take isl_multi_union_pw_aff *mupa);3608 3609C<isl_union_pw_multi_aff_as_multi_union_pw_aff> and3610C<isl_multi_union_pw_aff_from_union_pw_multi_aff>3611perform the same operation.3612 3613=head3 Piecewise Expressions3614 3615A piecewise expression is an expression that is described3616using zero or more base expression defined over the same3617number of cells in the domain space of the base expressions.3618All base expressions are defined over the same3619domain space and the cells are disjoint.3620The space of a piecewise expression is the same as3621that of the base expressions.3622If the union of the cells is a strict subset of the domain3623space, then the value of the piecewise expression outside3624this union is different for types derived from quasi-affine3625expressions and those derived from quasipolynomials.3626Piecewise expressions derived from quasi-affine expressions3627are considered to be undefined outside the union of their cells.3628Piecewise expressions derived from quasipolynomials3629are considered to be zero outside the union of their cells.3630 3631Piecewise quasipolynomials are mainly used by the C<barvinok>3632library for representing the number of elements in a parametric set or map.3633For example, the piecewise quasipolynomial3634 3635 [n] -> { [x] -> ((1 + n) - x) : x <= n and x >= 0 }3636 3637represents the number of points in the map3638 3639 [n] -> { [x] -> [y] : x,y >= 0 and 0 <= x + y <= n }3640 3641The piecewise expression types defined by C<isl>3642are C<isl_pw_aff>, C<isl_pw_multi_aff>,3643C<isl_pw_qpolynomial> and C<isl_pw_qpolynomial_fold>.3644 3645A piecewise expression with no cells can be created using3646the following functions.3647 3648 #include <isl/aff.h>3649 __isl_give isl_pw_aff *isl_pw_aff_empty(3650 __isl_take isl_space *space);3651 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_empty(3652 __isl_take isl_space *space);3653 3654A piecewise expression with a single universe cell can be3655created using the following functions.3656 3657 #include <isl/aff.h>3658 __isl_give isl_pw_aff *isl_pw_aff_from_aff(3659 __isl_take isl_aff *aff);3660 __isl_give isl_pw_multi_aff *3661 isl_multi_aff_to_pw_multi_aff(3662 __isl_take isl_multi_aff *ma);3663 __isl_give isl_pw_multi_aff *3664 isl_pw_multi_aff_from_multi_aff(3665 __isl_take isl_multi_aff *ma);3666 3667 #include <isl/polynomial.h>3668 __isl_give isl_pw_qpolynomial *3669 isl_pw_qpolynomial_from_qpolynomial(3670 __isl_take isl_qpolynomial *qp);3671 __isl_give isl_pw_qpolynomial_fold *3672 isl_pw_qpolynomial_fold_from_qpolynomial_fold(3673 __isl_take isl_qpolynomial_fold *fold);3674 3675C<isl_multi_aff_to_pw_multi_aff> and C<isl_pw_multi_aff_from_multi_aff> perform3676the same operation.3677 3678The inverse conversions below can only be used if the input3679expression is known to be defined over a single universe domain.3680 3681 #include <isl/aff.h>3682 isl_bool isl_pw_aff_isa_aff(__isl_keep isl_pw_aff *pa);3683 __isl_give isl_aff *isl_pw_aff_as_aff(3684 __isl_take isl_pw_aff *pa);3685 isl_bool isl_multi_pw_aff_isa_multi_aff(3686 __isl_keep isl_multi_pw_aff *mpa);3687 __isl_give isl_multi_aff *isl_multi_pw_aff_as_multi_aff(3688 __isl_take isl_multi_pw_aff *mpa);3689 isl_bool isl_pw_multi_aff_isa_multi_aff(3690 __isl_keep isl_pw_multi_aff *pma);3691 __isl_give isl_multi_aff *isl_pw_multi_aff_as_multi_aff(3692 __isl_take isl_pw_multi_aff *pma);3693 3694 #include <isl/polynomial.h>3695 isl_bool isl_pw_qpolynomial_isa_qpolynomial(3696 __isl_keep isl_pw_qpolynomial *pwqp);3697 __isl_give isl_qpolynomial *3698 isl_pw_qpolynomial_as_qpolynomial(3699 __isl_take isl_pw_qpolynomial *pwqp);3700 isl_bool isl_pw_qpolynomial_fold_isa_qpolynomial_fold(3701 __isl_keep isl_pw_qpolynomial_fold *pwf);3702 __isl_give isl_qpolynomial_fold *3703 isl_pw_qpolynomial_fold_as_qpolynomial_fold(3704 __isl_take isl_pw_qpolynomial_fold *pwf);3705 3706A piecewise expression with a single specified cell can be3707created using the following functions.3708 3709 #include <isl/aff.h>3710 __isl_give isl_pw_aff *isl_pw_aff_alloc(3711 __isl_take isl_set *set, __isl_take isl_aff *aff);3712 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_alloc(3713 __isl_take isl_set *set,3714 __isl_take isl_multi_aff *maff);3715 3716 #include <isl/polynomial.h>3717 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_alloc(3718 __isl_take isl_set *set,3719 __isl_take isl_qpolynomial *qp);3720 3721The following convenience functions first create a base expression and3722then create a piecewise expression over a universe domain.3723 3724 #include <isl/aff.h>3725 __isl_give isl_pw_aff *isl_pw_aff_zero_on_domain(3726 __isl_take isl_local_space *ls);3727 __isl_give isl_pw_aff *isl_pw_aff_var_on_domain(3728 __isl_take isl_local_space *ls,3729 enum isl_dim_type type, unsigned pos);3730 __isl_give isl_pw_aff *isl_pw_aff_nan_on_domain_space(3731 __isl_take isl_space *space);3732 __isl_give isl_pw_aff *isl_pw_aff_nan_on_domain(3733 __isl_take isl_local_space *ls);3734 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_zero(3735 __isl_take isl_space *space);3736 __isl_give isl_pw_multi_aff *3737 isl_pw_multi_aff_identity_on_domain_space(3738 __isl_take isl_space *space)3739 __isl_give isl_pw_multi_aff *3740 isl_space_identity_pw_multi_aff_on_domain(3741 __isl_take isl_space *space)3742 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_identity(3743 __isl_take isl_space *space);3744 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_domain_map(3745 __isl_take isl_space *space);3746 __isl_give isl_pw_multi_aff *3747 isl_space_domain_map_pw_multi_aff(3748 __isl_take isl_space *space);3749 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_map(3750 __isl_take isl_space *space);3751 __isl_give isl_pw_multi_aff *3752 isl_space_range_map_pw_multi_aff(3753 __isl_take isl_space *space);3754 __isl_give isl_pw_multi_aff *3755 isl_pw_multi_aff_project_out_map(3756 __isl_take isl_space *space,3757 enum isl_dim_type type,3758 unsigned first, unsigned n);3759 3760 #include <isl/polynomial.h>3761 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_zero(3762 __isl_take isl_space *space);3763 3764C<isl_pw_multi_aff_identity_on_domain_space> and3765C<isl_space_identity_pw_multi_aff_on_domain>3766perform the same operation.3767Similarly3768for the pair C<isl_pw_multi_aff_domain_map> and3769C<isl_space_domain_map_pw_multi_aff> and3770for the pair C<isl_pw_multi_aff_range_map> and3771C<isl_space_range_map_pw_multi_aff>.3772 3773The following convenience functions first create a base expression and3774then create a piecewise expression over a given domain.3775 3776 #include <isl/aff.h>3777 __isl_give isl_pw_aff *isl_pw_aff_val_on_domain(3778 __isl_take isl_set *domain,3779 __isl_take isl_val *v);3780 __isl_give isl_pw_aff *isl_set_pw_aff_on_domain_val(3781 __isl_take isl_set *domain,3782 __isl_take isl_val *v);3783 __isl_give isl_pw_multi_aff *3784 isl_pw_multi_aff_multi_val_on_domain(3785 __isl_take isl_set *domain,3786 __isl_take isl_multi_val *mv);3787 __isl_give isl_pw_multi_aff *3788 isl_set_pw_multi_aff_on_domain_multi_val(3789 __isl_take isl_set *domain,3790 __isl_take isl_multi_val *mv);3791 __isl_give isl_pw_aff *isl_pw_aff_param_on_domain_id(3792 __isl_take isl_set *domain,3793 __isl_take isl_id *id);3794 __isl_give isl_pw_aff *isl_set_param_pw_aff_on_domain_id(3795 __isl_take isl_set *domain,3796 __isl_take isl_id *id);3797 3798C<isl_set_pw_aff_on_domain_val> is an alternative name3799for C<isl_pw_aff_val_on_domain>.3800Similarly for the pair3801C<isl_set_pw_multi_aff_on_domain_multi_val> and3802C<isl_pw_multi_aff_multi_val_on_domain> and3803for the pair C<isl_set_param_pw_aff_on_domain_id> and3804C<isl_pw_aff_param_on_domain_id>.3805 3806As a convenience, a piecewise multiple expression can3807also be created from a piecewise expression.3808Each multiple expression in the result is derived3809from the corresponding base expression.3810 3811 #include <isl/aff.h>3812 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_pw_aff(3813 __isl_take isl_pw_aff *pa);3814 3815Similarly, a piecewise quasipolynomial can be3816created from a piecewise quasi-affine expression using3817the following function.3818 3819 #include <isl/polynomial.h>3820 __isl_give isl_pw_qpolynomial *3821 isl_pw_qpolynomial_from_pw_aff(3822 __isl_take isl_pw_aff *pwaff);3823 3824Piecewise expressions can be copied and freed using the following functions.3825 3826 #include <isl/aff.h>3827 __isl_give isl_pw_aff *isl_pw_aff_copy(3828 __isl_keep isl_pw_aff *pwaff);3829 __isl_null isl_pw_aff *isl_pw_aff_free(3830 __isl_take isl_pw_aff *pwaff);3831 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_copy(3832 __isl_keep isl_pw_multi_aff *pma);3833 __isl_null isl_pw_multi_aff *isl_pw_multi_aff_free(3834 __isl_take isl_pw_multi_aff *pma);3835 3836 #include <isl/polynomial.h>3837 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_copy(3838 __isl_keep isl_pw_qpolynomial *pwqp);3839 __isl_null isl_pw_qpolynomial *isl_pw_qpolynomial_free(3840 __isl_take isl_pw_qpolynomial *pwqp);3841 __isl_give isl_pw_qpolynomial_fold *3842 isl_pw_qpolynomial_fold_copy(3843 __isl_keep isl_pw_qpolynomial_fold *pwf);3844 __isl_null isl_pw_qpolynomial_fold *3845 isl_pw_qpolynomial_fold_free(3846 __isl_take isl_pw_qpolynomial_fold *pwf);3847 3848To iterate over the different cells of a piecewise expression,3849use the following functions.3850 3851 #include <isl/aff.h>3852 isl_bool isl_pw_aff_is_empty(__isl_keep isl_pw_aff *pwaff);3853 isl_size isl_pw_aff_n_piece(__isl_keep isl_pw_aff *pwaff);3854 isl_stat isl_pw_aff_foreach_piece(3855 __isl_keep isl_pw_aff *pwaff,3856 isl_stat (*fn)(__isl_take isl_set *set,3857 __isl_take isl_aff *aff,3858 void *user), void *user);3859 isl_bool isl_pw_aff_every_piece(__isl_keep isl_pw_aff *pa,3860 isl_bool (*test)(__isl_keep isl_set *set,3861 __isl_keep isl_aff *aff, void *user),3862 void *user);3863 isl_size isl_pw_multi_aff_n_piece(3864 __isl_keep isl_pw_multi_aff *pma);3865 isl_stat isl_pw_multi_aff_foreach_piece(3866 __isl_keep isl_pw_multi_aff *pma,3867 isl_stat (*fn)(__isl_take isl_set *set,3868 __isl_take isl_multi_aff *maff,3869 void *user), void *user);3870 isl_bool isl_pw_multi_aff_every_piece(3871 __isl_keep isl_pw_multi_aff *pma,3872 isl_bool (*test)(__isl_keep isl_set *set,3873 __isl_keep isl_multi_aff *ma, void *user),3874 void *user);3875 3876 #include <isl/polynomial.h>3877 isl_size isl_pw_qpolynomial_n_piece(3878 __isl_keep isl_pw_qpolynomial *pwqp);3879 isl_stat isl_pw_qpolynomial_foreach_piece(3880 __isl_keep isl_pw_qpolynomial *pwqp,3881 isl_stat (*fn)(__isl_take isl_set *set,3882 __isl_take isl_qpolynomial *qp,3883 void *user), void *user);3884 isl_bool isl_pw_qpolynomial_every_piece(3885 __isl_keep isl_pw_qpolynomial *pwqp,3886 isl_bool (*test)(__isl_keep isl_set *set,3887 __isl_keep isl_qpolynomial *qp,3888 void *user), void *user);3889 isl_stat isl_pw_qpolynomial_foreach_lifted_piece(3890 __isl_keep isl_pw_qpolynomial *pwqp,3891 isl_stat (*fn)(__isl_take isl_set *set,3892 __isl_take isl_qpolynomial *qp,3893 void *user), void *user);3894 isl_size isl_pw_qpolynomial_fold_n_piece(3895 __isl_keep isl_pw_qpolynomial_fold *pwf);3896 isl_stat isl_pw_qpolynomial_fold_foreach_piece(3897 __isl_keep isl_pw_qpolynomial_fold *pwf,3898 isl_stat (*fn)(__isl_take isl_set *set,3899 __isl_take isl_qpolynomial_fold *fold,3900 void *user), void *user);3901 isl_bool isl_pw_qpolynomial_fold_every_piece(3902 __isl_keep isl_pw_qpolynomial_fold *pwf,3903 isl_bool (*test)(__isl_keep isl_set *set,3904 __isl_keep isl_qpolynomial_fold *fold,3905 void *user), void *user);3906 isl_stat isl_pw_qpolynomial_fold_foreach_lifted_piece(3907 __isl_keep isl_pw_qpolynomial_fold *pwf,3908 isl_stat (*fn)(__isl_take isl_set *set,3909 __isl_take isl_qpolynomial_fold *fold,3910 void *user), void *user);3911 3912As usual, the function C<fn> should return C<isl_stat_ok> on success3913and C<isl_stat_error> on failure. The difference between3914C<isl_pw_qpolynomial_foreach_piece> and3915C<isl_pw_qpolynomial_foreach_lifted_piece> is that3916C<isl_pw_qpolynomial_foreach_lifted_piece> will first3917compute unique representations for all existentially quantified3918variables and then turn these existentially quantified variables3919into extra set variables, adapting the associated quasipolynomial3920accordingly. This means that the C<set> passed to C<fn>3921will not have any existentially quantified variables, but that3922the dimensions of the sets may be different for different3923invocations of C<fn>.3924Similarly for C<isl_pw_qpolynomial_fold_foreach_piece>3925and C<isl_pw_qpolynomial_fold_foreach_lifted_piece>.3926The function C<isl_pw_aff_every_piece> and its variants3927check whether each call to the callback returns true and3928stop checking as soon as one of these calls returns false (or error).3929 3930A piecewise expression consisting of the expressions at a given3931position of a piecewise multiple expression can be extracted3932using the following function.3933 3934 #include <isl/aff.h>3935 __isl_give isl_pw_aff *isl_pw_multi_aff_get_at(3936 __isl_keep isl_pw_multi_aff *pma, int pos);3937 __isl_give isl_pw_aff *isl_pw_multi_aff_get_pw_aff(3938 __isl_keep isl_pw_multi_aff *pma, int pos);3939 3940C<isl_pw_multi_aff_get_pw_aff> is an alternative name for3941C<isl_pw_multi_aff_get_at>.3942 3943These expressions can be replaced using the following function.3944 3945 #include <isl/aff.h>3946 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_pw_aff(3947 __isl_take isl_pw_multi_aff *pma, unsigned pos,3948 __isl_take isl_pw_aff *pa);3949 3950Note that there is a difference between C<isl_multi_pw_aff> and3951C<isl_pw_multi_aff> objects. The first is a sequence of piecewise3952affine expressions, while the second is a piecewise sequence3953of affine expressions. In particular, each of the piecewise3954affine expressions in an C<isl_multi_pw_aff> may have a different3955domain, while all multiple expressions associated to a cell3956in an C<isl_pw_multi_aff> have the same domain.3957It is possible to convert between the two, but when converting3958an C<isl_multi_pw_aff> to an C<isl_pw_multi_aff>, the domain3959of the result is the intersection of the domains of the input.3960The reverse conversion is exact.3961 3962 #include <isl/aff.h>3963 __isl_give isl_pw_multi_aff *3964 isl_pw_multi_aff_from_multi_pw_aff(3965 __isl_take isl_multi_pw_aff *mpa);3966 __isl_give isl_multi_pw_aff *3967 isl_pw_multi_aff_to_multi_pw_aff(3968 __isl_take isl_pw_multi_aff *pma);3969 __isl_give isl_multi_pw_aff *3970 isl_multi_pw_aff_from_pw_multi_aff(3971 __isl_take isl_pw_multi_aff *pma);3972 3973C<isl_pw_multi_aff_to_multi_pw_aff> and3974C<isl_multi_pw_aff_from_pw_multi_aff> perform the same operation.3975 3976=head3 Union Expressions3977 3978A union expression collects base expressions defined3979over different domains. The space of a union expression3980is that of the shared parameter space.3981 3982The union expression types defined by C<isl>3983are C<isl_union_pw_aff>, C<isl_union_pw_multi_aff>,3984C<isl_union_pw_qpolynomial> and C<isl_union_pw_qpolynomial_fold>.3985In case of3986C<isl_union_pw_aff>,3987C<isl_union_pw_qpolynomial> and C<isl_union_pw_qpolynomial_fold>,3988there can be at most one base expression for a given domain space.3989In case of3990C<isl_union_pw_multi_aff>,3991there can be multiple such expressions for a given domain space,3992but the domains of these expressions need to be disjoint.3993 3994An empty union expression can be created using the following functions.3995 3996 #include <isl/aff.h>3997 __isl_give isl_union_pw_aff *3998 isl_union_pw_aff_empty_ctx(3999 isl_ctx *ctx);4000 __isl_give isl_union_pw_aff *4001 isl_union_pw_aff_empty_space(4002 __isl_take isl_space *space);4003 __isl_give isl_union_pw_aff *isl_union_pw_aff_empty(4004 __isl_take isl_space *space);4005 __isl_give isl_union_pw_multi_aff *4006 isl_union_pw_multi_aff_empty_ctx(4007 isl_ctx *ctx);4008 __isl_give isl_union_pw_multi_aff *4009 isl_union_pw_multi_aff_empty_space(4010 __isl_take isl_space *space);4011 __isl_give isl_union_pw_multi_aff *4012 isl_union_pw_multi_aff_empty(4013 __isl_take isl_space *space);4014 4015 #include <isl/polynomial.h>4016 __isl_give isl_union_pw_qpolynomial *4017 isl_union_pw_qpolynomial_zero_ctx(4018 isl_ctx *ctx);4019 __isl_give isl_union_pw_qpolynomial *4020 isl_union_pw_qpolynomial_zero_space(4021 __isl_take isl_space *space);4022 __isl_give isl_union_pw_qpolynomial *4023 isl_union_pw_qpolynomial_zero(4024 __isl_take isl_space *space);4025 4026C<isl_union_pw_aff_empty> is an alternative name for4027C<isl_union_pw_aff_empty_space>.4028Similarly for the other pairs of functions.4029 4030A union expression containing a single base expression4031can be created using the following functions.4032 4033 #include <isl/aff.h>4034 __isl_give isl_union_pw_aff *4035 isl_pw_aff_to_union_pw_aff(4036 __isl_take isl_pw_aff *pa);4037 __isl_give isl_union_pw_aff *4038 isl_union_pw_aff_from_pw_aff(4039 __isl_take isl_pw_aff *pa);4040 __isl_give isl_union_pw_multi_aff *4041 isl_union_pw_multi_aff_from_aff(4042 __isl_take isl_aff *aff);4043 __isl_give isl_union_pw_multi_aff *4044 isl_pw_multi_aff_to_union_pw_multi_aff(4045 __isl_take isl_pw_multi_aff *pma);4046 __isl_give isl_union_pw_multi_aff *4047 isl_union_pw_multi_aff_from_pw_multi_aff(4048 __isl_take isl_pw_multi_aff *pma);4049 4050 #include <isl/polynomial.h>4051 __isl_give isl_union_pw_qpolynomial *4052 isl_pw_qpolynomial_to_union_pw_qpolynomial(4053 __isl_take isl_pw_qpolynomial *pwqp);4054 __isl_give isl_union_pw_qpolynomial *4055 isl_union_pw_qpolynomial_from_pw_qpolynomial(4056 __isl_take isl_pw_qpolynomial *pwqp);4057 __isl_give isl_union_pw_qpolynomial_fold *4058 isl_pw_qpolynomial_fold_to_union_pw_qpolynomial_fold(4059 __isl_take isl_pw_qpolynomial_fold *pwf);4060 __isl_give isl_union_pw_qpolynomial_fold *4061 isl_union_pw_qpolynomial_fold_from_pw_qpolynomial_fold(4062 __isl_take isl_pw_qpolynomial_fold *pwf);4063 4064C<isl_pw_aff_to_union_pw_aff> and C<isl_union_pw_aff_from_pw_aff> perform4065the same operation.4066Similarly for C<isl_pw_multi_aff_to_union_pw_multi_aff> and4067C<isl_union_pw_multi_aff_from_pw_multi_aff>,4068for4069C<isl_pw_qpolynomial_to_union_pw_qpolynomial> and4070C<isl_union_pw_qpolynomial_from_pw_qpolynomial>, and4071for4072C<isl_pw_qpolynomial_fold_to_union_pw_qpolynomial_fold> and4073C<isl_union_pw_qpolynomial_fold_from_pw_qpolynomial_fold>.4074 4075The inverse conversions below can only be used if the input4076expression is known to live in exactly one space.4077 4078 #include <isl/aff.h>4079 isl_bool isl_union_pw_multi_aff_isa_pw_multi_aff(4080 __isl_keep isl_union_pw_multi_aff *upma);4081 __isl_give isl_pw_multi_aff *4082 isl_union_pw_multi_aff_as_pw_multi_aff(4083 __isl_take isl_union_pw_multi_aff *upma);4084 4085A union piecewise expression containing a single base expression4086on a universe domain can also be created directly from4087a base expression using the following functions.4088 4089 #include <isl/aff.h>4090 __isl_give isl_union_pw_aff *isl_union_pw_aff_from_aff(4091 __isl_take isl_aff *aff);4092 __isl_give isl_union_pw_multi_aff *4093 isl_union_pw_multi_aff_from_multi_aff(4094 __isl_take isl_multi_aff *ma);4095 4096The following functions create a base expression on each4097of the sets in the union set and collect the results.4098 4099 #include <isl/aff.h>4100 __isl_give isl_union_pw_multi_aff *4101 isl_union_pw_multi_aff_from_union_pw_aff(4102 __isl_take isl_union_pw_aff *upa);4103 __isl_give isl_union_pw_aff *4104 isl_union_pw_multi_aff_get_union_pw_aff(4105 __isl_keep isl_union_pw_multi_aff *upma, int pos);4106 __isl_give isl_union_pw_aff *4107 isl_union_pw_aff_val_on_domain(4108 __isl_take isl_union_set *domain,4109 __isl_take isl_val *v);4110 __isl_give isl_union_pw_multi_aff *4111 isl_union_pw_multi_aff_multi_val_on_domain(4112 __isl_take isl_union_set *domain,4113 __isl_take isl_multi_val *mv);4114 __isl_give isl_union_pw_aff *4115 isl_union_pw_aff_param_on_domain_id(4116 __isl_take isl_union_set *domain,4117 __isl_take isl_id *id);4118 4119The C<id> argument of C<isl_union_pw_aff_param_on_domain_id>4120is the identifier of a parameter that may or may not already4121be present in C<domain>.4122 4123An C<isl_union_pw_aff> that is equal to a (parametric) affine4124or piecewise affine4125expression on a given domain can be created using the following4126functions.4127 4128 #include <isl/aff.h>4129 __isl_give isl_union_pw_aff *4130 isl_union_pw_aff_aff_on_domain(4131 __isl_take isl_union_set *domain,4132 __isl_take isl_aff *aff);4133 __isl_give isl_union_pw_aff *4134 isl_union_pw_aff_pw_aff_on_domain(4135 __isl_take isl_union_set *domain,4136 __isl_take isl_pw_aff *pa);4137 4138A base expression can be added to a union expression using4139the following functions.4140 4141 #include <isl/aff.h>4142 __isl_give isl_union_pw_aff *4143 isl_union_pw_aff_add_pw_aff(4144 __isl_take isl_union_pw_aff *upa,4145 __isl_take isl_pw_aff *pa);4146 __isl_give isl_union_pw_multi_aff *4147 isl_union_pw_multi_aff_add_pw_multi_aff(4148 __isl_take isl_union_pw_multi_aff *upma,4149 __isl_take isl_pw_multi_aff *pma);4150 4151 #include <isl/polynomial.h>4152 __isl_give isl_union_pw_qpolynomial *4153 isl_union_pw_qpolynomial_add_pw_qpolynomial(4154 __isl_take isl_union_pw_qpolynomial *upwqp,4155 __isl_take isl_pw_qpolynomial *pwqp);4156 4157Union expressions can be copied and freed using4158the following functions.4159 4160 #include <isl/aff.h>4161 __isl_give isl_union_pw_aff *isl_union_pw_aff_copy(4162 __isl_keep isl_union_pw_aff *upa);4163 __isl_null isl_union_pw_aff *isl_union_pw_aff_free(4164 __isl_take isl_union_pw_aff *upa);4165 __isl_give isl_union_pw_multi_aff *4166 isl_union_pw_multi_aff_copy(4167 __isl_keep isl_union_pw_multi_aff *upma);4168 __isl_null isl_union_pw_multi_aff *4169 isl_union_pw_multi_aff_free(4170 __isl_take isl_union_pw_multi_aff *upma);4171 4172 #include <isl/polynomial.h>4173 __isl_give isl_union_pw_qpolynomial *4174 isl_union_pw_qpolynomial_copy(4175 __isl_keep isl_union_pw_qpolynomial *upwqp);4176 __isl_null isl_union_pw_qpolynomial *4177 isl_union_pw_qpolynomial_free(4178 __isl_take isl_union_pw_qpolynomial *upwqp);4179 __isl_give isl_union_pw_qpolynomial_fold *4180 isl_union_pw_qpolynomial_fold_copy(4181 __isl_keep isl_union_pw_qpolynomial_fold *upwf);4182 __isl_null isl_union_pw_qpolynomial_fold *4183 isl_union_pw_qpolynomial_fold_free(4184 __isl_take isl_union_pw_qpolynomial_fold *upwf);4185 4186To iterate over the base expressions in a union expression,4187use the following functions.4188 4189 #include <isl/aff.h>4190 isl_size isl_union_pw_aff_n_pw_aff(4191 __isl_keep isl_union_pw_aff *upa);4192 isl_stat isl_union_pw_aff_foreach_pw_aff(4193 __isl_keep isl_union_pw_aff *upa,4194 isl_stat (*fn)(__isl_take isl_pw_aff *pa,4195 void *user), void *user);4196 isl_bool isl_union_pw_aff_every_pw_aff(4197 __isl_keep isl_union_pw_aff *upa,4198 isl_bool (*test)(__isl_keep isl_pw_aff *pa,4199 void *user), void *user);4200 isl_size isl_union_pw_multi_aff_n_pw_multi_aff(4201 __isl_keep isl_union_pw_multi_aff *upma);4202 isl_stat isl_union_pw_multi_aff_foreach_pw_multi_aff(4203 __isl_keep isl_union_pw_multi_aff *upma,4204 isl_stat (*fn)(__isl_take isl_pw_multi_aff *pma,4205 void *user), void *user);4206 isl_bool isl_union_pw_multi_aff_every_pw_multi_aff(4207 __isl_keep isl_union_pw_multi_aff *upma,4208 isl_bool (*test)(4209 __isl_keep isl_pw_multi_aff *pma,4210 void *user), void *user);4211 4212 #include <isl/polynomial.h>4213 isl_size isl_union_pw_qpolynomial_n_pw_qpolynomial(4214 __isl_keep isl_union_pw_qpolynomial *upwqp);4215 isl_stat isl_union_pw_qpolynomial_foreach_pw_qpolynomial(4216 __isl_keep isl_union_pw_qpolynomial *upwqp,4217 isl_stat (*fn)(__isl_take isl_pw_qpolynomial *pwqp,4218 void *user), void *user);4219 isl_bool isl_union_pw_qpolynomial_every_pw_qpolynomial(4220 __isl_keep isl_union_pw_qpolynomial *upwqp,4221 isl_bool (*test)(4222 __isl_keep isl_pw_qpolynomial *pwqp,4223 void *user), void *user);4224 isl_size isl_union_pw_qpolynomial_fold_n_pw_qpolynomial_fold(4225 __isl_keep isl_union_pw_qpolynomial_fold *upwf);4226 isl_stat isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(4227 __isl_keep isl_union_pw_qpolynomial_fold *upwf,4228 isl_stat (*fn)(__isl_take isl_pw_qpolynomial_fold *pwf,4229 void *user), void *user);4230 isl_bool4231 isl_union_pw_qpolynomial_fold_every_pw_qpolynomial_fold(4232 __isl_keep isl_union_pw_qpolynomial_fold *upwf,4233 isl_bool (*test)(4234 __isl_keep isl_pw_qpolynomial_fold *pwf,4235 void *user), void *user);4236 4237To extract the base expression in a given space from a union, use4238the following functions.4239 4240 #include <isl/aff.h>4241 __isl_give isl_pw_aff *isl_union_pw_aff_extract_pw_aff(4242 __isl_keep isl_union_pw_aff *upa,4243 __isl_take isl_space *space);4244 __isl_give isl_pw_multi_aff *4245 isl_union_pw_multi_aff_extract_pw_multi_aff(4246 __isl_keep isl_union_pw_multi_aff *upma,4247 __isl_take isl_space *space);4248 4249 #include <isl/polynomial.h>4250 __isl_give isl_pw_qpolynomial *4251 isl_union_pw_qpolynomial_extract_pw_qpolynomial(4252 __isl_keep isl_union_pw_qpolynomial *upwqp,4253 __isl_take isl_space *space);4254 4255It is also possible to obtain a list of the base expressions using4256the following functions.4257 4258 #include <isl/aff.h>4259 __isl_give isl_pw_aff_list *4260 isl_union_pw_aff_get_pw_aff_list(4261 __isl_keep isl_union_pw_aff *upa);4262 __isl_give isl_pw_multi_aff_list *4263 isl_union_pw_multi_aff_get_pw_multi_aff_list(4264 __isl_keep isl_union_pw_multi_aff *upma);4265 4266 #include <isl/polynomial.h>4267 __isl_give isl_pw_qpolynomial_list *4268 isl_union_pw_qpolynomial_get_pw_qpolynomial_list(4269 __isl_keep isl_union_pw_qpolynomial *upwqp);4270 __isl_give isl_pw_qpolynomial_fold_list *4271 isl_union_pw_qpolynomial_fold_get_pw_qpolynomial_fold_list(4272 __isl_keep isl_union_pw_qpolynomial_fold *upwf);4273 4274The returned list can be manipulated using the functions in L<"Lists">.4275 4276=head2 Input and Output4277 4278For set and relation,4279C<isl> supports its own input/output format, which is similar4280to the C<Omega> format, but also supports the C<PolyLib> format4281in some cases.4282For other object types, typically only an C<isl> format is supported.4283 4284=head3 C<isl> format4285 4286The C<isl> format is similar to that of C<Omega>, but has a different4287syntax for describing the parameters and allows for the definition4288of an existentially quantified variable as the integer division4289of an affine expression.4290For example, the set of integers C<i> between C<0> and C<n>4291such that C<i % 10 <= 6> can be described as4292 4293 [n] -> { [i] : exists (a = [i/10] : 0 <= i and i <= n and4294 i - 10 a <= 6) }4295 4296A set or relation can have several disjuncts, separated4297by the keyword C<or>. Each disjunct is either a conjunction4298of constraints or a projection (C<exists>) of a conjunction4299of constraints. The constraints are separated by the keyword4300C<and>.4301 4302=head3 C<PolyLib> format4303 4304If the represented set is a union, then the first line4305contains a single number representing the number of disjuncts.4306Otherwise, a line containing the number C<1> is optional.4307 4308Each disjunct is represented by a matrix of constraints.4309The first line contains two numbers representing4310the number of rows and columns,4311where the number of rows is equal to the number of constraints4312and the number of columns is equal to two plus the number of variables.4313The following lines contain the actual rows of the constraint matrix.4314In each row, the first column indicates whether the constraint4315is an equality (C<0>) or inequality (C<1>). The final column4316corresponds to the constant term.4317 4318If the set is parametric, then the coefficients of the parameters4319appear in the last columns before the constant column.4320The coefficients of any existentially quantified variables appear4321between those of the set variables and those of the parameters.4322 4323=head3 Extended C<PolyLib> format4324 4325The extended C<PolyLib> format is nearly identical to the4326C<PolyLib> format. The only difference is that the line4327containing the number of rows and columns of a constraint matrix4328also contains four additional numbers:4329the number of output dimensions, the number of input dimensions,4330the number of local dimensions (i.e., the number of existentially4331quantified variables) and the number of parameters.4332For sets, the number of ``output'' dimensions is equal4333to the number of set dimensions, while the number of ``input''4334dimensions is zero.4335 4336=head3 Input4337 4338Objects can be read from input using the following functions.4339 4340 #include <isl/id.h>4341 __isl_give isl_id *isl_id_read_from_str(isl_ctx *ctx,4342 const char *str);4343 __isl_give isl_multi_id *isl_multi_id_read_from_str(4344 isl_ctx *ctx, const char *str);4345 4346 #include <isl/val.h>4347 __isl_give isl_val *isl_val_read_from_str(isl_ctx *ctx,4348 const char *str);4349 __isl_give isl_multi_val *isl_multi_val_read_from_str(4350 isl_ctx *ctx, const char *str);4351 4352 #include <isl/space.h>4353 __isl_give isl_space *isl_space_read_from_str(4354 isl_ctx *ctx, const char *str);4355 4356 #include <isl/set.h>4357 __isl_give isl_basic_set *isl_basic_set_read_from_file(4358 isl_ctx *ctx, FILE *input);4359 __isl_give isl_basic_set *isl_basic_set_read_from_str(4360 isl_ctx *ctx, const char *str);4361 __isl_give isl_set *isl_set_read_from_file(isl_ctx *ctx,4362 FILE *input);4363 __isl_give isl_set *isl_set_read_from_str(isl_ctx *ctx,4364 const char *str);4365 4366 #include <isl/map.h>4367 __isl_give isl_basic_map *isl_basic_map_read_from_file(4368 isl_ctx *ctx, FILE *input);4369 __isl_give isl_basic_map *isl_basic_map_read_from_str(4370 isl_ctx *ctx, const char *str);4371 __isl_give isl_map *isl_map_read_from_file(4372 isl_ctx *ctx, FILE *input);4373 __isl_give isl_map *isl_map_read_from_str(isl_ctx *ctx,4374 const char *str);4375 4376 #include <isl/union_set.h>4377 __isl_give isl_union_set *isl_union_set_read_from_file(4378 isl_ctx *ctx, FILE *input);4379 __isl_give isl_union_set *isl_union_set_read_from_str(4380 isl_ctx *ctx, const char *str);4381 4382 #include <isl/union_map.h>4383 __isl_give isl_union_map *isl_union_map_read_from_file(4384 isl_ctx *ctx, FILE *input);4385 __isl_give isl_union_map *isl_union_map_read_from_str(4386 isl_ctx *ctx, const char *str);4387 4388 #include <isl/aff.h>4389 __isl_give isl_aff *isl_aff_read_from_str(4390 isl_ctx *ctx, const char *str);4391 __isl_give isl_multi_aff *isl_multi_aff_read_from_str(4392 isl_ctx *ctx, const char *str);4393 __isl_give isl_pw_aff *isl_pw_aff_read_from_str(4394 isl_ctx *ctx, const char *str);4395 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_read_from_str(4396 isl_ctx *ctx, const char *str);4397 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_read_from_str(4398 isl_ctx *ctx, const char *str);4399 __isl_give isl_union_pw_aff *4400 isl_union_pw_aff_read_from_str(4401 isl_ctx *ctx, const char *str);4402 __isl_give isl_union_pw_multi_aff *4403 isl_union_pw_multi_aff_read_from_str(4404 isl_ctx *ctx, const char *str);4405 __isl_give isl_multi_union_pw_aff *4406 isl_multi_union_pw_aff_read_from_str(4407 isl_ctx *ctx, const char *str);4408 4409 #include <isl/polynomial.h>4410 __isl_give isl_union_pw_qpolynomial *4411 isl_union_pw_qpolynomial_read_from_str(4412 isl_ctx *ctx, const char *str);4413 4414 __isl_give isl_pw_qpolynomial_fold *4415 isl_pw_qpolynomial_fold_read_from_str(4416 isl_ctx *ctx, const char *str);4417 4418For sets and relations,4419the input format is autodetected and may be either the C<PolyLib> format4420or the C<isl> format.4421 4422=head3 Output4423 4424Before anything can be printed, an C<isl_printer> needs to4425be created.4426 4427 __isl_give isl_printer *isl_printer_to_file(isl_ctx *ctx,4428 FILE *file);4429 __isl_give isl_printer *isl_printer_to_str(isl_ctx *ctx);4430 __isl_null isl_printer *isl_printer_free(4431 __isl_take isl_printer *printer);4432 4433C<isl_printer_to_file> prints to the given file, while4434C<isl_printer_to_str> prints to a string that can be extracted4435using the following function.4436 4437 #include <isl/printer.h>4438 __isl_give char *isl_printer_get_str(4439 __isl_keep isl_printer *printer);4440 4441The printer can be inspected using the following functions.4442 4443 FILE *isl_printer_get_file(4444 __isl_keep isl_printer *printer);4445 int isl_printer_get_output_format(4446 __isl_keep isl_printer *p);4447 int isl_printer_get_yaml_style(__isl_keep isl_printer *p);4448 4449The behavior of the printer can be modified in various ways4450 4451 __isl_give isl_printer *isl_printer_set_output_format(4452 __isl_take isl_printer *p, int output_format);4453 __isl_give isl_printer *isl_printer_set_indent(4454 __isl_take isl_printer *p, int indent);4455 __isl_give isl_printer *isl_printer_set_indent_prefix(4456 __isl_take isl_printer *p, const char *prefix);4457 __isl_give isl_printer *isl_printer_indent(4458 __isl_take isl_printer *p, int indent);4459 __isl_give isl_printer *isl_printer_set_prefix(4460 __isl_take isl_printer *p, const char *prefix);4461 __isl_give isl_printer *isl_printer_set_suffix(4462 __isl_take isl_printer *p, const char *suffix);4463 __isl_give isl_printer *isl_printer_set_yaml_style(4464 __isl_take isl_printer *p, int yaml_style);4465 4466The C<output_format> may be either C<ISL_FORMAT_ISL>, C<ISL_FORMAT_OMEGA>,4467C<ISL_FORMAT_POLYLIB>, C<ISL_FORMAT_EXT_POLYLIB> or C<ISL_FORMAT_LATEX>4468and defaults to C<ISL_FORMAT_ISL>.4469Each line in the output is prefixed by C<indent_prefix>,4470indented by C<indent> (set by C<isl_printer_set_indent>) spaces4471(default: 0), prefixed by C<prefix> and suffixed by C<suffix>.4472In the C<PolyLib> format output,4473the coefficients of the existentially quantified variables4474appear between those of the set variables and those4475of the parameters.4476The function C<isl_printer_indent> increases the indentation4477by the specified amount (which may be negative).4478The YAML style may be either C<ISL_YAML_STYLE_BLOCK> or4479C<ISL_YAML_STYLE_FLOW> and when we are printing something4480in YAML format.4481 4482To actually print something, use4483 4484 #include <isl/printer.h>4485 __isl_give isl_printer *isl_printer_print_double(4486 __isl_take isl_printer *p, double d);4487 4488 #include <isl/val.h>4489 __isl_give isl_printer *isl_printer_print_val(4490 __isl_take isl_printer *p, __isl_keep isl_val *v);4491 __isl_give isl_printer *isl_printer_print_multi_val(4492 __isl_take isl_printer *p,4493 __isl_keep isl_multi_val *mv);4494 4495 #include <isl/set.h>4496 __isl_give isl_printer *isl_printer_print_basic_set(4497 __isl_take isl_printer *printer,4498 __isl_keep isl_basic_set *bset);4499 __isl_give isl_printer *isl_printer_print_set(4500 __isl_take isl_printer *printer,4501 __isl_keep isl_set *set);4502 4503 #include <isl/map.h>4504 __isl_give isl_printer *isl_printer_print_basic_map(4505 __isl_take isl_printer *printer,4506 __isl_keep isl_basic_map *bmap);4507 __isl_give isl_printer *isl_printer_print_map(4508 __isl_take isl_printer *printer,4509 __isl_keep isl_map *map);4510 4511 #include <isl/union_set.h>4512 __isl_give isl_printer *isl_printer_print_union_set(4513 __isl_take isl_printer *p,4514 __isl_keep isl_union_set *uset);4515 4516 #include <isl/union_map.h>4517 __isl_give isl_printer *isl_printer_print_union_map(4518 __isl_take isl_printer *p,4519 __isl_keep isl_union_map *umap);4520 4521 #include <isl/id.h>4522 __isl_give isl_printer *isl_printer_print_multi_id(4523 __isl_take isl_printer *p,4524 __isl_keep isl_multi_id *mi);4525 4526 #include <isl/aff.h>4527 __isl_give isl_printer *isl_printer_print_aff(4528 __isl_take isl_printer *p, __isl_keep isl_aff *aff);4529 __isl_give isl_printer *isl_printer_print_multi_aff(4530 __isl_take isl_printer *p,4531 __isl_keep isl_multi_aff *maff);4532 __isl_give isl_printer *isl_printer_print_pw_aff(4533 __isl_take isl_printer *p,4534 __isl_keep isl_pw_aff *pwaff);4535 __isl_give isl_printer *isl_printer_print_pw_multi_aff(4536 __isl_take isl_printer *p,4537 __isl_keep isl_pw_multi_aff *pma);4538 __isl_give isl_printer *isl_printer_print_multi_pw_aff(4539 __isl_take isl_printer *p,4540 __isl_keep isl_multi_pw_aff *mpa);4541 __isl_give isl_printer *isl_printer_print_union_pw_aff(4542 __isl_take isl_printer *p,4543 __isl_keep isl_union_pw_aff *upa);4544 __isl_give isl_printer *isl_printer_print_union_pw_multi_aff(4545 __isl_take isl_printer *p,4546 __isl_keep isl_union_pw_multi_aff *upma);4547 __isl_give isl_printer *4548 isl_printer_print_multi_union_pw_aff(4549 __isl_take isl_printer *p,4550 __isl_keep isl_multi_union_pw_aff *mupa);4551 4552 #include <isl/polynomial.h>4553 __isl_give isl_printer *isl_printer_print_qpolynomial(4554 __isl_take isl_printer *p,4555 __isl_keep isl_qpolynomial *qp);4556 __isl_give isl_printer *isl_printer_print_pw_qpolynomial(4557 __isl_take isl_printer *p,4558 __isl_keep isl_pw_qpolynomial *pwqp);4559 __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial(4560 __isl_take isl_printer *p,4561 __isl_keep isl_union_pw_qpolynomial *upwqp);4562 4563 __isl_give isl_printer *4564 isl_printer_print_pw_qpolynomial_fold(4565 __isl_take isl_printer *p,4566 __isl_keep isl_pw_qpolynomial_fold *pwf);4567 __isl_give isl_printer *4568 isl_printer_print_union_pw_qpolynomial_fold(4569 __isl_take isl_printer *p,4570 __isl_keep isl_union_pw_qpolynomial_fold *upwf);4571 4572For C<isl_printer_print_qpolynomial>,4573C<isl_printer_print_pw_qpolynomial> and4574C<isl_printer_print_pw_qpolynomial_fold>,4575the output format of the printer4576needs to be set to either C<ISL_FORMAT_ISL> or C<ISL_FORMAT_C>.4577For C<isl_printer_print_union_pw_qpolynomial> and4578C<isl_printer_print_union_pw_qpolynomial_fold>, only C<ISL_FORMAT_ISL>4579is supported.4580In case of printing in C<ISL_FORMAT_C>, the user may want4581to set the names of all dimensions first.4582 4583C<isl> also provides limited support for printing YAML documents,4584just enough for the internal use for printing such documents.4585 4586 #include <isl/printer.h>4587 __isl_give isl_printer *isl_printer_yaml_start_mapping(4588 __isl_take isl_printer *p);4589 __isl_give isl_printer *isl_printer_yaml_end_mapping(4590 __isl_take isl_printer *p);4591 __isl_give isl_printer *isl_printer_yaml_start_sequence(4592 __isl_take isl_printer *p);4593 __isl_give isl_printer *isl_printer_yaml_end_sequence(4594 __isl_take isl_printer *p);4595 __isl_give isl_printer *isl_printer_yaml_next(4596 __isl_take isl_printer *p);4597 4598A document is started by a call to either4599C<isl_printer_yaml_start_mapping> or C<isl_printer_yaml_start_sequence>.4600Anything printed to the printer after such a call belong to the4601first key of the mapping or the first element in the sequence.4602The function C<isl_printer_yaml_next> moves to the value if4603we are currently printing a mapping key, the next key if we4604are printing a value or the next element if we are printing4605an element in a sequence.4606Nested mappings and sequences are initiated by the same4607C<isl_printer_yaml_start_mapping> or C<isl_printer_yaml_start_sequence>.4608Each call to these functions needs to have a corresponding call to4609C<isl_printer_yaml_end_mapping> or C<isl_printer_yaml_end_sequence>.4610 4611When called on a file printer, the following function flushes4612the file. When called on a string printer, the buffer is cleared.4613 4614 __isl_give isl_printer *isl_printer_flush(4615 __isl_take isl_printer *p);4616 4617The following functions allow the user to attach4618notes to a printer in order to keep track of additional state.4619 4620 #include <isl/printer.h>4621 isl_bool isl_printer_has_note(__isl_keep isl_printer *p,4622 __isl_keep isl_id *id);4623 __isl_give isl_id *isl_printer_get_note(4624 __isl_keep isl_printer *p, __isl_take isl_id *id);4625 __isl_give isl_printer *isl_printer_set_note(4626 __isl_take isl_printer *p,4627 __isl_take isl_id *id, __isl_take isl_id *note);4628 4629C<isl_printer_set_note> associates the given note to the given4630identifier in the printer.4631C<isl_printer_get_note> retrieves a note associated to an4632identifier, while4633C<isl_printer_has_note> checks if there is such a note.4634C<isl_printer_get_note> fails if the requested note does not exist.4635 4636Alternatively, a string representation can be obtained4637directly using the following functions, which always print4638in isl format.4639 4640 #include <isl/id.h>4641 __isl_give char *isl_id_to_str(4642 __isl_keep isl_id *id);4643 __isl_give char *isl_multi_id_to_str(4644 __isl_keep isl_multi_id *mi);4645 4646 #include <isl/space.h>4647 __isl_give char *isl_space_to_str(4648 __isl_keep isl_space *space);4649 4650 #include <isl/val.h>4651 __isl_give char *isl_val_to_str(__isl_keep isl_val *v);4652 __isl_give char *isl_multi_val_to_str(4653 __isl_keep isl_multi_val *mv);4654 4655 #include <isl/set.h>4656 __isl_give char *isl_basic_set_to_str(4657 __isl_keep isl_basic_set *bset);4658 __isl_give char *isl_set_to_str(4659 __isl_keep isl_set *set);4660 4661 #include <isl/union_set.h>4662 __isl_give char *isl_union_set_to_str(4663 __isl_keep isl_union_set *uset);4664 4665 #include <isl/map.h>4666 __isl_give char *isl_basic_map_to_str(4667 __isl_keep isl_basic_map *bmap);4668 __isl_give char *isl_map_to_str(4669 __isl_keep isl_map *map);4670 4671 #include <isl/union_map.h>4672 __isl_give char *isl_union_map_to_str(4673 __isl_keep isl_union_map *umap);4674 4675 #include <isl/aff.h>4676 __isl_give char *isl_aff_to_str(__isl_keep isl_aff *aff);4677 __isl_give char *isl_pw_aff_to_str(4678 __isl_keep isl_pw_aff *pa);4679 __isl_give char *isl_multi_aff_to_str(4680 __isl_keep isl_multi_aff *ma);4681 __isl_give char *isl_pw_multi_aff_to_str(4682 __isl_keep isl_pw_multi_aff *pma);4683 __isl_give char *isl_multi_pw_aff_to_str(4684 __isl_keep isl_multi_pw_aff *mpa);4685 __isl_give char *isl_union_pw_aff_to_str(4686 __isl_keep isl_union_pw_aff *upa);4687 __isl_give char *isl_union_pw_multi_aff_to_str(4688 __isl_keep isl_union_pw_multi_aff *upma);4689 __isl_give char *isl_multi_union_pw_aff_to_str(4690 __isl_keep isl_multi_union_pw_aff *mupa);4691 4692 #include <isl/point.h>4693 __isl_give char *isl_point_to_str(4694 __isl_keep isl_point *pnt);4695 4696 #include <isl/polynomial.h>4697 __isl_give char *isl_pw_qpolynomial_to_str(4698 __isl_keep isl_pw_qpolynomial *pwqp);4699 __isl_give char *isl_union_pw_qpolynomial_to_str(4700 __isl_keep isl_union_pw_qpolynomial *upwqp);4701 4702=head2 Properties4703 4704=head3 Unary Properties4705 4706=over4707 4708=item * Emptiness4709 4710The following functions test whether the given set or relation4711contains any integer points. The ``plain'' variants do not perform4712any computations, but simply check if the given set or relation4713is already known to be empty.4714 4715 #include <isl/set.h>4716 isl_bool isl_basic_set_plain_is_empty(4717 __isl_keep isl_basic_set *bset);4718 isl_bool isl_basic_set_is_empty(4719 __isl_keep isl_basic_set *bset);4720 isl_bool isl_set_plain_is_empty(4721 __isl_keep isl_set *set);4722 isl_bool isl_set_is_empty(__isl_keep isl_set *set);4723 4724 #include <isl/union_set.h>4725 isl_bool isl_union_set_is_empty(4726 __isl_keep isl_union_set *uset);4727 4728 #include <isl/map.h>4729 isl_bool isl_basic_map_plain_is_empty(4730 __isl_keep isl_basic_map *bmap);4731 isl_bool isl_basic_map_is_empty(4732 __isl_keep isl_basic_map *bmap);4733 isl_bool isl_map_plain_is_empty(4734 __isl_keep isl_map *map);4735 isl_bool isl_map_is_empty(__isl_keep isl_map *map);4736 4737 #include <isl/union_map.h>4738 isl_bool isl_union_map_plain_is_empty(4739 __isl_keep isl_union_map *umap);4740 isl_bool isl_union_map_is_empty(4741 __isl_keep isl_union_map *umap);4742 4743 #include <isl/aff.h>4744 isl_bool isl_union_pw_multi_aff_plain_is_empty(4745 __isl_keep isl_union_pw_multi_aff *upma);4746 4747=item * Universality4748 4749 isl_bool isl_basic_set_plain_is_universe(4750 __isl_keep isl_basic_set *bset);4751 isl_bool isl_basic_set_is_universe(4752 __isl_keep isl_basic_set *bset);4753 isl_bool isl_basic_map_plain_is_universe(4754 __isl_keep isl_basic_map *bmap);4755 isl_bool isl_basic_map_is_universe(4756 __isl_keep isl_basic_map *bmap);4757 isl_bool isl_set_plain_is_universe(4758 __isl_keep isl_set *set);4759 isl_bool isl_map_plain_is_universe(4760 __isl_keep isl_map *map);4761 4762=item * Single-valuedness4763 4764 #include <isl/set.h>4765 isl_bool isl_set_is_singleton(__isl_keep isl_set *set);4766 4767 #include <isl/map.h>4768 isl_bool isl_basic_map_is_single_valued(4769 __isl_keep isl_basic_map *bmap);4770 isl_bool isl_map_plain_is_single_valued(4771 __isl_keep isl_map *map);4772 isl_bool isl_map_is_single_valued(__isl_keep isl_map *map);4773 4774 #include <isl/union_map.h>4775 isl_bool isl_union_map_is_single_valued(4776 __isl_keep isl_union_map *umap);4777 4778=item * Injectivity4779 4780 isl_bool isl_map_plain_is_injective(4781 __isl_keep isl_map *map);4782 isl_bool isl_map_is_injective(4783 __isl_keep isl_map *map);4784 isl_bool isl_union_map_plain_is_injective(4785 __isl_keep isl_union_map *umap);4786 isl_bool isl_union_map_is_injective(4787 __isl_keep isl_union_map *umap);4788 4789=item * Bijectivity4790 4791 isl_bool isl_map_is_bijective(4792 __isl_keep isl_map *map);4793 isl_bool isl_union_map_is_bijective(4794 __isl_keep isl_union_map *umap);4795 4796=item * Identity4797 4798The following functions test whether the given relation4799only maps elements to themselves.4800 4801 #include <isl/map.h>4802 isl_bool isl_map_is_identity(4803 __isl_keep isl_map *map);4804 4805 #include <isl/union_map.h>4806 isl_bool isl_union_map_is_identity(4807 __isl_keep isl_union_map *umap);4808 4809=item * Position4810 4811 __isl_give isl_val *4812 isl_basic_map_plain_get_val_if_fixed(4813 __isl_keep isl_basic_map *bmap,4814 enum isl_dim_type type, unsigned pos);4815 __isl_give isl_val *isl_set_plain_get_val_if_fixed(4816 __isl_keep isl_set *set,4817 enum isl_dim_type type, unsigned pos);4818 __isl_give isl_multi_val *4819 isl_set_get_plain_multi_val_if_fixed(4820 __isl_keep isl_set *set);4821 __isl_give isl_val *isl_map_plain_get_val_if_fixed(4822 __isl_keep isl_map *map,4823 enum isl_dim_type type, unsigned pos);4824 4825If the set or relation obviously lies on a hyperplane where the given dimension4826has a fixed value, then return that value.4827Otherwise return NaN.4828C<isl_set_get_plain_multi_val_if_fixed> collects the results over4829all set dimensions.4830 4831=item * Stride4832 4833Stride detection is based on heuristics.4834The strides returned by the functions below are always valid,4835but there may be larger valid strides that are not detected.4836 4837 isl_stat isl_set_dim_residue_class_val(4838 __isl_keep isl_set *set,4839 int pos, __isl_give isl_val **modulo,4840 __isl_give isl_val **residue);4841 4842Check if the values of the given set dimension are equal to a fixed4843value modulo some integer value. If so, assign the modulo to C<*modulo>4844and the fixed value to C<*residue>. If the given dimension attains only4845a single value, then assign C<0> to C<*modulo> and the fixed value to4846C<*residue>.4847If the dimension does not attain only a single value and if no modulo4848can be found then assign C<1> to C<*modulo> and C<1> to C<*residue>.4849 4850 #include <isl/set.h>4851 __isl_give isl_stride_info *isl_set_get_stride_info(4852 __isl_keep isl_set *set, int pos);4853 __isl_give isl_val *isl_set_get_stride(4854 __isl_keep isl_set *set, int pos);4855 __isl_give isl_fixed_box *isl_set_get_lattice_tile(4856 __isl_keep isl_set *set);4857 4858 #include <isl/map.h>4859 __isl_give isl_stride_info *4860 isl_map_get_range_stride_info(4861 __isl_keep isl_map *map, int pos);4862 __isl_give isl_fixed_box *4863 isl_map_get_range_lattice_tile(4864 __isl_keep isl_map *map);4865 4866Check if the values of the given set dimension are equal to4867some affine expression of the other dimensions (the offset)4868modulo some integer stride or4869check if the values of the given output dimensions are equal to4870some affine expression of the input dimensions (the offset)4871modulo some integer stride.4872If no more specific information can be found, then the stride4873is taken to be one and the offset is taken to be the zero expression.4874The function C<isl_set_get_stride> performs the same4875computation as C<isl_set_get_stride_info> but only returns the stride.4876The function C<isl_map_get_range_lattice_tile> collects the stride4877information over all output dimensions.4878In particular, it returns a tile of a rectangular lattice4879(possibly of size 1 in all directions)4880containing the output in terms of the parameters and the input dimensions.4881The size and the offset of this tile correspond to4882the strides and the offsets of the stride information and4883can be extracted from the returned4884C<isl_fixed_box> using the functions described under "Box hull" in4885L</"Unary Operations">. Note that the C<isl_fixed_box> object returned by4886C<isl_map_get_range_lattice_tile> is always valid.4887The function C<isl_set_get_lattice_tile> collects the same stride4888information over all set dimensions.4889For the other functions,4890the stride and offset can be extracted from the returned object4891using the following functions.4892 4893 #include <isl/stride_info.h>4894 __isl_give isl_val *isl_stride_info_get_stride(4895 __isl_keep isl_stride_info *si);4896 __isl_give isl_aff *isl_stride_info_get_offset(4897 __isl_keep isl_stride_info *si);4898 4899The stride info object can be copied and released using the following4900functions.4901 4902 #include <isl/stride_info.h>4903 __isl_give isl_stride_info *isl_stride_info_copy(4904 __isl_keep isl_stride_info *si);4905 __isl_null isl_stride_info *isl_stride_info_free(4906 __isl_take isl_stride_info *si);4907 4908=item * Dependence4909 4910To check whether a function involves any local variables,4911i.e., integer divisions,4912the following functions can be used.4913 4914 #include <isl/set.h>4915 isl_bool isl_set_involves_locals(4916 __isl_keep isl_set *set);4917 4918 #include <isl/aff.h>4919 isl_bool isl_aff_involves_locals(4920 __isl_keep isl_aff *aff);4921 isl_bool isl_multi_aff_involves_locals(4922 __isl_keep isl_multi_aff *ma);4923 isl_bool isl_pw_multi_aff_involves_locals(4924 __isl_keep isl_pw_multi_aff *pma);4925 isl_bool isl_union_pw_multi_aff_involves_locals(4926 __isl_keep isl_union_pw_multi_aff *upma);4927 4928To check whether the description of a set, relation or function depends4929on a parameter or one or more given dimensions,4930the following functions can be used.4931 4932 #include <isl/constraint.h>4933 isl_bool isl_constraint_involves_dims(4934 __isl_keep isl_constraint *constraint,4935 enum isl_dim_type type, unsigned first, unsigned n);4936 4937 #include <isl/set.h>4938 isl_bool isl_basic_set_involves_dims(4939 __isl_keep isl_basic_set *bset,4940 enum isl_dim_type type, unsigned first, unsigned n);4941 isl_bool isl_set_involves_dims(__isl_keep isl_set *set,4942 enum isl_dim_type type, unsigned first, unsigned n);4943 4944 #include <isl/map.h>4945 isl_bool isl_basic_map_involves_dims(4946 __isl_keep isl_basic_map *bmap,4947 enum isl_dim_type type, unsigned first, unsigned n);4948 isl_bool isl_map_involves_dims(__isl_keep isl_map *map,4949 enum isl_dim_type type, unsigned first, unsigned n);4950 4951 #include <isl/union_map.h>4952 isl_bool isl_union_map_involves_dims(4953 __isl_keep isl_union_map *umap,4954 enum isl_dim_type type, unsigned first, unsigned n);4955 4956 #include <isl/aff.h>4957 isl_bool isl_aff_involves_dims(__isl_keep isl_aff *aff,4958 enum isl_dim_type type, unsigned first, unsigned n);4959 isl_bool isl_pw_aff_involves_param_id(4960 __isl_keep isl_pw_aff *pa,4961 __isl_keep isl_id *id);4962 isl_bool isl_pw_aff_involves_dims(4963 __isl_keep isl_pw_aff *pwaff,4964 enum isl_dim_type type, unsigned first, unsigned n);4965 isl_bool isl_multi_aff_involves_dims(4966 __isl_keep isl_multi_aff *ma,4967 enum isl_dim_type type, unsigned first, unsigned n);4968 isl_bool isl_pw_multi_aff_involves_param_id(4969 __isl_keep isl_pw_multi_aff *pma,4970 __isl_keep isl_id *id);4971 isl_bool isl_pw_multi_aff_involves_dims(4972 __isl_keep isl_pw_multi_aff *pma,4973 enum isl_dim_type type, unsigned first, unsigned n);4974 isl_bool isl_multi_pw_aff_involves_dims(4975 __isl_keep isl_multi_pw_aff *mpa,4976 enum isl_dim_type type, unsigned first, unsigned n);4977 isl_bool isl_multi_pw_aff_involves_param_id(4978 __isl_keep isl_multi_pw_aff *mpa,4979 __isl_keep isl_id *id);4980 isl_bool isl_multi_pw_aff_involves_param_id_list(4981 __isl_keep isl_multi_pw_aff *mpa,4982 __isl_keep isl_id_list *list);4983 4984 #include <isl/polynomial.h>4985 isl_bool isl_qpolynomial_involves_dims(4986 __isl_keep isl_qpolynomial *qp,4987 enum isl_dim_type type, unsigned first, unsigned n);4988 isl_bool isl_pw_qpolynomial_involves_param_id(4989 __isl_keep isl_pw_qpolynomial *pwqp,4990 __isl_keep isl_id *id);4991 isl_bool isl_pw_qpolynomial_fold_involves_param_id(4992 __isl_keep isl_pw_qpolynomial_fold *pwf,4993 __isl_keep isl_id *id);4994 4995Similarly, the following functions can be used to check whether4996a given dimension is involved in any lower or upper bound.4997 4998 #include <isl/set.h>4999 isl_bool isl_set_dim_has_any_lower_bound(5000 __isl_keep isl_set *set,5001 enum isl_dim_type type, unsigned pos);5002 isl_bool isl_set_dim_has_any_upper_bound(5003 __isl_keep isl_set *set,5004 enum isl_dim_type type, unsigned pos);5005 5006Note that these functions return true even if there is a bound on5007the dimension on only some of the basic sets of C<set>.5008To check if they have a bound for all of the basic sets in C<set>,5009use the following functions instead.5010 5011 #include <isl/set.h>5012 isl_bool isl_set_dim_has_lower_bound(5013 __isl_keep isl_set *set,5014 enum isl_dim_type type, unsigned pos);5015 isl_bool isl_set_dim_has_upper_bound(5016 __isl_keep isl_set *set,5017 enum isl_dim_type type, unsigned pos);5018 5019=item * Space5020 5021To check whether a set is a parameter domain, use this function:5022 5023 isl_bool isl_set_is_params(__isl_keep isl_set *set);5024 isl_bool isl_union_set_is_params(5025 __isl_keep isl_union_set *uset);5026 5027=item * Wrapping5028 5029The following functions check whether the space of the given5030(basic) set or relation domain and/or range is a wrapped relation.5031 5032 #include <isl/space.h>5033 isl_bool isl_space_is_wrapping(5034 __isl_keep isl_space *space);5035 isl_bool isl_space_domain_is_wrapping(5036 __isl_keep isl_space *space);5037 isl_bool isl_space_range_is_wrapping(5038 __isl_keep isl_space *space);5039 isl_bool isl_space_is_product(5040 __isl_keep isl_space *space);5041 5042 #include <isl/set.h>5043 isl_bool isl_basic_set_is_wrapping(5044 __isl_keep isl_basic_set *bset);5045 isl_bool isl_set_is_wrapping(__isl_keep isl_set *set);5046 5047 #include <isl/map.h>5048 isl_bool isl_map_domain_is_wrapping(5049 __isl_keep isl_map *map);5050 isl_bool isl_map_range_is_wrapping(5051 __isl_keep isl_map *map);5052 isl_bool isl_map_is_product(__isl_keep isl_map *map);5053 5054 #include <isl/id.h>5055 isl_bool isl_multi_id_range_is_wrapping(5056 __isl_keep isl_multi_id *mi);5057 5058 #include <isl/val.h>5059 isl_bool isl_multi_val_range_is_wrapping(5060 __isl_keep isl_multi_val *mv);5061 5062 #include <isl/aff.h>5063 isl_bool isl_multi_aff_range_is_wrapping(5064 __isl_keep isl_multi_aff *ma);5065 isl_bool isl_multi_pw_aff_range_is_wrapping(5066 __isl_keep isl_multi_pw_aff *mpa);5067 isl_bool isl_multi_union_pw_aff_range_is_wrapping(5068 __isl_keep isl_multi_union_pw_aff *mupa);5069 5070The input to C<isl_space_is_wrapping> should5071be the space of a set, while that of5072C<isl_space_domain_is_wrapping> and5073C<isl_space_range_is_wrapping> should be the space of a relation.5074The input to C<isl_space_is_product> can be either the space5075of a set or that of a binary relation.5076In case the input is the space of a binary relation, it checks5077whether both domain and range are wrapping.5078 5079=item * Internal Product5080 5081 isl_bool isl_basic_map_can_zip(5082 __isl_keep isl_basic_map *bmap);5083 isl_bool isl_map_can_zip(__isl_keep isl_map *map);5084 5085Check whether the product of domain and range of the given relation5086can be computed,5087i.e., whether both domain and range are nested relations.5088 5089=item * Currying5090 5091 #include <isl/space.h>5092 isl_bool isl_space_can_curry(5093 __isl_keep isl_space *space);5094 5095 #include <isl/map.h>5096 isl_bool isl_basic_map_can_curry(5097 __isl_keep isl_basic_map *bmap);5098 isl_bool isl_map_can_curry(__isl_keep isl_map *map);5099 5100Check whether the domain of the (basic) relation is a wrapped relation.5101 5102 #include <isl/space.h>5103 isl_bool isl_space_can_uncurry(5104 __isl_keep isl_space *space);5105 5106 #include <isl/map.h>5107 isl_bool isl_basic_map_can_uncurry(5108 __isl_keep isl_basic_map *bmap);5109 isl_bool isl_map_can_uncurry(__isl_keep isl_map *map);5110 5111Check whether the range of the (basic) relation is a wrapped relation.5112 5113 #include <isl/space.h>5114 isl_bool isl_space_can_range_curry(5115 __isl_keep isl_space *space);5116 5117 #include <isl/map.h>5118 isl_bool isl_map_can_range_curry(5119 __isl_keep isl_map *map);5120 5121Check whether the domain of the relation wrapped in the range of5122the input is itself a wrapped relation.5123 5124=item * Special Values5125 5126 #include <isl/aff.h>5127 isl_bool isl_aff_is_cst(__isl_keep isl_aff *aff);5128 isl_bool isl_pw_aff_is_cst(__isl_keep isl_pw_aff *pwaff);5129 isl_bool isl_multi_pw_aff_is_cst(5130 __isl_keep isl_multi_pw_aff *mpa);5131 5132Check whether the given expression is a constant.5133 5134 #include <isl/val.h>5135 isl_bool isl_multi_val_involves_nan(5136 __isl_keep isl_multi_val *mv);5137 5138 #include <isl/aff.h>5139 isl_bool isl_aff_is_nan(__isl_keep isl_aff *aff);5140 isl_bool isl_multi_aff_involves_nan(5141 __isl_keep isl_multi_aff *ma);5142 isl_bool isl_pw_aff_involves_nan(5143 __isl_keep isl_pw_aff *pa);5144 isl_bool isl_pw_multi_aff_involves_nan(5145 __isl_keep isl_pw_multi_aff *pma);5146 isl_bool isl_multi_pw_aff_involves_nan(5147 __isl_keep isl_multi_pw_aff *mpa);5148 isl_bool isl_union_pw_aff_involves_nan(5149 __isl_keep isl_union_pw_aff *upa);5150 isl_bool isl_union_pw_multi_aff_involves_nan(5151 __isl_keep isl_union_pw_multi_aff *upma);5152 isl_bool isl_multi_union_pw_aff_involves_nan(5153 __isl_keep isl_multi_union_pw_aff *mupa);5154 5155 #include <isl/polynomial.h>5156 isl_bool isl_qpolynomial_is_nan(5157 __isl_keep isl_qpolynomial *qp);5158 isl_bool isl_qpolynomial_fold_is_nan(5159 __isl_keep isl_qpolynomial_fold *fold);5160 isl_bool isl_pw_qpolynomial_involves_nan(5161 __isl_keep isl_pw_qpolynomial *pwqp);5162 isl_bool isl_pw_qpolynomial_fold_involves_nan(5163 __isl_keep isl_pw_qpolynomial_fold *pwf);5164 isl_bool isl_union_pw_qpolynomial_involves_nan(5165 __isl_keep isl_union_pw_qpolynomial *upwqp);5166 isl_bool isl_union_pw_qpolynomial_fold_involves_nan(5167 __isl_keep isl_union_pw_qpolynomial_fold *upwf);5168 5169Check whether the given expression is equal to or involves NaN.5170 5171 #include <isl/val.h>5172 isl_bool isl_multi_val_is_zero(5173 __isl_keep isl_multi_val *mv);5174 5175Check whether the multiple value is zero.5176 5177 #include <isl/aff.h>5178 isl_bool isl_aff_plain_is_zero(5179 __isl_keep isl_aff *aff);5180 5181Check whether the affine expression is obviously zero.5182 5183=back5184 5185=head3 Binary Properties5186 5187=over5188 5189=item * Equality5190 5191The following functions check whether two objects5192represent the same set, relation or function.5193The C<plain> variants only return true if the objects5194are obviously the same. That is, they may return false5195even if the objects are the same, but they will never5196return true if the objects are not the same.5197 5198 #include <isl/set.h>5199 isl_bool isl_basic_set_plain_is_equal(5200 __isl_keep isl_basic_set *bset1,5201 __isl_keep isl_basic_set *bset2);5202 isl_bool isl_basic_set_is_equal(5203 __isl_keep isl_basic_set *bset1,5204 __isl_keep isl_basic_set *bset2);5205 isl_bool isl_set_plain_is_equal(5206 __isl_keep isl_set *set1,5207 __isl_keep isl_set *set2);5208 isl_bool isl_set_is_equal(__isl_keep isl_set *set1,5209 __isl_keep isl_set *set2);5210 5211 #include <isl/map.h>5212 isl_bool isl_basic_map_is_equal(5213 __isl_keep isl_basic_map *bmap1,5214 __isl_keep isl_basic_map *bmap2);5215 isl_bool isl_map_is_equal(__isl_keep isl_map *map1,5216 __isl_keep isl_map *map2);5217 isl_bool isl_map_plain_is_equal(5218 __isl_keep isl_map *map1,5219 __isl_keep isl_map *map2);5220 5221 #include <isl/union_set.h>5222 isl_bool isl_union_set_is_equal(5223 __isl_keep isl_union_set *uset1,5224 __isl_keep isl_union_set *uset2);5225 5226 #include <isl/union_map.h>5227 isl_bool isl_union_map_is_equal(5228 __isl_keep isl_union_map *umap1,5229 __isl_keep isl_union_map *umap2);5230 5231 #include <isl/id.h>5232 isl_bool isl_multi_id_plain_is_equal(5233 __isl_keep isl_multi_id *mi1,5234 __isl_keep isl_multi_id *mi2);5235 5236 #include <isl/val.h>5237 isl_bool isl_multi_val_plain_is_equal(5238 __isl_keep isl_multi_val *mv1,5239 __isl_keep isl_multi_val *mv2);5240 5241 #include <isl/aff.h>5242 isl_bool isl_aff_plain_is_equal(5243 __isl_keep isl_aff *aff1,5244 __isl_keep isl_aff *aff2);5245 isl_bool isl_multi_aff_plain_is_equal(5246 __isl_keep isl_multi_aff *maff1,5247 __isl_keep isl_multi_aff *maff2);5248 isl_bool isl_pw_aff_plain_is_equal(5249 __isl_keep isl_pw_aff *pwaff1,5250 __isl_keep isl_pw_aff *pwaff2);5251 isl_bool isl_pw_aff_is_equal(5252 __isl_keep isl_pw_aff *pa1,5253 __isl_keep isl_pw_aff *pa2);5254 isl_bool isl_pw_multi_aff_plain_is_equal(5255 __isl_keep isl_pw_multi_aff *pma1,5256 __isl_keep isl_pw_multi_aff *pma2);5257 isl_bool isl_pw_multi_aff_is_equal(5258 __isl_keep isl_pw_multi_aff *pma1,5259 __isl_keep isl_pw_multi_aff *pma2);5260 isl_bool isl_multi_pw_aff_plain_is_equal(5261 __isl_keep isl_multi_pw_aff *mpa1,5262 __isl_keep isl_multi_pw_aff *mpa2);5263 isl_bool isl_multi_pw_aff_is_equal(5264 __isl_keep isl_multi_pw_aff *mpa1,5265 __isl_keep isl_multi_pw_aff *mpa2);5266 isl_bool isl_union_pw_aff_plain_is_equal(5267 __isl_keep isl_union_pw_aff *upa1,5268 __isl_keep isl_union_pw_aff *upa2);5269 isl_bool isl_union_pw_multi_aff_plain_is_equal(5270 __isl_keep isl_union_pw_multi_aff *upma1,5271 __isl_keep isl_union_pw_multi_aff *upma2);5272 isl_bool isl_multi_union_pw_aff_plain_is_equal(5273 __isl_keep isl_multi_union_pw_aff *mupa1,5274 __isl_keep isl_multi_union_pw_aff *mupa2);5275 5276 #include <isl/polynomial.h>5277 isl_bool isl_union_pw_qpolynomial_plain_is_equal(5278 __isl_keep isl_union_pw_qpolynomial *upwqp1,5279 __isl_keep isl_union_pw_qpolynomial *upwqp2);5280 isl_bool isl_union_pw_qpolynomial_fold_plain_is_equal(5281 __isl_keep isl_union_pw_qpolynomial_fold *upwf1,5282 __isl_keep isl_union_pw_qpolynomial_fold *upwf2);5283 5284=item * Disjointness5285 5286 #include <isl/set.h>5287 isl_bool isl_basic_set_is_disjoint(5288 __isl_keep isl_basic_set *bset1,5289 __isl_keep isl_basic_set *bset2);5290 isl_bool isl_set_plain_is_disjoint(5291 __isl_keep isl_set *set1,5292 __isl_keep isl_set *set2);5293 isl_bool isl_set_is_disjoint(__isl_keep isl_set *set1,5294 __isl_keep isl_set *set2);5295 5296 #include <isl/map.h>5297 isl_bool isl_basic_map_is_disjoint(5298 __isl_keep isl_basic_map *bmap1,5299 __isl_keep isl_basic_map *bmap2);5300 isl_bool isl_map_is_disjoint(__isl_keep isl_map *map1,5301 __isl_keep isl_map *map2);5302 5303 #include <isl/union_set.h>5304 isl_bool isl_union_set_is_disjoint(5305 __isl_keep isl_union_set *uset1,5306 __isl_keep isl_union_set *uset2);5307 5308 #include <isl/union_map.h>5309 isl_bool isl_union_map_is_disjoint(5310 __isl_keep isl_union_map *umap1,5311 __isl_keep isl_union_map *umap2);5312 5313=item * Subset5314 5315 isl_bool isl_basic_set_is_subset(5316 __isl_keep isl_basic_set *bset1,5317 __isl_keep isl_basic_set *bset2);5318 isl_bool isl_set_is_subset(__isl_keep isl_set *set1,5319 __isl_keep isl_set *set2);5320 isl_bool isl_set_is_strict_subset(5321 __isl_keep isl_set *set1,5322 __isl_keep isl_set *set2);5323 isl_bool isl_union_set_is_subset(5324 __isl_keep isl_union_set *uset1,5325 __isl_keep isl_union_set *uset2);5326 isl_bool isl_union_set_is_strict_subset(5327 __isl_keep isl_union_set *uset1,5328 __isl_keep isl_union_set *uset2);5329 isl_bool isl_basic_map_is_subset(5330 __isl_keep isl_basic_map *bmap1,5331 __isl_keep isl_basic_map *bmap2);5332 isl_bool isl_basic_map_is_strict_subset(5333 __isl_keep isl_basic_map *bmap1,5334 __isl_keep isl_basic_map *bmap2);5335 isl_bool isl_map_is_subset(5336 __isl_keep isl_map *map1,5337 __isl_keep isl_map *map2);5338 isl_bool isl_map_is_strict_subset(5339 __isl_keep isl_map *map1,5340 __isl_keep isl_map *map2);5341 isl_bool isl_union_map_is_subset(5342 __isl_keep isl_union_map *umap1,5343 __isl_keep isl_union_map *umap2);5344 isl_bool isl_union_map_is_strict_subset(5345 __isl_keep isl_union_map *umap1,5346 __isl_keep isl_union_map *umap2);5347 5348Check whether the first argument is a (strict) subset of the5349second argument.5350 5351=item * Order5352 5353Every comparison function returns a negative value if the first5354argument is considered smaller than the second, a positive value5355if the first argument is considered greater and zero if the two5356constraints are considered the same by the comparison criterion.5357 5358 #include <isl/constraint.h>5359 int isl_constraint_plain_cmp(5360 __isl_keep isl_constraint *c1,5361 __isl_keep isl_constraint *c2);5362 5363This function is useful for sorting C<isl_constraint>s.5364The order depends on the internal representation of the inputs.5365The order is fixed over different calls to the function (assuming5366the internal representation of the inputs has not changed), but may5367change over different versions of C<isl>.5368 5369 #include <isl/constraint.h>5370 int isl_constraint_cmp_last_non_zero(5371 __isl_keep isl_constraint *c1,5372 __isl_keep isl_constraint *c2);5373 5374This function can be used to sort constraints that live in the same5375local space. Constraints that involve ``earlier'' dimensions or5376that have a smaller coefficient for the shared latest dimension5377are considered smaller than other constraints.5378This function only defines a B<partial> order.5379 5380 #include <isl/set.h>5381 int isl_set_plain_cmp(__isl_keep isl_set *set1,5382 __isl_keep isl_set *set2);5383 5384This function is useful for sorting C<isl_set>s.5385The order depends on the internal representation of the inputs.5386The order is fixed over different calls to the function (assuming5387the internal representation of the inputs has not changed), but may5388change over different versions of C<isl>.5389 5390 #include <isl/aff.h>5391 int isl_multi_aff_plain_cmp(5392 __isl_keep isl_multi_aff *ma1,5393 __isl_keep isl_multi_aff *ma2);5394 int isl_pw_aff_plain_cmp(__isl_keep isl_pw_aff *pa1,5395 __isl_keep isl_pw_aff *pa2);5396 5397The functions C<isl_multi_aff_plain_cmp> and5398C<isl_pw_aff_plain_cmp> can be used to sort C<isl_multi_aff>s and5399C<isl_pw_aff>s. The order is not strictly defined.5400The current order sorts expressions that only involve5401earlier dimensions before those that involve later dimensions.5402 5403=back5404 5405=head2 Unary Operations5406 5407=over5408 5409=item * Complement5410 5411 __isl_give isl_set *isl_set_complement(5412 __isl_take isl_set *set);5413 __isl_give isl_map *isl_map_complement(5414 __isl_take isl_map *map);5415 5416=item * Inverse map5417 5418 #include <isl/space.h>5419 __isl_give isl_space *isl_space_reverse(5420 __isl_take isl_space *space);5421 __isl_give isl_space *isl_space_range_reverse(5422 __isl_take isl_space *space);5423 5424 #include <isl/map.h>5425 __isl_give isl_basic_map *isl_basic_map_reverse(5426 __isl_take isl_basic_map *bmap);5427 __isl_give isl_map *isl_map_reverse(5428 __isl_take isl_map *map);5429 __isl_give isl_map *isl_map_range_reverse(5430 __isl_take isl_map *map);5431 5432 #include <isl/union_map.h>5433 __isl_give isl_union_map *isl_union_map_reverse(5434 __isl_take isl_union_map *umap);5435 __isl_give isl_union_map *isl_union_map_range_reverse(5436 __isl_take isl_union_map *umap);5437 5438The function C<isl_space_range_reverse> reverses the relation5439that is embedded in the range of the input map space.5440The identifier of the range, if any, is only preserved5441if this embedded relation has identical input and output tuples.5442 5443=item * Tuple binding5444 5445The following function binds5446a tuple to a sequence of parameter identifiers, equating5447the tuple dimensions to the parameters with those identifiers and5448subsequently projecting out the tuple.5449If the original object did not reference any such parameters,5450then this means that the tuple dimensions are reinterpreted5451as parameters.5452The space of C<tuple> needs to match that of the bound tuple.5453 5454 #include <isl/set.h>5455 __isl_give isl_set *isl_set_bind(5456 __isl_take isl_set *set,5457 __isl_take isl_multi_id *tuple);5458 5459 #include <isl/map.h>5460 __isl_give isl_set *isl_map_bind_domain(5461 __isl_take isl_map *map,5462 __isl_take isl_multi_id *tuple);5463 __isl_give isl_set *isl_map_bind_range(5464 __isl_take isl_map *map,5465 __isl_take isl_multi_id *tuple);5466 5467 #include <isl/union_map.h>5468 __isl_give isl_union_set *isl_union_map_bind_range(5469 __isl_take isl_union_map *umap,5470 __isl_take isl_multi_id *tuple);5471 5472 #include <isl/aff.h>5473 __isl_give isl_pw_aff *isl_pw_aff_bind_domain(5474 __isl_take isl_pw_aff *pa,5475 __isl_take isl_multi_id *tuple);5476 __isl_give isl_multi_aff *isl_multi_aff_bind_domain(5477 __isl_take isl_multi_aff *ma,5478 __isl_take isl_multi_id *tuple);5479 __isl_give isl_pw_multi_aff *5480 isl_pw_multi_aff_bind_domain(5481 __isl_take isl_pw_multi_aff *pma,5482 __isl_take isl_multi_id *tuple);5483 __isl_give isl_multi_pw_aff *5484 isl_multi_pw_aff_bind_domain(5485 __isl_take isl_multi_pw_aff *mpa,5486 __isl_take isl_multi_id *tuple);5487 __isl_give isl_pw_aff *5488 isl_pw_aff_bind_domain_wrapped_domain(5489 __isl_take isl_pw_aff *pa,5490 __isl_take isl_multi_id *tuple);5491 __isl_give isl_multi_aff *5492 isl_multi_aff_bind_domain_wrapped_domain(5493 __isl_take isl_multi_aff *ma,5494 __isl_take isl_multi_id *tuple);5495 __isl_give isl_pw_multi_aff *5496 isl_pw_multi_aff_bind_domain_wrapped_domain(5497 __isl_take isl_pw_multi_aff *pma,5498 __isl_take isl_multi_id *tuple);5499 __isl_give isl_multi_pw_aff *5500 isl_multi_pw_aff_bind_domain_wrapped_domain(5501 __isl_take isl_multi_pw_aff *mpa,5502 __isl_take isl_multi_id *tuple);5503 __isl_give isl_basic_set *isl_aff_bind_id(5504 __isl_take isl_aff *aff,5505 __isl_take isl_id *id);5506 __isl_give isl_set *isl_pw_aff_bind_id(5507 __isl_take isl_pw_aff *pa,5508 __isl_take isl_id *id);5509 __isl_give isl_basic_set *isl_multi_aff_bind(5510 __isl_take isl_multi_aff *ma,5511 __isl_take isl_multi_id *tuple);5512 __isl_give isl_set *isl_multi_pw_aff_bind(5513 __isl_take isl_multi_pw_aff *mpa,5514 __isl_take isl_multi_id *tuple);5515 __isl_give isl_union_set *isl_union_pw_aff_bind_id(5516 __isl_take isl_union_pw_aff *upa,5517 __isl_take isl_id *id);5518 __isl_give isl_union_set *5519 isl_multi_union_pw_aff_bind(5520 __isl_take isl_multi_union_pw_aff *mupa,5521 __isl_take isl_multi_id *tuple);5522 5523Projecting out the domain of the wrapped relation in the domain5524of a function leaves the range of that wrapped relation5525in the domain of the resulting function.5526In the case of C<isl_aff_bind_id>, C<isl_pw_aff_bind_id>,5527C<isl_multi_aff_bind>, C<isl_multi_pw_aff_bind>,5528C<isl_union_pw_aff_bind_id> and5529C<isl_multi_union_pw_aff_bind>, the parameters5530are bound to the function values and the result lives5531in the domain of the input function.5532 5533=item * Projection5534 5535 #include <isl/space.h>5536 __isl_give isl_space *isl_space_domain(5537 __isl_take isl_space *space);5538 __isl_give isl_space *isl_space_range(5539 __isl_take isl_space *space);5540 __isl_give isl_space *isl_space_params(5541 __isl_take isl_space *space);5542 __isl_give isl_space *5543 isl_space_domain_wrapped_domain(5544 __isl_take isl_space *space);5545 __isl_give isl_space *5546 isl_space_domain_wrapped_range(5547 __isl_take isl_space *space);5548 __isl_give isl_space *5549 isl_space_range_wrapped_domain(5550 __isl_take isl_space *space);5551 __isl_give isl_space *5552 isl_space_range_wrapped_range(5553 __isl_take isl_space *space);5554 5555 #include <isl/local_space.h>5556 __isl_give isl_local_space *isl_local_space_domain(5557 __isl_take isl_local_space *ls);5558 __isl_give isl_local_space *isl_local_space_range(5559 __isl_take isl_local_space *ls);5560 5561 #include <isl/set.h>5562 __isl_give isl_basic_set *isl_basic_set_project_out(5563 __isl_take isl_basic_set *bset,5564 enum isl_dim_type type, unsigned first, unsigned n);5565 __isl_give isl_set *isl_set_project_out_param_id(5566 __isl_take isl_set *set,5567 __isl_take isl_id *id);5568 __isl_give isl_set *5569 isl_set_project_out_param_id_list(5570 __isl_take isl_set *set,5571 __isl_take isl_id_list *list);5572 __isl_give isl_set *isl_set_project_out(__isl_take isl_set *set,5573 enum isl_dim_type type, unsigned first, unsigned n);5574 __isl_give isl_set *isl_set_project_out_all_params(5575 __isl_take isl_set *set);5576 __isl_give isl_map *isl_set_project_onto_map(5577 __isl_take isl_set *set,5578 enum isl_dim_type type, unsigned first,5579 unsigned n);5580 __isl_give isl_basic_set *isl_basic_set_params(5581 __isl_take isl_basic_set *bset);5582 __isl_give isl_set *isl_set_params(__isl_take isl_set *set);5583 5584The function C<isl_space_domain_wrapped_domain> returns the domain5585of the binary relation wrapped inside the domain of the input.5586The function C<isl_set_project_onto_map> returns a relation5587that projects the input set onto the given set dimensions.5588 5589 #include <isl/map.h>5590 __isl_give isl_basic_map *isl_basic_map_project_out(5591 __isl_take isl_basic_map *bmap,5592 enum isl_dim_type type, unsigned first, unsigned n);5593 __isl_give isl_map *isl_map_project_out_param_id(5594 __isl_take isl_map *map,5595 __isl_take isl_id *id);5596 __isl_give isl_map *isl_map_project_out_param_id_list(5597 __isl_take isl_map *map,5598 __isl_take isl_id_list *list);5599 __isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,5600 enum isl_dim_type type, unsigned first, unsigned n);5601 __isl_give isl_map *isl_map_project_out_all_params(5602 __isl_take isl_map *map);5603 __isl_give isl_basic_set *isl_basic_map_domain(5604 __isl_take isl_basic_map *bmap);5605 __isl_give isl_basic_set *isl_basic_map_range(5606 __isl_take isl_basic_map *bmap);5607 __isl_give isl_set *isl_map_params(__isl_take isl_map *map);5608 __isl_give isl_set *isl_map_domain(5609 __isl_take isl_map *bmap);5610 __isl_give isl_set *isl_map_range(5611 __isl_take isl_map *map);5612 5613 #include <isl/union_set.h>5614 __isl_give isl_union_set *isl_union_set_project_out(5615 __isl_take isl_union_set *uset,5616 enum isl_dim_type type,5617 unsigned first, unsigned n);5618 __isl_give isl_union_set *5619 isl_union_set_project_out_all_params(5620 __isl_take isl_union_set *uset);5621 __isl_give isl_set *isl_union_set_params(5622 __isl_take isl_union_set *uset);5623 5624The function C<isl_union_set_project_out> can only project out5625parameters.5626 5627 #include <isl/union_map.h>5628 __isl_give isl_union_map *5629 isl_union_map_project_out_param_id(5630 __isl_take isl_union_map *umap,5631 __isl_take isl_id *id);5632 __isl_give isl_union_map *5633 isl_union_map_project_out_param_id_list(5634 __isl_take isl_union_map *umap,5635 __isl_take isl_id_list *list);5636 __isl_give isl_union_map *isl_union_map_project_out(5637 __isl_take isl_union_map *umap,5638 enum isl_dim_type type, unsigned first, unsigned n);5639 __isl_give isl_union_map *5640 isl_union_map_project_out_all_params(5641 __isl_take isl_union_map *umap);5642 __isl_give isl_set *isl_union_map_params(5643 __isl_take isl_union_map *umap);5644 __isl_give isl_union_set *isl_union_map_domain(5645 __isl_take isl_union_map *umap);5646 __isl_give isl_union_set *isl_union_map_range(5647 __isl_take isl_union_map *umap);5648 5649The function C<isl_union_map_project_out> can only project out5650parameters.5651 5652 #include <isl/aff.h>5653 __isl_give isl_aff *isl_aff_project_domain_on_params(5654 __isl_take isl_aff *aff);5655 __isl_give isl_multi_aff *5656 isl_multi_aff_project_domain_on_params(5657 __isl_take isl_multi_aff *ma);5658 __isl_give isl_pw_aff *5659 isl_pw_aff_project_domain_on_params(5660 __isl_take isl_pw_aff *pa);5661 __isl_give isl_multi_pw_aff *5662 isl_multi_pw_aff_project_domain_on_params(5663 __isl_take isl_multi_pw_aff *mpa);5664 __isl_give isl_pw_multi_aff *5665 isl_pw_multi_aff_project_domain_on_params(5666 __isl_take isl_pw_multi_aff *pma);5667 __isl_give isl_set *isl_pw_aff_domain(5668 __isl_take isl_pw_aff *pwaff);5669 __isl_give isl_set *isl_pw_multi_aff_domain(5670 __isl_take isl_pw_multi_aff *pma);5671 __isl_give isl_set *isl_multi_pw_aff_domain(5672 __isl_take isl_multi_pw_aff *mpa);5673 __isl_give isl_union_set *isl_union_pw_aff_domain(5674 __isl_take isl_union_pw_aff *upa);5675 __isl_give isl_union_set *isl_union_pw_multi_aff_domain(5676 __isl_take isl_union_pw_multi_aff *upma);5677 __isl_give isl_union_set *5678 isl_multi_union_pw_aff_domain(5679 __isl_take isl_multi_union_pw_aff *mupa);5680 __isl_give isl_set *isl_pw_aff_params(5681 __isl_take isl_pw_aff *pwa);5682 5683If no explicit domain was set on a zero-dimensional input to5684C<isl_multi_union_pw_aff_domain>, then this function will5685return a parameter set.5686 5687 #include <isl/polynomial.h>5688 __isl_give isl_qpolynomial *5689 isl_qpolynomial_project_domain_on_params(5690 __isl_take isl_qpolynomial *qp);5691 __isl_give isl_pw_qpolynomial *5692 isl_pw_qpolynomial_project_domain_on_params(5693 __isl_take isl_pw_qpolynomial *pwqp);5694 __isl_give isl_pw_qpolynomial_fold *5695 isl_pw_qpolynomial_fold_project_domain_on_params(5696 __isl_take isl_pw_qpolynomial_fold *pwf);5697 __isl_give isl_set *isl_pw_qpolynomial_domain(5698 __isl_take isl_pw_qpolynomial *pwqp);5699 __isl_give isl_union_set *isl_union_pw_qpolynomial_fold_domain(5700 __isl_take isl_union_pw_qpolynomial_fold *upwf);5701 __isl_give isl_union_set *isl_union_pw_qpolynomial_domain(5702 __isl_take isl_union_pw_qpolynomial *upwqp);5703 5704 #include <isl/space.h>5705 __isl_give isl_space *isl_space_domain_map(5706 __isl_take isl_space *space);5707 __isl_give isl_space *isl_space_range_map(5708 __isl_take isl_space *space);5709 5710 #include <isl/map.h>5711 __isl_give isl_map *isl_set_wrapped_domain_map(5712 __isl_take isl_set *set);5713 __isl_give isl_basic_map *isl_basic_map_domain_map(5714 __isl_take isl_basic_map *bmap);5715 __isl_give isl_basic_map *isl_basic_map_range_map(5716 __isl_take isl_basic_map *bmap);5717 __isl_give isl_map *isl_map_domain_map(__isl_take isl_map *map);5718 __isl_give isl_map *isl_map_range_map(__isl_take isl_map *map);5719 5720 #include <isl/union_map.h>5721 __isl_give isl_union_map *isl_union_map_domain_map(5722 __isl_take isl_union_map *umap);5723 __isl_give isl_union_pw_multi_aff *5724 isl_union_map_domain_map_union_pw_multi_aff(5725 __isl_take isl_union_map *umap);5726 __isl_give isl_union_map *isl_union_map_range_map(5727 __isl_take isl_union_map *umap);5728 __isl_give isl_union_map *5729 isl_union_set_wrapped_domain_map(5730 __isl_take isl_union_set *uset);5731 5732The functions above construct a (basic, regular or union) relation5733that maps (a wrapped version of) the input relation to its domain or range.5734C<isl_set_wrapped_domain_map> maps the input set to the domain5735of its wrapped relation.5736 5737=item * Elimination5738 5739 __isl_give isl_basic_set *isl_basic_set_eliminate(5740 __isl_take isl_basic_set *bset,5741 enum isl_dim_type type,5742 unsigned first, unsigned n);5743 __isl_give isl_set *isl_set_eliminate(5744 __isl_take isl_set *set, enum isl_dim_type type,5745 unsigned first, unsigned n);5746 __isl_give isl_basic_map *isl_basic_map_eliminate(5747 __isl_take isl_basic_map *bmap,5748 enum isl_dim_type type,5749 unsigned first, unsigned n);5750 __isl_give isl_map *isl_map_eliminate(5751 __isl_take isl_map *map, enum isl_dim_type type,5752 unsigned first, unsigned n);5753 5754Eliminate the coefficients for the given dimensions from the constraints,5755without removing the dimensions.5756 5757=item * Constructing a set from a parameter domain5758 5759A set space of a given dimension and with an optional name5760can be created from a parameter space using the following functions.5761 5762 #include <isl/space.h>5763 __isl_give isl_space *isl_space_add_unnamed_tuple_ui(5764 __isl_take isl_space *space, unsigned dim);5765 __isl_give isl_space *5766 isl_space_add_named_tuple_id_ui(5767 __isl_take isl_space *space,5768 __isl_take isl_id *tuple_id, unsigned dim);5769 5770A set with a given tuple can be created from a parameter domain5771using the following function.5772 5773 #include <isl/set.h>5774 __isl_give isl_set *isl_set_unbind_params(5775 __isl_take isl_set *set,5776 __isl_take isl_multi_id *tuple);5777 5778Any parameters with identifiers in C<tuple> are reinterpreted5779as the corresponding set dimensions.5780 5781A zero-dimensional (local) space or (basic) set can be constructed5782on a given parameter domain using the following functions.5783 5784 #include <isl/space.h>5785 __isl_give isl_space *isl_space_set_from_params(5786 __isl_take isl_space *space);5787 5788 #include <isl/local_space.h>5789 __isl_give isl_local_space *5790 isl_local_space_set_from_params(5791 __isl_take isl_local_space *ls);5792 5793 #include <isl/set.h>5794 __isl_give isl_basic_set *isl_basic_set_from_params(5795 __isl_take isl_basic_set *bset);5796 __isl_give isl_set *isl_set_from_params(5797 __isl_take isl_set *set);5798 5799=item * Constructing a relation from one or two sets5800 5801A map space with a range of a given dimension and with an optional name5802can be created from a domain space using the functions5803C<isl_space_add_unnamed_tuple_ui> and C<isl_space_add_named_tuple_id_ui>5804described above.5805 5806A relation with a given domain tuple can be created from a set5807that will become the range of the relation5808using the following function.5809 5810 #include <isl/set.h>5811 __isl_give isl_map *5812 isl_set_unbind_params_insert_domain(5813 __isl_take isl_set *set,5814 __isl_take isl_multi_id *domain);5815 5816Any parameters with identifiers in C<domain> are reinterpreted5817as the corresponding input dimensions.5818 5819Similarly, a function defined over a parameter domain can5820be converted into one defined over a set domain5821using the following functions.5822 5823 #include <isl/aff.h>5824 __isl_give isl_aff *5825 isl_aff_unbind_params_insert_domain(5826 __isl_take isl_aff *aff,5827 __isl_take isl_multi_id *domain);5828 __isl_give isl_multi_aff *5829 isl_multi_aff_unbind_params_insert_domain(5830 __isl_take isl_multi_aff *ma,5831 __isl_take isl_multi_id *domain);5832 __isl_give isl_multi_pw_aff *5833 isl_multi_pw_aff_unbind_params_insert_domain(5834 __isl_take isl_multi_pw_aff *mpa,5835 __isl_take isl_multi_id *domain);5836 5837Again,5838any parameters with identifiers in C<domain> are reinterpreted5839as the corresponding input dimensions.5840 5841Create a relation with the given set(s) as domain and/or range.5842If only the domain or the range is specified, then5843the range or domain of the created relation is a zero-dimensional5844flat anonymous space.5845If the case of C<isl_space_map_from_set>, the input space5846specifies both the domain and the range of the result.5847 5848 #include <isl/space.h>5849 __isl_give isl_space *isl_space_from_domain(5850 __isl_take isl_space *space);5851 __isl_give isl_space *isl_space_from_range(5852 __isl_take isl_space *space);5853 __isl_give isl_space *isl_space_map_from_set(5854 __isl_take isl_space *space);5855 __isl_give isl_space *isl_space_map_from_domain_and_range(5856 __isl_take isl_space *domain,5857 __isl_take isl_space *range);5858 5859 #include <isl/local_space.h>5860 __isl_give isl_local_space *isl_local_space_from_domain(5861 __isl_take isl_local_space *ls);5862 5863 #include <isl/map.h>5864 __isl_give isl_map *isl_set_insert_domain(5865 __isl_take isl_set *set,5866 __isl_take isl_space *domain);5867 __isl_give isl_map *isl_map_from_domain(5868 __isl_take isl_set *set);5869 __isl_give isl_map *isl_map_from_range(5870 __isl_take isl_set *set);5871 5872 #include <isl/union_map.h>5873 __isl_give isl_union_map *isl_union_map_from_domain(5874 __isl_take isl_union_set *uset);5875 __isl_give isl_union_map *isl_union_map_from_range(5876 __isl_take isl_union_set *uset);5877 __isl_give isl_union_map *5878 isl_union_map_from_domain_and_range(5879 __isl_take isl_union_set *domain,5880 __isl_take isl_union_set *range);5881 5882 #include <isl/id.h>5883 __isl_give isl_multi_id *isl_multi_id_from_range(5884 __isl_take isl_multi_id *mi);5885 5886 #include <isl/val.h>5887 __isl_give isl_multi_val *isl_multi_val_from_range(5888 __isl_take isl_multi_val *mv);5889 5890 #include <isl/aff.h>5891 __isl_give isl_multi_aff *5892 isl_multi_aff_insert_domain(5893 __isl_take isl_multi_aff *ma,5894 __isl_take isl_space *domain);5895 __isl_give isl_pw_aff *isl_pw_aff_insert_domain(5896 __isl_take isl_pw_aff *pa,5897 __isl_take isl_space *domain);5898 __isl_give isl_pw_multi_aff *5899 isl_pw_multi_aff_insert_domain(5900 __isl_take isl_pw_multi_aff *pma,5901 __isl_take isl_space *domain);5902 __isl_give isl_multi_pw_aff *5903 isl_multi_pw_aff_insert_domain(5904 __isl_take isl_multi_pw_aff *mpa,5905 __isl_take isl_space *domain);5906 __isl_give isl_aff *isl_aff_from_range(5907 __isl_take isl_aff *aff);5908 __isl_give isl_multi_aff *isl_multi_aff_from_range(5909 __isl_take isl_multi_aff *ma);5910 __isl_give isl_pw_aff *isl_pw_aff_from_range(5911 __isl_take isl_pw_aff *pwa);5912 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_range(5913 __isl_take isl_multi_pw_aff *mpa);5914 __isl_give isl_multi_union_pw_aff *5915 isl_multi_union_pw_aff_from_range(5916 __isl_take isl_multi_union_pw_aff *mupa);5917 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_domain(5918 __isl_take isl_set *set);5919 __isl_give isl_union_pw_multi_aff *5920 isl_union_pw_multi_aff_from_domain(5921 __isl_take isl_union_set *uset);5922 5923 #include <isl/polynomial.h>5924 __isl_give isl_pw_qpolynomial *5925 isl_pw_qpolynomial_from_range(5926 __isl_take isl_pw_qpolynomial *pwqp);5927 __isl_give isl_pw_qpolynomial_fold *5928 isl_pw_qpolynomial_fold_from_range(5929 __isl_take isl_pw_qpolynomial_fold *pwf);5930 5931=item * Slicing5932 5933 #include <isl/set.h>5934 __isl_give isl_basic_set *isl_basic_set_fix_si(5935 __isl_take isl_basic_set *bset,5936 enum isl_dim_type type, unsigned pos, int value);5937 __isl_give isl_basic_set *isl_basic_set_fix_val(5938 __isl_take isl_basic_set *bset,5939 enum isl_dim_type type, unsigned pos,5940 __isl_take isl_val *v);5941 __isl_give isl_set *isl_set_fix_si(__isl_take isl_set *set,5942 enum isl_dim_type type, unsigned pos, int value);5943 __isl_give isl_set *isl_set_fix_val(5944 __isl_take isl_set *set,5945 enum isl_dim_type type, unsigned pos,5946 __isl_take isl_val *v);5947 5948 #include <isl/map.h>5949 __isl_give isl_basic_map *isl_basic_map_fix_si(5950 __isl_take isl_basic_map *bmap,5951 enum isl_dim_type type, unsigned pos, int value);5952 __isl_give isl_basic_map *isl_basic_map_fix_val(5953 __isl_take isl_basic_map *bmap,5954 enum isl_dim_type type, unsigned pos,5955 __isl_take isl_val *v);5956 __isl_give isl_map *isl_map_fix_si(__isl_take isl_map *map,5957 enum isl_dim_type type, unsigned pos, int value);5958 __isl_give isl_map *isl_map_fix_val(5959 __isl_take isl_map *map,5960 enum isl_dim_type type, unsigned pos,5961 __isl_take isl_val *v);5962 5963 #include <isl/aff.h>5964 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_fix_si(5965 __isl_take isl_pw_multi_aff *pma,5966 enum isl_dim_type type, unsigned pos, int value);5967 5968 #include <isl/polynomial.h>5969 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_fix_val(5970 __isl_take isl_pw_qpolynomial *pwqp,5971 enum isl_dim_type type, unsigned n,5972 __isl_take isl_val *v);5973 __isl_give isl_pw_qpolynomial_fold *5974 isl_pw_qpolynomial_fold_fix_val(5975 __isl_take isl_pw_qpolynomial_fold *pwf,5976 enum isl_dim_type type, unsigned n,5977 __isl_take isl_val *v);5978 5979Intersect the set, relation or function domain5980with the hyperplane where the given5981dimension has the fixed given value.5982 5983 #include <isl/set.h>5984 __isl_give isl_basic_set *5985 isl_basic_set_lower_bound_val(5986 __isl_take isl_basic_set *bset,5987 enum isl_dim_type type, unsigned pos,5988 __isl_take isl_val *value);5989 __isl_give isl_basic_set *5990 isl_basic_set_upper_bound_val(5991 __isl_take isl_basic_set *bset,5992 enum isl_dim_type type, unsigned pos,5993 __isl_take isl_val *value);5994 __isl_give isl_set *isl_set_lower_bound_si(5995 __isl_take isl_set *set,5996 enum isl_dim_type type, unsigned pos, int value);5997 __isl_give isl_set *isl_set_lower_bound_val(5998 __isl_take isl_set *set,5999 enum isl_dim_type type, unsigned pos,6000 __isl_take isl_val *value);6001 __isl_give isl_set *isl_set_upper_bound_si(6002 __isl_take isl_set *set,6003 enum isl_dim_type type, unsigned pos, int value);6004 __isl_give isl_set *isl_set_upper_bound_val(6005 __isl_take isl_set *set,6006 enum isl_dim_type type, unsigned pos,6007 __isl_take isl_val *value);6008 __isl_give isl_set *isl_set_lower_bound_multi_val(6009 __isl_take isl_set *set,6010 __isl_take isl_multi_val *lower);6011 __isl_give isl_set *isl_set_upper_bound_multi_val(6012 __isl_take isl_set *set,6013 __isl_take isl_multi_val *upper);6014 __isl_give isl_set *isl_set_lower_bound_multi_pw_aff(6015 __isl_take isl_set *set,6016 __isl_take isl_multi_pw_aff *lower);6017 __isl_give isl_set *isl_set_upper_bound_multi_pw_aff(6018 __isl_take isl_set *set,6019 __isl_take isl_multi_pw_aff *upper);6020 6021 #include <isl/map.h>6022 __isl_give isl_basic_map *isl_basic_map_lower_bound_si(6023 __isl_take isl_basic_map *bmap,6024 enum isl_dim_type type, unsigned pos, int value);6025 __isl_give isl_basic_map *isl_basic_map_upper_bound_si(6026 __isl_take isl_basic_map *bmap,6027 enum isl_dim_type type, unsigned pos, int value);6028 __isl_give isl_map *isl_map_lower_bound_si(6029 __isl_take isl_map *map,6030 enum isl_dim_type type, unsigned pos, int value);6031 __isl_give isl_map *isl_map_upper_bound_si(6032 __isl_take isl_map *map,6033 enum isl_dim_type type, unsigned pos, int value);6034 __isl_give isl_map *isl_map_lower_bound_val(6035 __isl_take isl_map *map,6036 enum isl_dim_type type, unsigned pos,6037 __isl_take isl_val *value);6038 __isl_give isl_map *isl_map_upper_bound_val(6039 __isl_take isl_map *map,6040 enum isl_dim_type type, unsigned pos,6041 __isl_take isl_val *value);6042 __isl_give isl_map *isl_map_lower_bound_multi_pw_aff(6043 __isl_take isl_map *map,6044 __isl_take isl_multi_pw_aff *lower);6045 __isl_give isl_map *isl_map_upper_bound_multi_pw_aff(6046 __isl_take isl_map *map,6047 __isl_take isl_multi_pw_aff *upper);6048 6049Intersect the set or relation with the half-space where the given6050dimension has a value bounded by the given fixed integer value or6051symbolic constant expression.6052For functions taking a multi expression,6053this applies to all set dimensions.6054Those that bound a map, bound the range of that map.6055If the multi expression is zero-dimensional but has an explicit domain,6056then the (parameter) domain of the set or map is intersected6057with this explicit domain.6058 6059 __isl_give isl_set *isl_set_equate(__isl_take isl_set *set,6060 enum isl_dim_type type1, int pos1,6061 enum isl_dim_type type2, int pos2);6062 __isl_give isl_basic_map *isl_basic_map_equate(6063 __isl_take isl_basic_map *bmap,6064 enum isl_dim_type type1, int pos1,6065 enum isl_dim_type type2, int pos2);6066 __isl_give isl_map *isl_map_equate(__isl_take isl_map *map,6067 enum isl_dim_type type1, int pos1,6068 enum isl_dim_type type2, int pos2);6069 6070Intersect the set or relation with the hyperplane where the given6071dimensions are equal to each other.6072 6073 __isl_give isl_map *isl_map_oppose(__isl_take isl_map *map,6074 enum isl_dim_type type1, int pos1,6075 enum isl_dim_type type2, int pos2);6076 6077Intersect the relation with the hyperplane where the given6078dimensions have opposite values.6079 6080 __isl_give isl_map *isl_map_order_le(6081 __isl_take isl_map *map,6082 enum isl_dim_type type1, int pos1,6083 enum isl_dim_type type2, int pos2);6084 __isl_give isl_basic_map *isl_basic_map_order_ge(6085 __isl_take isl_basic_map *bmap,6086 enum isl_dim_type type1, int pos1,6087 enum isl_dim_type type2, int pos2);6088 __isl_give isl_map *isl_map_order_ge(6089 __isl_take isl_map *map,6090 enum isl_dim_type type1, int pos1,6091 enum isl_dim_type type2, int pos2);6092 __isl_give isl_map *isl_map_order_lt(__isl_take isl_map *map,6093 enum isl_dim_type type1, int pos1,6094 enum isl_dim_type type2, int pos2);6095 __isl_give isl_basic_map *isl_basic_map_order_gt(6096 __isl_take isl_basic_map *bmap,6097 enum isl_dim_type type1, int pos1,6098 enum isl_dim_type type2, int pos2);6099 __isl_give isl_map *isl_map_order_gt(__isl_take isl_map *map,6100 enum isl_dim_type type1, int pos1,6101 enum isl_dim_type type2, int pos2);6102 6103Intersect the relation with the half-space where the given6104dimensions satisfy the given ordering.6105 6106 #include <isl/union_set.h>6107 __isl_give isl_union_map *isl_union_map_remove_map_if(6108 __isl_take isl_union_map *umap,6109 isl_bool (*fn)(__isl_keep isl_map *map,6110 void *user), void *user);6111 6112This function calls the callback function once for each6113pair of spaces for which there are elements in the input.6114If the callback returns C<isl_bool_true>, then all those elements6115are removed from the result. The only remaining elements in the output6116are then those for which the callback returns C<isl_bool_false>.6117 6118=item * Locus6119 6120 #include <isl/aff.h>6121 __isl_give isl_basic_set *isl_aff_zero_basic_set(6122 __isl_take isl_aff *aff);6123 __isl_give isl_basic_set *isl_aff_neg_basic_set(6124 __isl_take isl_aff *aff);6125 __isl_give isl_set *isl_pw_aff_pos_set(6126 __isl_take isl_pw_aff *pa);6127 __isl_give isl_set *isl_pw_aff_nonneg_set(6128 __isl_take isl_pw_aff *pwaff);6129 __isl_give isl_set *isl_pw_aff_zero_set(6130 __isl_take isl_pw_aff *pwaff);6131 __isl_give isl_set *isl_pw_aff_non_zero_set(6132 __isl_take isl_pw_aff *pwaff);6133 __isl_give isl_union_set *6134 isl_union_pw_aff_zero_union_set(6135 __isl_take isl_union_pw_aff *upa);6136 __isl_give isl_union_set *6137 isl_multi_union_pw_aff_zero_union_set(6138 __isl_take isl_multi_union_pw_aff *mupa);6139 6140The function C<isl_aff_neg_basic_set> returns a basic set6141containing those elements in the domain space6142of C<aff> where C<aff> is negative.6143The function C<isl_pw_aff_nonneg_set> returns a set6144containing those elements in the domain6145of C<pwaff> where C<pwaff> is non-negative.6146The function C<isl_multi_union_pw_aff_zero_union_set>6147returns a union set containing those elements6148in the domains of its elements where they are all zero.6149 6150=item * Identity6151 6152 __isl_give isl_map *isl_set_identity(6153 __isl_take isl_set *set);6154 __isl_give isl_union_map *isl_union_set_identity(6155 __isl_take isl_union_set *uset);6156 __isl_give isl_union_pw_multi_aff *6157 isl_union_set_identity_union_pw_multi_aff(6158 __isl_take isl_union_set *uset);6159 6160Construct an identity relation on the given (union) set.6161 6162=item * Function Extraction6163 6164A piecewise quasi affine expression that is equal to 1 on a set6165and 0 outside the set can be created using the following function.6166 6167 #include <isl/aff.h>6168 __isl_give isl_pw_aff *isl_set_indicator_function(6169 __isl_take isl_set *set);6170 6171A piecewise multiple quasi affine expression can be extracted6172from an C<isl_set> or C<isl_map>, provided the C<isl_set> is a singleton6173and the C<isl_map> is single-valued.6174In case of a conversion from an C<isl_union_map>6175to an C<isl_union_pw_multi_aff>, these properties need to hold6176in each domain space.6177A conversion to a C<isl_multi_union_pw_aff> additionally6178requires that the input is non-empty and involves only a single6179range space.6180 6181 #include <isl/aff.h>6182 __isl_give isl_pw_multi_aff *isl_set_as_pw_multi_aff(6183 __isl_take isl_set *set);6184 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_set(6185 __isl_take isl_set *set);6186 __isl_give isl_pw_multi_aff *isl_map_as_pw_multi_aff(6187 __isl_take isl_map *map);6188 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_map(6189 __isl_take isl_map *map);6190 6191 __isl_give isl_union_pw_multi_aff *6192 isl_union_pw_multi_aff_from_union_set(6193 __isl_take isl_union_set *uset);6194 __isl_give isl_union_pw_multi_aff *6195 isl_union_map_as_union_pw_multi_aff(6196 __isl_take isl_union_map *umap);6197 __isl_give isl_union_pw_multi_aff *6198 isl_union_pw_multi_aff_from_union_map(6199 __isl_take isl_union_map *umap);6200 6201 __isl_give isl_multi_union_pw_aff *6202 isl_union_map_as_multi_union_pw_aff(6203 __isl_take isl_union_map *umap);6204 __isl_give isl_multi_union_pw_aff *6205 isl_multi_union_pw_aff_from_union_map(6206 __isl_take isl_union_map *umap);6207 6208C<isl_map_as_pw_multi_aff> and C<isl_pw_multi_aff_from_map> perform6209the same operation.6210Similarly for C<isl_set_as_pw_multi_aff> and6211C<isl_pw_multi_aff_from_set>,6212for C<isl_union_map_as_union_pw_multi_aff> and6213C<isl_union_pw_multi_aff_from_union_map> and6214for C<isl_union_map_as_multi_union_pw_aff> and6215C<isl_multi_union_pw_aff_from_union_map>.6216 6217=item * Deltas6218 6219 __isl_give isl_basic_set *isl_basic_map_deltas(6220 __isl_take isl_basic_map *bmap);6221 __isl_give isl_set *isl_map_deltas(__isl_take isl_map *map);6222 __isl_give isl_union_set *isl_union_map_deltas(6223 __isl_take isl_union_map *umap);6224 6225These functions return a (basic) set containing the differences6226between image elements and corresponding domain elements in the input.6227 6228 __isl_give isl_basic_map *isl_basic_map_deltas_map(6229 __isl_take isl_basic_map *bmap);6230 __isl_give isl_map *isl_map_deltas_map(6231 __isl_take isl_map *map);6232 __isl_give isl_union_map *isl_union_map_deltas_map(6233 __isl_take isl_union_map *umap);6234 6235The functions above construct a (basic, regular or union) relation6236that maps (a wrapped version of) the input relation to its delta set.6237 6238=item * Translation6239 6240 #include <isl/map.h>6241 __isl_give isl_map *isl_set_translation(6242 __isl_take isl_set *deltas);6243 6244This function performs essentially the opposite operation6245of C<isl_map_deltas>. In particular, it returns pairs6246of elements in the same space that have a difference in C<deltas>.6247 6248=item * Coalescing6249 6250Simplify the representation of a set, relation or functions by trying6251to combine pairs of basic sets or relations into a single6252basic set or relation.6253 6254 #include <isl/set.h>6255 __isl_give isl_set *isl_set_coalesce(__isl_take isl_set *set);6256 6257 #include <isl/map.h>6258 __isl_give isl_map *isl_map_coalesce(__isl_take isl_map *map);6259 6260 #include <isl/union_set.h>6261 __isl_give isl_union_set *isl_union_set_coalesce(6262 __isl_take isl_union_set *uset);6263 6264 #include <isl/union_map.h>6265 __isl_give isl_union_map *isl_union_map_coalesce(6266 __isl_take isl_union_map *umap);6267 6268 #include <isl/aff.h>6269 __isl_give isl_pw_aff *isl_pw_aff_coalesce(6270 __isl_take isl_pw_aff *pa);6271 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_coalesce(6272 __isl_take isl_pw_multi_aff *pma);6273 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_coalesce(6274 __isl_take isl_multi_pw_aff *mpa);6275 __isl_give isl_union_pw_aff *isl_union_pw_aff_coalesce(6276 __isl_take isl_union_pw_aff *upa);6277 __isl_give isl_union_pw_multi_aff *6278 isl_union_pw_multi_aff_coalesce(6279 __isl_take isl_union_pw_multi_aff *upma);6280 __isl_give isl_multi_union_pw_aff *6281 isl_multi_union_pw_aff_coalesce(6282 __isl_take isl_multi_union_pw_aff *mupa);6283 6284 #include <isl/polynomial.h>6285 __isl_give isl_pw_qpolynomial_fold *6286 isl_pw_qpolynomial_fold_coalesce(6287 __isl_take isl_pw_qpolynomial_fold *pwf);6288 __isl_give isl_union_pw_qpolynomial *6289 isl_union_pw_qpolynomial_coalesce(6290 __isl_take isl_union_pw_qpolynomial *upwqp);6291 __isl_give isl_union_pw_qpolynomial_fold *6292 isl_union_pw_qpolynomial_fold_coalesce(6293 __isl_take isl_union_pw_qpolynomial_fold *upwf);6294 6295One of the methods for combining pairs of basic sets or relations6296can result in coefficients that are much larger than those that appear6297in the constraints of the input. By default, the coefficients are6298not allowed to grow larger, but this can be changed by unsetting6299the following option.6300 6301 isl_stat isl_options_set_coalesce_bounded_wrapping(6302 isl_ctx *ctx, int val);6303 int isl_options_get_coalesce_bounded_wrapping(6304 isl_ctx *ctx);6305 6306One of the other methods tries to combine pairs of basic sets6307with different local variables, treating them as existentially6308quantified variables even if they have known (but different)6309integer division expressions. The result may then also have6310existentially quantified variables. Turning on the following6311option prevents this from happening.6312 6313 isl_stat isl_options_set_coalesce_preserve_locals(6314 isl_ctx *ctx, int val);6315 int isl_options_get_coalesce_preserve_locals(isl_ctx *ctx);6316 6317=item * Detecting equalities6318 6319 __isl_give isl_basic_set *isl_basic_set_detect_equalities(6320 __isl_take isl_basic_set *bset);6321 __isl_give isl_basic_map *isl_basic_map_detect_equalities(6322 __isl_take isl_basic_map *bmap);6323 __isl_give isl_set *isl_set_detect_equalities(6324 __isl_take isl_set *set);6325 __isl_give isl_map *isl_map_detect_equalities(6326 __isl_take isl_map *map);6327 __isl_give isl_union_set *isl_union_set_detect_equalities(6328 __isl_take isl_union_set *uset);6329 __isl_give isl_union_map *isl_union_map_detect_equalities(6330 __isl_take isl_union_map *umap);6331 6332Simplify the representation of a set or relation by detecting implicit6333equalities.6334 6335=item * Removing redundant constraints6336 6337 #include <isl/set.h>6338 __isl_give isl_basic_set *isl_basic_set_remove_redundancies(6339 __isl_take isl_basic_set *bset);6340 __isl_give isl_set *isl_set_remove_redundancies(6341 __isl_take isl_set *set);6342 6343 #include <isl/union_set.h>6344 __isl_give isl_union_set *6345 isl_union_set_remove_redundancies(6346 __isl_take isl_union_set *uset);6347 6348 #include <isl/map.h>6349 __isl_give isl_basic_map *isl_basic_map_remove_redundancies(6350 __isl_take isl_basic_map *bmap);6351 __isl_give isl_map *isl_map_remove_redundancies(6352 __isl_take isl_map *map);6353 6354 #include <isl/union_map.h>6355 __isl_give isl_union_map *6356 isl_union_map_remove_redundancies(6357 __isl_take isl_union_map *umap);6358 6359=item * Convex hull6360 6361 __isl_give isl_basic_set *isl_set_convex_hull(6362 __isl_take isl_set *set);6363 __isl_give isl_basic_map *isl_map_convex_hull(6364 __isl_take isl_map *map);6365 6366If the input set or relation has any existentially quantified6367variables, then the result of these operations is currently undefined.6368 6369=item * Simple hull6370 6371 #include <isl/set.h>6372 __isl_give isl_basic_set *6373 isl_set_unshifted_simple_hull(6374 __isl_take isl_set *set);6375 __isl_give isl_basic_set *isl_set_simple_hull(6376 __isl_take isl_set *set);6377 __isl_give isl_basic_set *6378 isl_set_plain_unshifted_simple_hull(6379 __isl_take isl_set *set);6380 __isl_give isl_basic_set *6381 isl_set_unshifted_simple_hull_from_set_list(6382 __isl_take isl_set *set,6383 __isl_take isl_set_list *list);6384 6385 #include <isl/map.h>6386 __isl_give isl_basic_map *6387 isl_map_unshifted_simple_hull(6388 __isl_take isl_map *map);6389 __isl_give isl_basic_map *isl_map_simple_hull(6390 __isl_take isl_map *map);6391 __isl_give isl_basic_map *6392 isl_map_plain_unshifted_simple_hull(6393 __isl_take isl_map *map);6394 __isl_give isl_basic_map *6395 isl_map_unshifted_simple_hull_from_map_list(6396 __isl_take isl_map *map,6397 __isl_take isl_map_list *list);6398 6399 #include <isl/union_map.h>6400 __isl_give isl_union_map *isl_union_map_simple_hull(6401 __isl_take isl_union_map *umap);6402 6403These functions compute a single basic set or relation6404that contains the whole input set or relation.6405In particular, the output is described by translates6406of the constraints describing the basic sets or relations in the input.6407In case of C<isl_set_unshifted_simple_hull>, only the original6408constraints are used, without any translation.6409In case of C<isl_set_plain_unshifted_simple_hull> and6410C<isl_map_plain_unshifted_simple_hull>, the result is described6411by original constraints that are obviously satisfied6412by the entire input set or relation.6413In case of C<isl_set_unshifted_simple_hull_from_set_list> and6414C<isl_map_unshifted_simple_hull_from_map_list>, the6415constraints are taken from the elements of the second argument.6416 6417=begin latex6418 6419(See \autoref{s:simple hull}.)6420 6421=end latex6422 6423=item * Affine hull6424 6425 __isl_give isl_basic_set *isl_basic_set_affine_hull(6426 __isl_take isl_basic_set *bset);6427 __isl_give isl_basic_set *isl_set_affine_hull(6428 __isl_take isl_set *set);6429 __isl_give isl_union_set *isl_union_set_affine_hull(6430 __isl_take isl_union_set *uset);6431 __isl_give isl_basic_map *isl_basic_map_affine_hull(6432 __isl_take isl_basic_map *bmap);6433 __isl_give isl_basic_map *isl_map_affine_hull(6434 __isl_take isl_map *map);6435 __isl_give isl_union_map *isl_union_map_affine_hull(6436 __isl_take isl_union_map *umap);6437 6438In case of union sets and relations, the affine hull is computed6439per space.6440 6441=item * Polyhedral hull6442 6443 __isl_give isl_basic_set *isl_set_polyhedral_hull(6444 __isl_take isl_set *set);6445 __isl_give isl_basic_map *isl_map_polyhedral_hull(6446 __isl_take isl_map *map);6447 __isl_give isl_union_set *isl_union_set_polyhedral_hull(6448 __isl_take isl_union_set *uset);6449 __isl_give isl_union_map *isl_union_map_polyhedral_hull(6450 __isl_take isl_union_map *umap);6451 6452These functions compute a single basic set or relation6453not involving any existentially quantified variables6454that contains the whole input set or relation.6455In case of union sets and relations, the polyhedral hull is computed6456per space.6457 6458=item * Box hull6459 6460 #include <isl/set.h>6461 __isl_give isl_fixed_box *6462 isl_set_get_simple_fixed_box_hull(6463 __isl_keep isl_set *set)6464 6465 #include <isl/map.h>6466 __isl_give isl_fixed_box *6467 isl_map_get_range_simple_fixed_box_hull(6468 __isl_keep isl_map *map);6469 6470These functions try to approximate the set or6471the range of the map by a box of fixed size.6472The box is described in terms of an offset living in the same space as6473the input and a size living in the set or range space. For any element6474in the input map, the range value is greater than or equal to6475the offset applied to the domain value and the difference with6476this offset is strictly smaller than the size.6477The same holds for the elements of the input set, where6478the offset is a parametric constant value.6479If no fixed-size approximation can be found,6480an I<invalid> box is returned, i.e., one for which6481C<isl_fixed_box_is_valid> below returns false.6482 6483The validity, the offset and the size of the box can be obtained using6484the following functions.6485 6486 #include <isl/fixed_box.h>6487 isl_bool isl_fixed_box_is_valid(6488 __isl_keep isl_fixed_box *box);6489 __isl_give isl_multi_aff *isl_fixed_box_get_offset(6490 __isl_keep isl_fixed_box *box);6491 __isl_give isl_multi_val *isl_fixed_box_get_size(6492 __isl_keep isl_fixed_box *box);6493 6494The box can be copied and freed using the following functions.6495 6496 #include <isl/fixed_box.h>6497 __isl_give isl_fixed_box *isl_fixed_box_copy(6498 __isl_keep isl_fixed_box *box);6499 __isl_null isl_fixed_box *isl_fixed_box_free(6500 __isl_take isl_fixed_box *box);6501 6502A representation of the information contained in an object6503of type C<isl_fixed_box> can be obtained using6504 6505 #include <isl/fixed_box.h>6506 __isl_give isl_printer *isl_printer_print_fixed_box(6507 __isl_take isl_printer *p,6508 __isl_keep isl_fixed_box *box);6509 __isl_give char *isl_fixed_box_to_str(6510 __isl_keep isl_fixed_box *box);6511 6512C<isl_fixed_box_to_str> prints the information in flow format.6513 6514=item * Other approximations6515 6516 #include <isl/set.h>6517 __isl_give isl_basic_set *6518 isl_basic_set_drop_constraints_involving_dims(6519 __isl_take isl_basic_set *bset,6520 enum isl_dim_type type,6521 unsigned first, unsigned n);6522 __isl_give isl_basic_set *6523 isl_basic_set_drop_constraints_not_involving_dims(6524 __isl_take isl_basic_set *bset,6525 enum isl_dim_type type,6526 unsigned first, unsigned n);6527 __isl_give isl_set *6528 isl_set_drop_constraints_involving_dims(6529 __isl_take isl_set *set,6530 enum isl_dim_type type,6531 unsigned first, unsigned n);6532 __isl_give isl_set *6533 isl_set_drop_constraints_not_involving_dims(6534 __isl_take isl_set *set,6535 enum isl_dim_type type,6536 unsigned first, unsigned n);6537 6538 #include <isl/map.h>6539 __isl_give isl_basic_map *6540 isl_basic_map_drop_constraints_involving_dims(6541 __isl_take isl_basic_map *bmap,6542 enum isl_dim_type type,6543 unsigned first, unsigned n);6544 __isl_give isl_basic_map *6545 isl_basic_map_drop_constraints_not_involving_dims(6546 __isl_take isl_basic_map *bmap,6547 enum isl_dim_type type,6548 unsigned first, unsigned n);6549 __isl_give isl_map *6550 isl_map_drop_constraints_involving_dims(6551 __isl_take isl_map *map,6552 enum isl_dim_type type,6553 unsigned first, unsigned n);6554 __isl_give isl_map *6555 isl_map_drop_constraints_not_involving_dims(6556 __isl_take isl_map *map,6557 enum isl_dim_type type,6558 unsigned first, unsigned n);6559 6560These functions drop any constraints (not) involving the specified dimensions.6561Note that the result depends on the representation of the input.6562 6563 #include <isl/polynomial.h>6564 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_to_polynomial(6565 __isl_take isl_pw_qpolynomial *pwqp, int sign);6566 __isl_give isl_union_pw_qpolynomial *6567 isl_union_pw_qpolynomial_to_polynomial(6568 __isl_take isl_union_pw_qpolynomial *upwqp, int sign);6569 6570Approximate each quasipolynomial by a polynomial. If C<sign> is positive,6571the polynomial will be an overapproximation. If C<sign> is negative,6572it will be an underapproximation. If C<sign> is zero, the approximation6573will lie somewhere in between.6574 6575=item * Feasibility6576 6577 __isl_give isl_basic_set *isl_basic_set_sample(6578 __isl_take isl_basic_set *bset);6579 __isl_give isl_basic_set *isl_set_sample(6580 __isl_take isl_set *set);6581 __isl_give isl_basic_map *isl_basic_map_sample(6582 __isl_take isl_basic_map *bmap);6583 __isl_give isl_basic_map *isl_map_sample(6584 __isl_take isl_map *map);6585 6586If the input (basic) set or relation is non-empty, then return6587a singleton subset of the input. Otherwise, return an empty set.6588 6589=item * Optimization6590 6591 #include <isl/ilp.h>6592 __isl_give isl_val *isl_basic_set_max_val(6593 __isl_keep isl_basic_set *bset,6594 __isl_keep isl_aff *obj);6595 __isl_give isl_val *isl_set_min_val(6596 __isl_keep isl_set *set,6597 __isl_keep isl_aff *obj);6598 __isl_give isl_val *isl_set_max_val(6599 __isl_keep isl_set *set,6600 __isl_keep isl_aff *obj);6601 __isl_give isl_multi_val *6602 isl_union_set_min_multi_union_pw_aff(6603 __isl_keep isl_union_set *uset,6604 __isl_keep isl_multi_union_pw_aff *obj);6605 6606Compute the minimum or maximum of the integer affine expression C<obj>6607over the points in C<set>.6608The result is C<NULL> in case of an error, the optimal value in case6609there is one, negative infinity or infinity if the problem is unbounded and6610NaN if the problem is empty.6611 6612 #include <isl/ilp.h>6613 __isl_give isl_val *isl_pw_aff_min_val(6614 __isl_take isl_pw_aff *pa);6615 __isl_give isl_val *isl_pw_aff_max_val(6616 __isl_take isl_pw_aff *pa);6617 __isl_give isl_multi_val *6618 isl_pw_multi_aff_min_multi_val(6619 __isl_take isl_pw_multi_aff *pma);6620 __isl_give isl_multi_val *6621 isl_pw_multi_aff_max_multi_val(6622 __isl_take isl_pw_multi_aff *pma);6623 __isl_give isl_multi_val *6624 isl_multi_pw_aff_min_multi_val(6625 __isl_take isl_multi_pw_aff *mpa);6626 __isl_give isl_multi_val *6627 isl_multi_pw_aff_max_multi_val(6628 __isl_take isl_multi_pw_aff *mpa);6629 __isl_give isl_val *isl_union_pw_aff_min_val(6630 __isl_take isl_union_pw_aff *upa);6631 __isl_give isl_val *isl_union_pw_aff_max_val(6632 __isl_take isl_union_pw_aff *upa);6633 __isl_give isl_multi_val *6634 isl_multi_union_pw_aff_min_multi_val(6635 __isl_take isl_multi_union_pw_aff *mupa);6636 __isl_give isl_multi_val *6637 isl_multi_union_pw_aff_max_multi_val(6638 __isl_take isl_multi_union_pw_aff *mupa);6639 6640Compute the minimum or maximum of the integer affine expression6641over its definition domain.6642The result is C<NULL> in case of an error, the optimal value in case6643there is one, negative infinity or infinity if the problem is unbounded and6644NaN if the problem is empty.6645 6646 #include <isl/ilp.h>6647 __isl_give isl_val *isl_basic_set_dim_max_val(6648 __isl_take isl_basic_set *bset, int pos);6649 __isl_give isl_val *isl_set_dim_min_val(6650 __isl_take isl_set *set, int pos);6651 __isl_give isl_val *isl_set_dim_max_val(6652 __isl_take isl_set *set, int pos);6653 6654Return the minimal or maximal value attained by the given set dimension,6655independently of the parameter values and of any other dimensions.6656The result is C<NULL> in case of an error, the optimal value in case6657there is one, (negative) infinity if the problem is unbounded and6658NaN if the input is empty.6659 6660=item * Parametric optimization6661 6662 __isl_give isl_pw_aff *isl_set_dim_min(6663 __isl_take isl_set *set, int pos);6664 __isl_give isl_pw_aff *isl_set_dim_max(6665 __isl_take isl_set *set, int pos);6666 __isl_give isl_pw_aff *isl_map_dim_min(6667 __isl_take isl_map *map, int pos);6668 __isl_give isl_pw_aff *isl_map_dim_max(6669 __isl_take isl_map *map, int pos);6670 __isl_give isl_multi_pw_aff *6671 isl_set_min_multi_pw_aff(6672 __isl_take isl_set *set);6673 __isl_give isl_multi_pw_aff *6674 isl_set_max_multi_pw_aff(6675 __isl_take isl_set *set);6676 __isl_give isl_multi_pw_aff *6677 isl_map_min_multi_pw_aff(6678 __isl_take isl_map *map);6679 __isl_give isl_multi_pw_aff *6680 isl_map_max_multi_pw_aff(6681 __isl_take isl_map *map);6682 6683Compute the minimum or maximum of the (given) set or output dimension(s)6684as a function of the parameters (and input dimensions), but independently6685of the other set or output dimensions.6686For lexicographic optimization, see L<"Lexicographic Optimization">.6687 6688=item * Dual6689 6690The following functions compute either the set of (rational) coefficient6691values of valid constraints for the given set or the set of (rational)6692values satisfying the constraints with coefficients from the given set.6693Internally, these two sets of functions perform essentially the6694same operations, except that the set of coefficients is assumed to6695be a cone, while the set of values may be any polyhedron.6696The current implementation is based on the Farkas lemma and6697Fourier-Motzkin elimination, but this may change or be made optional6698in future. In particular, future implementations may use different6699dualization algorithms or skip the elimination step.6700 6701 #include <isl/set.h>6702 __isl_give isl_basic_set *isl_basic_set_coefficients(6703 __isl_take isl_basic_set *bset);6704 __isl_give isl_basic_set_list *6705 isl_basic_set_list_coefficients(6706 __isl_take isl_basic_set_list *list);6707 __isl_give isl_basic_set *isl_set_coefficients(6708 __isl_take isl_set *set);6709 __isl_give isl_union_set *isl_union_set_coefficients(6710 __isl_take isl_union_set *bset);6711 __isl_give isl_basic_set *isl_basic_set_solutions(6712 __isl_take isl_basic_set *bset);6713 __isl_give isl_basic_set *isl_set_solutions(6714 __isl_take isl_set *set);6715 __isl_give isl_union_set *isl_union_set_solutions(6716 __isl_take isl_union_set *bset);6717 6718=item * Power6719 6720 __isl_give isl_map *isl_map_fixed_power_val(6721 __isl_take isl_map *map,6722 __isl_take isl_val *exp);6723 __isl_give isl_union_map *6724 isl_union_map_fixed_power_val(6725 __isl_take isl_union_map *umap,6726 __isl_take isl_val *exp);6727 6728Compute the given power of C<map>, where C<exp> is assumed to be non-zero.6729If the exponent C<exp> is negative, then the -C<exp> th power of the inverse6730of C<map> is computed.6731 6732 __isl_give isl_map *isl_map_power(__isl_take isl_map *map,6733 isl_bool *exact);6734 __isl_give isl_union_map *isl_union_map_power(6735 __isl_take isl_union_map *umap, isl_bool *exact);6736 6737Compute a parametric representation for all positive powers I<k> of C<map>.6738The result maps I<k> to a nested relation corresponding to the6739I<k>th power of C<map>.6740The result may be an overapproximation. If the result is known to be exact,6741then C<*exact> is set to C<1>.6742 6743=item * Transitive closure6744 6745 __isl_give isl_map *isl_map_transitive_closure(6746 __isl_take isl_map *map, isl_bool *exact);6747 __isl_give isl_union_map *isl_union_map_transitive_closure(6748 __isl_take isl_union_map *umap, isl_bool *exact);6749 6750Compute the transitive closure of C<map>.6751The result may be an overapproximation. If the result is known to be exact,6752then C<*exact> is set to C<1>.6753 6754=item * Reaching path lengths6755 6756 __isl_give isl_map *isl_map_reaching_path_lengths(6757 __isl_take isl_map *map, isl_bool *exact);6758 6759Compute a relation that maps each element in the range of C<map>6760to the lengths of all paths composed of edges in C<map> that6761end up in the given element.6762The result may be an overapproximation. If the result is known to be exact,6763then C<*exact> is set to C<1>.6764To compute the I<maximal> path length, the resulting relation6765should be postprocessed by C<isl_map_lexmax>.6766In particular, if the input relation is a dependence relation6767(mapping sources to sinks), then the maximal path length corresponds6768to the free schedule.6769Note, however, that C<isl_map_lexmax> expects the maximum to be6770finite, so if the path lengths are unbounded (possibly due to6771the overapproximation), then you will get an error message.6772 6773=item * Wrapping6774 6775 #include <isl/space.h>6776 __isl_give isl_space *isl_space_wrap(6777 __isl_take isl_space *space);6778 __isl_give isl_space *isl_space_unwrap(6779 __isl_take isl_space *space);6780 6781 #include <isl/local_space.h>6782 __isl_give isl_local_space *isl_local_space_wrap(6783 __isl_take isl_local_space *ls);6784 6785 #include <isl/set.h>6786 __isl_give isl_basic_map *isl_basic_set_unwrap(6787 __isl_take isl_basic_set *bset);6788 __isl_give isl_map *isl_set_unwrap(6789 __isl_take isl_set *set);6790 6791 #include <isl/map.h>6792 __isl_give isl_basic_set *isl_basic_map_wrap(6793 __isl_take isl_basic_map *bmap);6794 __isl_give isl_set *isl_map_wrap(6795 __isl_take isl_map *map);6796 6797 #include <isl/union_set.h>6798 __isl_give isl_union_map *isl_union_set_unwrap(6799 __isl_take isl_union_set *uset);6800 6801 #include <isl/union_map.h>6802 __isl_give isl_union_set *isl_union_map_wrap(6803 __isl_take isl_union_map *umap);6804 6805The input to C<isl_space_unwrap> should6806be the space of a set, while that of6807C<isl_space_wrap> should be the space of a relation.6808Conversely, the output of C<isl_space_unwrap> is the space6809of a relation, while that of C<isl_space_wrap> is the space of a set.6810 6811=item * Flattening6812 6813Remove any internal structure of domain (and range) of the given6814set or relation. If there is any such internal structure in the input,6815then the name of the space is also removed.6816 6817 #include <isl/space.h>6818 __isl_give isl_space *isl_space_flatten_domain(6819 __isl_take isl_space *space);6820 __isl_give isl_space *isl_space_flatten_range(6821 __isl_take isl_space *space);6822 6823 #include <isl/local_space.h>6824 __isl_give isl_local_space *6825 isl_local_space_flatten_domain(6826 __isl_take isl_local_space *ls);6827 __isl_give isl_local_space *6828 isl_local_space_flatten_range(6829 __isl_take isl_local_space *ls);6830 6831 #include <isl/set.h>6832 __isl_give isl_basic_set *isl_basic_set_flatten(6833 __isl_take isl_basic_set *bset);6834 __isl_give isl_set *isl_set_flatten(6835 __isl_take isl_set *set);6836 6837 #include <isl/map.h>6838 __isl_give isl_basic_map *isl_basic_map_flatten_domain(6839 __isl_take isl_basic_map *bmap);6840 __isl_give isl_basic_map *isl_basic_map_flatten_range(6841 __isl_take isl_basic_map *bmap);6842 __isl_give isl_map *isl_map_flatten_range(6843 __isl_take isl_map *map);6844 __isl_give isl_map *isl_map_flatten_domain(6845 __isl_take isl_map *map);6846 __isl_give isl_basic_map *isl_basic_map_flatten(6847 __isl_take isl_basic_map *bmap);6848 __isl_give isl_map *isl_map_flatten(6849 __isl_take isl_map *map);6850 6851 #include <isl/id.h>6852 __isl_give isl_multi_id *isl_multi_id_flatten_range(6853 __isl_take isl_multi_id *mi);6854 6855 #include <isl/val.h>6856 __isl_give isl_multi_val *isl_multi_val_flatten_range(6857 __isl_take isl_multi_val *mv);6858 6859 #include <isl/aff.h>6860 __isl_give isl_multi_aff *isl_multi_aff_flatten_domain(6861 __isl_take isl_multi_aff *ma);6862 __isl_give isl_multi_aff *isl_multi_aff_flatten_range(6863 __isl_take isl_multi_aff *ma);6864 __isl_give isl_multi_pw_aff *6865 isl_multi_pw_aff_flatten_range(6866 __isl_take isl_multi_pw_aff *mpa);6867 __isl_give isl_multi_union_pw_aff *6868 isl_multi_union_pw_aff_flatten_range(6869 __isl_take isl_multi_union_pw_aff *mupa);6870 6871 #include <isl/map.h>6872 __isl_give isl_map *isl_set_flatten_map(6873 __isl_take isl_set *set);6874 6875The function above constructs a relation6876that maps the input set to a flattened version of the set.6877 6878=item * Lifting6879 6880Lift the input set to a space with extra dimensions corresponding6881to the existentially quantified variables in the input.6882In particular, the result lives in a wrapped map where the domain6883is the original space and the range corresponds to the original6884existentially quantified variables.6885 6886 #include <isl/set.h>6887 __isl_give isl_basic_set *isl_basic_set_lift(6888 __isl_take isl_basic_set *bset);6889 __isl_give isl_set *isl_set_lift(6890 __isl_take isl_set *set);6891 __isl_give isl_union_set *isl_union_set_lift(6892 __isl_take isl_union_set *uset);6893 6894Given a local space that contains the existentially quantified6895variables of a set, a basic relation that, when applied to6896a basic set, has essentially the same effect as C<isl_basic_set_lift>,6897can be constructed using the following function.6898 6899 #include <isl/local_space.h>6900 __isl_give isl_basic_map *isl_local_space_lifting(6901 __isl_take isl_local_space *ls);6902 6903 #include <isl/aff.h>6904 __isl_give isl_multi_aff *isl_multi_aff_lift(6905 __isl_take isl_multi_aff *maff,6906 __isl_give isl_local_space **ls);6907 6908If the C<ls> argument of C<isl_multi_aff_lift> is not C<NULL>,6909then it is assigned the local space that lies at the basis of6910the lifting applied.6911 6912=item * Internal Product6913 6914 #include <isl/space.h>6915 __isl_give isl_space *isl_space_zip(6916 __isl_take isl_space *space);6917 6918 #include <isl/map.h>6919 __isl_give isl_basic_map *isl_basic_map_zip(6920 __isl_take isl_basic_map *bmap);6921 __isl_give isl_map *isl_map_zip(6922 __isl_take isl_map *map);6923 6924 #include <isl/union_map.h>6925 __isl_give isl_union_map *isl_union_map_zip(6926 __isl_take isl_union_map *umap);6927 6928Given a relation with nested relations for domain and range,6929interchange the range of the domain with the domain of the range.6930 6931=item * Currying6932 6933 #include <isl/space.h>6934 __isl_give isl_space *isl_space_curry(6935 __isl_take isl_space *space);6936 __isl_give isl_space *isl_space_uncurry(6937 __isl_take isl_space *space);6938 6939 #include <isl/map.h>6940 __isl_give isl_basic_map *isl_basic_map_curry(6941 __isl_take isl_basic_map *bmap);6942 __isl_give isl_basic_map *isl_basic_map_uncurry(6943 __isl_take isl_basic_map *bmap);6944 __isl_give isl_map *isl_map_curry(6945 __isl_take isl_map *map);6946 __isl_give isl_map *isl_map_uncurry(6947 __isl_take isl_map *map);6948 6949 #include <isl/union_map.h>6950 __isl_give isl_union_map *isl_union_map_curry(6951 __isl_take isl_union_map *umap);6952 __isl_give isl_union_map *isl_union_map_uncurry(6953 __isl_take isl_union_map *umap);6954 6955Given a relation with a nested relation for domain,6956the C<curry> functions6957move the range of the nested relation out of the domain6958and use it as the domain of a nested relation in the range,6959with the original range as range of this nested relation.6960The C<uncurry> functions perform the inverse operation.6961 6962 #include <isl/space.h>6963 __isl_give isl_space *isl_space_range_curry(6964 __isl_take isl_space *space);6965 6966 #include <isl/map.h>6967 __isl_give isl_map *isl_map_range_curry(6968 __isl_take isl_map *map);6969 6970 #include <isl/union_map.h>6971 __isl_give isl_union_map *isl_union_map_range_curry(6972 __isl_take isl_union_map *umap);6973 6974These functions apply the currying to the relation that6975is nested inside the range of the input.6976 6977=item * Aligning parameters6978 6979Change the order of the parameters of the given set, relation6980or function6981such that the first parameters match those of C<model>.6982This may involve the introduction of extra parameters.6983All parameters need to be named.6984 6985 #include <isl/space.h>6986 __isl_give isl_space *isl_space_align_params(6987 __isl_take isl_space *space1,6988 __isl_take isl_space *space2)6989 6990 #include <isl/set.h>6991 __isl_give isl_basic_set *isl_basic_set_align_params(6992 __isl_take isl_basic_set *bset,6993 __isl_take isl_space *model);6994 __isl_give isl_set *isl_set_align_params(6995 __isl_take isl_set *set,6996 __isl_take isl_space *model);6997 6998 #include <isl/map.h>6999 __isl_give isl_basic_map *isl_basic_map_align_params(7000 __isl_take isl_basic_map *bmap,7001 __isl_take isl_space *model);7002 __isl_give isl_map *isl_map_align_params(7003 __isl_take isl_map *map,7004 __isl_take isl_space *model);7005 7006 #include <isl/id.h>7007 __isl_give isl_multi_id *isl_multi_id_align_params(7008 __isl_take isl_multi_id *mi,7009 __isl_take isl_space *model);7010 7011 #include <isl/val.h>7012 __isl_give isl_multi_val *isl_multi_val_align_params(7013 __isl_take isl_multi_val *mv,7014 __isl_take isl_space *model);7015 7016 #include <isl/aff.h>7017 __isl_give isl_aff *isl_aff_align_params(7018 __isl_take isl_aff *aff,7019 __isl_take isl_space *model);7020 __isl_give isl_multi_aff *isl_multi_aff_align_params(7021 __isl_take isl_multi_aff *multi,7022 __isl_take isl_space *model);7023 __isl_give isl_pw_aff *isl_pw_aff_align_params(7024 __isl_take isl_pw_aff *pwaff,7025 __isl_take isl_space *model);7026 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_align_params(7027 __isl_take isl_pw_multi_aff *pma,7028 __isl_take isl_space *model);7029 __isl_give isl_union_pw_aff *7030 isl_union_pw_aff_align_params(7031 __isl_take isl_union_pw_aff *upa,7032 __isl_take isl_space *model);7033 __isl_give isl_union_pw_multi_aff *7034 isl_union_pw_multi_aff_align_params(7035 __isl_take isl_union_pw_multi_aff *upma,7036 __isl_take isl_space *model);7037 __isl_give isl_multi_union_pw_aff *7038 isl_multi_union_pw_aff_align_params(7039 __isl_take isl_multi_union_pw_aff *mupa,7040 __isl_take isl_space *model);7041 7042 #include <isl/polynomial.h>7043 __isl_give isl_qpolynomial *isl_qpolynomial_align_params(7044 __isl_take isl_qpolynomial *qp,7045 __isl_take isl_space *model);7046 7047=item * Drop unused parameters7048 7049Drop parameters that are not referenced by the isl object.7050All parameters need to be named.7051 7052 #include <isl/set.h>7053 __isl_give isl_basic_set *7054 isl_basic_set_drop_unused_params(7055 __isl_take isl_basic_set *bset);7056 __isl_give isl_set *isl_set_drop_unused_params(7057 __isl_take isl_set *set);7058 7059 #include <isl/map.h>7060 __isl_give isl_basic_map *7061 isl_basic_map_drop_unused_params(7062 __isl_take isl_basic_map *bmap);7063 __isl_give isl_map *isl_map_drop_unused_params(7064 __isl_take isl_map *map);7065 7066 #include <isl/aff.h>7067 __isl_give isl_pw_aff *isl_pw_aff_drop_unused_params(7068 __isl_take isl_pw_aff *pa);7069 __isl_give isl_pw_multi_aff *7070 isl_pw_multi_aff_drop_unused_params(7071 __isl_take isl_pw_multi_aff *pma);7072 7073 #include <isl/polynomial.h>7074 __isl_give isl_pw_qpolynomial *7075 isl_pw_qpolynomial_drop_unused_params(7076 __isl_take isl_pw_qpolynomial *pwqp);7077 __isl_give isl_pw_qpolynomial_fold *7078 isl_pw_qpolynomial_fold_drop_unused_params(7079 __isl_take isl_pw_qpolynomial_fold *pwf);7080 7081=item * Unary Arithmetic Operations7082 7083 #include <isl/set.h>7084 __isl_give isl_set *isl_set_neg(7085 __isl_take isl_set *set);7086 #include <isl/map.h>7087 __isl_give isl_map *isl_map_neg(7088 __isl_take isl_map *map);7089 7090C<isl_set_neg> constructs a set containing the opposites of7091the elements in its argument.7092The domain of the result of C<isl_map_neg> is the same7093as the domain of its argument. The corresponding range7094elements are the opposites of the corresponding range7095elements in the argument.7096 7097 #include <isl/val.h>7098 __isl_give isl_multi_val *isl_multi_val_neg(7099 __isl_take isl_multi_val *mv);7100 7101 #include <isl/aff.h>7102 __isl_give isl_aff *isl_aff_neg(7103 __isl_take isl_aff *aff);7104 __isl_give isl_multi_aff *isl_multi_aff_neg(7105 __isl_take isl_multi_aff *ma);7106 __isl_give isl_pw_aff *isl_pw_aff_neg(7107 __isl_take isl_pw_aff *pwaff);7108 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_neg(7109 __isl_take isl_pw_multi_aff *pma);7110 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_neg(7111 __isl_take isl_multi_pw_aff *mpa);7112 __isl_give isl_union_pw_aff *isl_union_pw_aff_neg(7113 __isl_take isl_union_pw_aff *upa);7114 __isl_give isl_union_pw_multi_aff *7115 isl_union_pw_multi_aff_neg(7116 __isl_take isl_union_pw_multi_aff *upma);7117 __isl_give isl_multi_union_pw_aff *7118 isl_multi_union_pw_aff_neg(7119 __isl_take isl_multi_union_pw_aff *mupa);7120 __isl_give isl_aff *isl_aff_ceil(7121 __isl_take isl_aff *aff);7122 __isl_give isl_pw_aff *isl_pw_aff_ceil(7123 __isl_take isl_pw_aff *pwaff);7124 __isl_give isl_aff *isl_aff_floor(7125 __isl_take isl_aff *aff);7126 __isl_give isl_multi_aff *isl_multi_aff_floor(7127 __isl_take isl_multi_aff *ma);7128 __isl_give isl_pw_aff *isl_pw_aff_floor(7129 __isl_take isl_pw_aff *pwaff);7130 __isl_give isl_union_pw_aff *isl_union_pw_aff_floor(7131 __isl_take isl_union_pw_aff *upa);7132 __isl_give isl_multi_union_pw_aff *7133 isl_multi_union_pw_aff_floor(7134 __isl_take isl_multi_union_pw_aff *mupa);7135 7136 #include <isl/aff.h>7137 __isl_give isl_pw_aff *isl_pw_aff_list_min(7138 __isl_take isl_pw_aff_list *list);7139 __isl_give isl_pw_aff *isl_pw_aff_list_max(7140 __isl_take isl_pw_aff_list *list);7141 7142 #include <isl/polynomial.h>7143 __isl_give isl_qpolynomial *isl_qpolynomial_neg(7144 __isl_take isl_qpolynomial *qp);7145 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_neg(7146 __isl_take isl_pw_qpolynomial *pwqp);7147 __isl_give isl_union_pw_qpolynomial *7148 isl_union_pw_qpolynomial_neg(7149 __isl_take isl_union_pw_qpolynomial *upwqp);7150 __isl_give isl_qpolynomial *isl_qpolynomial_pow(7151 __isl_take isl_qpolynomial *qp,7152 unsigned exponent);7153 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_pow(7154 __isl_take isl_pw_qpolynomial *pwqp,7155 unsigned exponent);7156 7157=item * Evaluation7158 7159The following functions evaluate a function in a point.7160 7161 #include <isl/aff.h>7162 __isl_give isl_val *isl_aff_eval(7163 __isl_take isl_aff *aff,7164 __isl_take isl_point *pnt);7165 __isl_give isl_val *isl_pw_aff_eval(7166 __isl_take isl_pw_aff *pa,7167 __isl_take isl_point *pnt);7168 7169 #include <isl/polynomial.h>7170 __isl_give isl_val *isl_pw_qpolynomial_eval(7171 __isl_take isl_pw_qpolynomial *pwqp,7172 __isl_take isl_point *pnt);7173 __isl_give isl_val *isl_pw_qpolynomial_fold_eval(7174 __isl_take isl_pw_qpolynomial_fold *pwf,7175 __isl_take isl_point *pnt);7176 __isl_give isl_val *isl_union_pw_qpolynomial_eval(7177 __isl_take isl_union_pw_qpolynomial *upwqp,7178 __isl_take isl_point *pnt);7179 __isl_give isl_val *isl_union_pw_qpolynomial_fold_eval(7180 __isl_take isl_union_pw_qpolynomial_fold *upwf,7181 __isl_take isl_point *pnt);7182 7183These functions return NaN when evaluated at a void point.7184Note that C<isl_pw_aff_eval> returns NaN when the function is evaluated outside7185its definition domain, while C<isl_pw_qpolynomial_eval> returns zero7186when the function is evaluated outside its explicit domain.7187 7188=item * Dimension manipulation7189 7190It is usually not advisable to directly change the (input or output)7191space of a set or a relation as this removes the name and the internal7192structure of the space. However, the functions below can be useful7193to add new parameters, assuming7194C<isl_set_align_params> and C<isl_map_align_params>7195are not sufficient.7196 7197 #include <isl/space.h>7198 __isl_give isl_space *isl_space_add_dims(7199 __isl_take isl_space *space,7200 enum isl_dim_type type, unsigned n);7201 __isl_give isl_space *isl_space_insert_dims(7202 __isl_take isl_space *space,7203 enum isl_dim_type type, unsigned pos, unsigned n);7204 __isl_give isl_space *isl_space_drop_dims(7205 __isl_take isl_space *space,7206 enum isl_dim_type type, unsigned first, unsigned n);7207 __isl_give isl_space *isl_space_move_dims(7208 __isl_take isl_space *space,7209 enum isl_dim_type dst_type, unsigned dst_pos,7210 enum isl_dim_type src_type, unsigned src_pos,7211 unsigned n);7212 7213 #include <isl/local_space.h>7214 __isl_give isl_local_space *isl_local_space_add_dims(7215 __isl_take isl_local_space *ls,7216 enum isl_dim_type type, unsigned n);7217 __isl_give isl_local_space *isl_local_space_insert_dims(7218 __isl_take isl_local_space *ls,7219 enum isl_dim_type type, unsigned first, unsigned n);7220 __isl_give isl_local_space *isl_local_space_drop_dims(7221 __isl_take isl_local_space *ls,7222 enum isl_dim_type type, unsigned first, unsigned n);7223 7224 #include <isl/set.h>7225 __isl_give isl_basic_set *isl_basic_set_add_dims(7226 __isl_take isl_basic_set *bset,7227 enum isl_dim_type type, unsigned n);7228 __isl_give isl_set *isl_set_add_dims(7229 __isl_take isl_set *set,7230 enum isl_dim_type type, unsigned n);7231 __isl_give isl_basic_set *isl_basic_set_insert_dims(7232 __isl_take isl_basic_set *bset,7233 enum isl_dim_type type, unsigned pos,7234 unsigned n);7235 __isl_give isl_set *isl_set_insert_dims(7236 __isl_take isl_set *set,7237 enum isl_dim_type type, unsigned pos, unsigned n);7238 __isl_give isl_basic_set *isl_basic_set_move_dims(7239 __isl_take isl_basic_set *bset,7240 enum isl_dim_type dst_type, unsigned dst_pos,7241 enum isl_dim_type src_type, unsigned src_pos,7242 unsigned n);7243 __isl_give isl_set *isl_set_move_dims(7244 __isl_take isl_set *set,7245 enum isl_dim_type dst_type, unsigned dst_pos,7246 enum isl_dim_type src_type, unsigned src_pos,7247 unsigned n);7248 7249 #include <isl/map.h>7250 __isl_give isl_basic_map *isl_basic_map_add_dims(7251 __isl_take isl_basic_map *bmap,7252 enum isl_dim_type type, unsigned n);7253 __isl_give isl_map *isl_map_add_dims(7254 __isl_take isl_map *map,7255 enum isl_dim_type type, unsigned n);7256 __isl_give isl_basic_map *isl_basic_map_insert_dims(7257 __isl_take isl_basic_map *bmap,7258 enum isl_dim_type type, unsigned pos,7259 unsigned n);7260 __isl_give isl_map *isl_map_insert_dims(7261 __isl_take isl_map *map,7262 enum isl_dim_type type, unsigned pos, unsigned n);7263 __isl_give isl_basic_map *isl_basic_map_move_dims(7264 __isl_take isl_basic_map *bmap,7265 enum isl_dim_type dst_type, unsigned dst_pos,7266 enum isl_dim_type src_type, unsigned src_pos,7267 unsigned n);7268 __isl_give isl_map *isl_map_move_dims(7269 __isl_take isl_map *map,7270 enum isl_dim_type dst_type, unsigned dst_pos,7271 enum isl_dim_type src_type, unsigned src_pos,7272 unsigned n);7273 7274 #include <isl/val.h>7275 __isl_give isl_multi_val *isl_multi_val_insert_dims(7276 __isl_take isl_multi_val *mv,7277 enum isl_dim_type type, unsigned first, unsigned n);7278 __isl_give isl_multi_val *isl_multi_val_add_dims(7279 __isl_take isl_multi_val *mv,7280 enum isl_dim_type type, unsigned n);7281 __isl_give isl_multi_val *isl_multi_val_drop_dims(7282 __isl_take isl_multi_val *mv,7283 enum isl_dim_type type, unsigned first, unsigned n);7284 7285 #include <isl/aff.h>7286 __isl_give isl_aff *isl_aff_insert_dims(7287 __isl_take isl_aff *aff,7288 enum isl_dim_type type, unsigned first, unsigned n);7289 __isl_give isl_multi_aff *isl_multi_aff_insert_dims(7290 __isl_take isl_multi_aff *ma,7291 enum isl_dim_type type, unsigned first, unsigned n);7292 __isl_give isl_pw_aff *isl_pw_aff_insert_dims(7293 __isl_take isl_pw_aff *pwaff,7294 enum isl_dim_type type, unsigned first, unsigned n);7295 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_insert_dims(7296 __isl_take isl_multi_pw_aff *mpa,7297 enum isl_dim_type type, unsigned first, unsigned n);7298 __isl_give isl_aff *isl_aff_add_dims(7299 __isl_take isl_aff *aff,7300 enum isl_dim_type type, unsigned n);7301 __isl_give isl_multi_aff *isl_multi_aff_add_dims(7302 __isl_take isl_multi_aff *ma,7303 enum isl_dim_type type, unsigned n);7304 __isl_give isl_pw_aff *isl_pw_aff_add_dims(7305 __isl_take isl_pw_aff *pwaff,7306 enum isl_dim_type type, unsigned n);7307 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_add_dims(7308 __isl_take isl_multi_pw_aff *mpa,7309 enum isl_dim_type type, unsigned n);7310 __isl_give isl_aff *isl_aff_drop_dims(7311 __isl_take isl_aff *aff,7312 enum isl_dim_type type, unsigned first, unsigned n);7313 __isl_give isl_multi_aff *isl_multi_aff_drop_dims(7314 __isl_take isl_multi_aff *maff,7315 enum isl_dim_type type, unsigned first, unsigned n);7316 __isl_give isl_pw_aff *isl_pw_aff_drop_dims(7317 __isl_take isl_pw_aff *pwaff,7318 enum isl_dim_type type, unsigned first, unsigned n);7319 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_drop_dims(7320 __isl_take isl_pw_multi_aff *pma,7321 enum isl_dim_type type, unsigned first, unsigned n);7322 __isl_give isl_union_pw_aff *isl_union_pw_aff_drop_dims(7323 __isl_take isl_union_pw_aff *upa,7324 enum isl_dim_type type, unsigned first, unsigned n);7325 __isl_give isl_union_pw_multi_aff *7326 isl_union_pw_multi_aff_drop_dims(7327 __isl_take isl_union_pw_multi_aff *upma,7328 enum isl_dim_type type,7329 unsigned first, unsigned n);7330 __isl_give isl_multi_union_pw_aff *7331 isl_multi_union_pw_aff_drop_dims(7332 __isl_take isl_multi_union_pw_aff *mupa,7333 enum isl_dim_type type, unsigned first,7334 unsigned n);7335 __isl_give isl_aff *isl_aff_move_dims(7336 __isl_take isl_aff *aff,7337 enum isl_dim_type dst_type, unsigned dst_pos,7338 enum isl_dim_type src_type, unsigned src_pos,7339 unsigned n);7340 __isl_give isl_multi_aff *isl_multi_aff_move_dims(7341 __isl_take isl_multi_aff *ma,7342 enum isl_dim_type dst_type, unsigned dst_pos,7343 enum isl_dim_type src_type, unsigned src_pos,7344 unsigned n);7345 __isl_give isl_pw_aff *isl_pw_aff_move_dims(7346 __isl_take isl_pw_aff *pa,7347 enum isl_dim_type dst_type, unsigned dst_pos,7348 enum isl_dim_type src_type, unsigned src_pos,7349 unsigned n);7350 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_move_dims(7351 __isl_take isl_multi_pw_aff *pma,7352 enum isl_dim_type dst_type, unsigned dst_pos,7353 enum isl_dim_type src_type, unsigned src_pos,7354 unsigned n);7355 7356 #include <isl/polynomial.h>7357 __isl_give isl_union_pw_qpolynomial *7358 isl_union_pw_qpolynomial_drop_dims(7359 __isl_take isl_union_pw_qpolynomial *upwqp,7360 enum isl_dim_type type,7361 unsigned first, unsigned n);7362 __isl_give isl_union_pw_qpolynomial_fold *7363 isl_union_pw_qpolynomial_fold_drop_dims(7364 __isl_take isl_union_pw_qpolynomial_fold *upwf,7365 enum isl_dim_type type,7366 unsigned first, unsigned n);7367 7368The operations on union expressions can only manipulate parameters.7369 7370=back7371 7372=head2 Binary Operations7373 7374The two arguments of a binary operation not only need to live7375in the same C<isl_ctx>, they currently also need to have7376the same (number of) parameters.7377 7378=head3 Basic Operations7379 7380=over7381 7382=item * Intersection7383 7384 #include <isl/local_space.h>7385 __isl_give isl_local_space *isl_local_space_intersect(7386 __isl_take isl_local_space *ls1,7387 __isl_take isl_local_space *ls2);7388 7389 #include <isl/set.h>7390 __isl_give isl_basic_set *isl_basic_set_intersect_params(7391 __isl_take isl_basic_set *bset1,7392 __isl_take isl_basic_set *bset2);7393 __isl_give isl_basic_set *isl_basic_set_intersect(7394 __isl_take isl_basic_set *bset1,7395 __isl_take isl_basic_set *bset2);7396 __isl_give isl_basic_set *isl_basic_set_list_intersect(7397 __isl_take struct isl_basic_set_list *list);7398 __isl_give isl_set *isl_set_intersect_params(7399 __isl_take isl_set *set,7400 __isl_take isl_set *params);7401 __isl_give isl_set *isl_set_intersect(7402 __isl_take isl_set *set1,7403 __isl_take isl_set *set2);7404 __isl_give isl_set *isl_set_intersect_factor_domain(7405 __isl_take isl_set *set,7406 __isl_take isl_set *domain);7407 __isl_give isl_set *isl_set_intersect_factor_range(7408 __isl_take isl_set *set,7409 __isl_take isl_set *range);7410 7411 #include <isl/map.h>7412 __isl_give isl_basic_map *isl_basic_map_intersect_domain(7413 __isl_take isl_basic_map *bmap,7414 __isl_take isl_basic_set *bset);7415 __isl_give isl_basic_map *isl_basic_map_intersect_range(7416 __isl_take isl_basic_map *bmap,7417 __isl_take isl_basic_set *bset);7418 __isl_give isl_basic_map *isl_basic_map_intersect(7419 __isl_take isl_basic_map *bmap1,7420 __isl_take isl_basic_map *bmap2);7421 __isl_give isl_basic_map *isl_basic_map_list_intersect(7422 __isl_take isl_basic_map_list *list);7423 __isl_give isl_map *isl_map_intersect_params(7424 __isl_take isl_map *map,7425 __isl_take isl_set *params);7426 __isl_give isl_map *isl_map_intersect_domain(7427 __isl_take isl_map *map,7428 __isl_take isl_set *set);7429 __isl_give isl_map *isl_map_intersect_range(7430 __isl_take isl_map *map,7431 __isl_take isl_set *set);7432 __isl_give isl_map *isl_map_intersect(7433 __isl_take isl_map *map1,7434 __isl_take isl_map *map2);7435 __isl_give isl_map *7436 isl_map_intersect_domain_factor_domain(7437 __isl_take isl_map *map,7438 __isl_take isl_map *factor);7439 __isl_give isl_map *7440 isl_map_intersect_domain_factor_range(7441 __isl_take isl_map *map,7442 __isl_take isl_map *factor);7443 __isl_give isl_map *7444 isl_map_intersect_range_factor_domain(7445 __isl_take isl_map *map,7446 __isl_take isl_map *factor);7447 __isl_give isl_map *7448 isl_map_intersect_range_factor_range(7449 __isl_take isl_map *map,7450 __isl_take isl_map *factor);7451 __isl_give isl_map *7452 isl_map_intersect_domain_wrapped_domain(7453 __isl_take isl_map *map,7454 __isl_take isl_set *domain);7455 __isl_give isl_map *7456 isl_map_intersect_range_wrapped_domain(7457 __isl_take isl_map *map,7458 __isl_take isl_set *domain);7459 7460 #include <isl/union_set.h>7461 __isl_give isl_union_set *isl_union_set_intersect_params(7462 __isl_take isl_union_set *uset,7463 __isl_take isl_set *set);7464 __isl_give isl_union_set *isl_union_set_intersect(7465 __isl_take isl_union_set *uset1,7466 __isl_take isl_union_set *uset2);7467 7468 #include <isl/union_map.h>7469 __isl_give isl_union_map *isl_union_map_intersect_params(7470 __isl_take isl_union_map *umap,7471 __isl_take isl_set *set);7472 __isl_give isl_union_map *7473 isl_union_map_intersect_domain_union_set(7474 __isl_take isl_union_map *umap,7475 __isl_take isl_union_set *uset);7476 __isl_give isl_union_map *7477 isl_union_map_intersect_domain_space(7478 __isl_take isl_union_map *umap,7479 __isl_take isl_space *space);7480 __isl_give isl_union_map *isl_union_map_intersect_domain(7481 __isl_take isl_union_map *umap,7482 __isl_take isl_union_set *uset);7483 __isl_give isl_union_map *7484 isl_union_map_intersect_range_union_set(7485 __isl_take isl_union_map *umap,7486 __isl_take isl_union_set *uset);7487 __isl_give isl_union_map *7488 isl_union_map_intersect_range_space(7489 __isl_take isl_union_map *umap,7490 __isl_take isl_space *space);7491 __isl_give isl_union_map *isl_union_map_intersect_range(7492 __isl_take isl_union_map *umap,7493 __isl_take isl_union_set *uset);7494 __isl_give isl_union_map *isl_union_map_intersect(7495 __isl_take isl_union_map *umap1,7496 __isl_take isl_union_map *umap2);7497 __isl_give isl_union_map *7498 isl_union_map_intersect_domain_factor_domain(7499 __isl_take isl_union_map *umap,7500 __isl_take isl_union_map *factor);7501 __isl_give isl_union_map *7502 isl_union_map_intersect_domain_factor_range(7503 __isl_take isl_union_map *umap,7504 __isl_take isl_union_map *factor);7505 __isl_give isl_union_map *7506 isl_union_map_intersect_range_factor_domain(7507 __isl_take isl_union_map *umap,7508 __isl_take isl_union_map *factor);7509 __isl_give isl_union_map *7510 isl_union_map_intersect_range_factor_range(7511 __isl_take isl_union_map *umap,7512 __isl_take isl_union_map *factor);7513 __isl_give isl_union_map *7514 isl_union_map_intersect_domain_wrapped_domain_union_set(7515 __isl_take isl_union_map *umap,7516 __isl_take isl_union_set *domain);7517 __isl_give isl_union_map *7518 isl_union_map_intersect_range_wrapped_domain_union_set(7519 __isl_take isl_union_map *umap,7520 __isl_take isl_union_set *domain);7521 7522 #include <isl/aff.h>7523 __isl_give isl_pw_aff *isl_pw_aff_intersect_domain(7524 __isl_take isl_pw_aff *pa,7525 __isl_take isl_set *set);7526 __isl_give isl_multi_pw_aff *7527 isl_multi_pw_aff_intersect_domain(7528 __isl_take isl_multi_pw_aff *mpa,7529 __isl_take isl_set *domain);7530 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_domain(7531 __isl_take isl_pw_multi_aff *pma,7532 __isl_take isl_set *set);7533 __isl_give isl_union_pw_aff *7534 isl_union_pw_aff_intersect_domain_space(7535 __isl_take isl_union_pw_aff *upa,7536 __isl_take isl_space *space);7537 __isl_give isl_union_pw_aff *7538 isl_union_pw_aff_intersect_domain_union_set(7539 __isl_take isl_union_pw_aff *upa,7540 __isl_take isl_union_set *uset);7541 __isl_give isl_union_pw_aff *isl_union_pw_aff_intersect_domain(7542 __isl_take isl_union_pw_aff *upa,7543 __isl_take isl_union_set *uset);7544 __isl_give isl_union_pw_multi_aff *7545 isl_union_pw_multi_aff_intersect_domain_space(7546 __isl_take isl_union_pw_multi_aff *upma,7547 __isl_take isl_space *space);7548 __isl_give isl_union_pw_multi_aff *7549 isl_union_pw_multi_aff_intersect_domain_union_set(7550 __isl_take isl_union_pw_multi_aff *upma,7551 __isl_take isl_union_set *uset);7552 __isl_give isl_union_pw_multi_aff *7553 isl_union_pw_multi_aff_intersect_domain(7554 __isl_take isl_union_pw_multi_aff *upma,7555 __isl_take isl_union_set *uset);7556 __isl_give isl_multi_union_pw_aff *7557 isl_multi_union_pw_aff_intersect_domain(7558 __isl_take isl_multi_union_pw_aff *mupa,7559 __isl_take isl_union_set *uset);7560 __isl_give isl_pw_aff *7561 isl_pw_aff_intersect_domain_wrapped_domain(7562 __isl_take isl_pw_aff *pa,7563 __isl_take isl_set *set);7564 __isl_give isl_pw_multi_aff *7565 isl_pw_multi_aff_intersect_domain_wrapped_domain(7566 __isl_take isl_pw_multi_aff *pma,7567 __isl_take isl_set *set);7568 __isl_give isl_union_pw_aff *7569 isl_union_pw_aff_intersect_domain_wrapped_domain(7570 __isl_take isl_union_pw_aff *upa,7571 __isl_take isl_union_set *uset);7572 __isl_give isl_union_pw_multi_aff *7573 isl_union_pw_multi_aff_intersect_domain_wrapped_domain(7574 __isl_take isl_union_pw_multi_aff *upma,7575 __isl_take isl_union_set *uset);7576 __isl_give isl_pw_aff *7577 isl_pw_aff_intersect_domain_wrapped_range(7578 __isl_take isl_pw_aff *pa,7579 __isl_take isl_set *set);7580 __isl_give isl_pw_multi_aff *7581 isl_pw_multi_aff_intersect_domain_wrapped_range(7582 __isl_take isl_pw_multi_aff *pma,7583 __isl_take isl_set *set);7584 __isl_give isl_union_pw_multi_aff *7585 isl_union_pw_multi_aff_intersect_domain_wrapped_range(7586 __isl_take isl_union_pw_multi_aff *upma,7587 __isl_take isl_union_set *uset);7588 __isl_give isl_union_pw_aff *7589 isl_union_pw_aff_intersect_domain_wrapped_range(7590 __isl_take isl_union_pw_aff *upa,7591 __isl_take isl_union_set *uset);7592 __isl_give isl_pw_aff *isl_pw_aff_intersect_params(7593 __isl_take isl_pw_aff *pa,7594 __isl_take isl_set *set);7595 __isl_give isl_multi_pw_aff *7596 isl_multi_pw_aff_intersect_params(7597 __isl_take isl_multi_pw_aff *mpa,7598 __isl_take isl_set *set);7599 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_params(7600 __isl_take isl_pw_multi_aff *pma,7601 __isl_take isl_set *set);7602 __isl_give isl_union_pw_aff *7603 isl_union_pw_aff_intersect_params(7604 __isl_take isl_union_pw_aff *upa,7605 __isl_take isl_set *set);7606 __isl_give isl_union_pw_multi_aff *7607 isl_union_pw_multi_aff_intersect_params(7608 __isl_take isl_union_pw_multi_aff *upma,7609 __isl_take isl_set *set);7610 __isl_give isl_multi_union_pw_aff *7611 isl_multi_union_pw_aff_intersect_params(7612 __isl_take isl_multi_union_pw_aff *mupa,7613 __isl_take isl_set *params);7614 __isl_give isl_multi_union_pw_aff *7615 isl_multi_union_pw_aff_intersect_range(7616 __isl_take isl_multi_union_pw_aff *mupa,7617 __isl_take isl_set *set);7618 7619 #include <isl/polynomial.h>7620 __isl_give isl_pw_qpolynomial *7621 isl_pw_qpolynomial_intersect_domain(7622 __isl_take isl_pw_qpolynomial *pwpq,7623 __isl_take isl_set *set);7624 __isl_give isl_union_pw_qpolynomial *7625 isl_union_pw_qpolynomial_intersect_domain_space(7626 __isl_take isl_union_pw_qpolynomial *upwpq,7627 __isl_take isl_space *space);7628 __isl_give isl_union_pw_qpolynomial *7629 isl_union_pw_qpolynomial_intersect_domain_union_set(7630 __isl_take isl_union_pw_qpolynomial *upwpq,7631 __isl_take isl_union_set *uset);7632 __isl_give isl_union_pw_qpolynomial *7633 isl_union_pw_qpolynomial_intersect_domain(7634 __isl_take isl_union_pw_qpolynomial *upwpq,7635 __isl_take isl_union_set *uset);7636 __isl_give isl_union_pw_qpolynomial_fold *7637 isl_union_pw_qpolynomial_fold_intersect_domain_space(7638 __isl_take isl_union_pw_qpolynomial_fold *upwf,7639 __isl_take isl_space *space);7640 __isl_give isl_union_pw_qpolynomial_fold *7641 isl_union_pw_qpolynomial_fold_intersect_domain_union_set(7642 __isl_take isl_union_pw_qpolynomial_fold *upwf,7643 __isl_take isl_union_set *uset);7644 __isl_give isl_union_pw_qpolynomial_fold *7645 isl_union_pw_qpolynomial_fold_intersect_domain(7646 __isl_take isl_union_pw_qpolynomial_fold *upwf,7647 __isl_take isl_union_set *uset);7648 __isl_give isl_pw_qpolynomial *7649 isl_pw_qpolynomial_intersect_domain_wrapped_domain(7650 __isl_take isl_pw_qpolynomial *pwpq,7651 __isl_take isl_set *set);7652 __isl_give isl_pw_qpolynomial_fold *7653 isl_pw_qpolynomial_fold_intersect_domain_wrapped_domain(7654 __isl_take isl_pw_qpolynomial_fold *pwf,7655 __isl_take isl_set *set);7656 __isl_give isl_union_pw_qpolynomial *7657 isl_union_pw_qpolynomial_intersect_domain_wrapped_domain(7658 __isl_take isl_union_pw_qpolynomial *upwpq,7659 __isl_take isl_union_set *uset);7660 __isl_give isl_union_pw_qpolynomial_fold *7661 isl_union_pw_qpolynomial_fold_intersect_domain_wrapped_domain(7662 __isl_take isl_union_pw_qpolynomial_fold *upwf,7663 __isl_take isl_union_set *uset);7664 __isl_give isl_pw_qpolynomial *7665 isl_pw_qpolynomial_intersect_domain_wrapped_range(7666 __isl_take isl_pw_qpolynomial *pwpq,7667 __isl_take isl_set *set);7668 __isl_give isl_pw_qpolynomial_fold *7669 isl_pw_qpolynomial_fold_intersect_domain_wrapped_range(7670 __isl_take isl_pw_qpolynomial_fold *pwf,7671 __isl_take isl_set *set);7672 __isl_give isl_union_pw_qpolynomial *7673 isl_union_pw_qpolynomial_intersect_domain_wrapped_range(7674 __isl_take isl_union_pw_qpolynomial *upwpq,7675 __isl_take isl_union_set *uset);7676 __isl_give isl_union_pw_qpolynomial_fold *7677 isl_union_pw_qpolynomial_fold_intersect_domain_wrapped_range(7678 __isl_take isl_union_pw_qpolynomial_fold *upwf,7679 __isl_take isl_union_set *uset);7680 __isl_give isl_pw_qpolynomial *7681 isl_pw_qpolynomial_intersect_params(7682 __isl_take isl_pw_qpolynomial *pwpq,7683 __isl_take isl_set *set);7684 __isl_give isl_pw_qpolynomial_fold *7685 isl_pw_qpolynomial_fold_intersect_params(7686 __isl_take isl_pw_qpolynomial_fold *pwf,7687 __isl_take isl_set *set);7688 __isl_give isl_union_pw_qpolynomial *7689 isl_union_pw_qpolynomial_intersect_params(7690 __isl_take isl_union_pw_qpolynomial *upwpq,7691 __isl_take isl_set *set);7692 __isl_give isl_union_pw_qpolynomial_fold *7693 isl_union_pw_qpolynomial_fold_intersect_params(7694 __isl_take isl_union_pw_qpolynomial_fold *upwf,7695 __isl_take isl_set *set);7696 7697The second argument to the C<_params> functions needs to be7698a parametric (basic) set. For the other functions, a parametric set7699for either argument is only allowed if the other argument is7700a parametric set as well.7701The list passed to C<isl_basic_set_list_intersect> needs to have7702at least one element and all elements need to live in the same space.7703The function C<isl_multi_union_pw_aff_intersect_range>7704restricts the input function to those shared domain elements7705that map to the specified range.7706C<isl_union_map_intersect_domain> is an alternative name for7707C<isl_union_map_intersect_domain_union_set>.7708Similarly for the other pairs of functions.7709 7710=item * Union7711 7712 #include <isl/set.h>7713 __isl_give isl_set *isl_basic_set_union(7714 __isl_take isl_basic_set *bset1,7715 __isl_take isl_basic_set *bset2);7716 __isl_give isl_set *isl_set_union(7717 __isl_take isl_set *set1,7718 __isl_take isl_set *set2);7719 __isl_give isl_set *isl_set_list_union(7720 __isl_take isl_set_list *list);7721 7722 #include <isl/map.h>7723 __isl_give isl_map *isl_basic_map_union(7724 __isl_take isl_basic_map *bmap1,7725 __isl_take isl_basic_map *bmap2);7726 __isl_give isl_map *isl_map_union(7727 __isl_take isl_map *map1,7728 __isl_take isl_map *map2);7729 7730 #include <isl/union_set.h>7731 __isl_give isl_union_set *isl_union_set_union(7732 __isl_take isl_union_set *uset1,7733 __isl_take isl_union_set *uset2);7734 __isl_give isl_union_set *isl_union_set_list_union(7735 __isl_take isl_union_set_list *list);7736 7737 #include <isl/union_map.h>7738 __isl_give isl_union_map *isl_union_map_union(7739 __isl_take isl_union_map *umap1,7740 __isl_take isl_union_map *umap2);7741 7742The list passed to C<isl_set_list_union> needs to have7743at least one element and all elements need to live in the same space.7744 7745=item * Set difference7746 7747 #include <isl/set.h>7748 __isl_give isl_set *isl_set_subtract(7749 __isl_take isl_set *set1,7750 __isl_take isl_set *set2);7751 7752 #include <isl/map.h>7753 __isl_give isl_map *isl_map_subtract(7754 __isl_take isl_map *map1,7755 __isl_take isl_map *map2);7756 __isl_give isl_map *isl_map_subtract_domain(7757 __isl_take isl_map *map,7758 __isl_take isl_set *dom);7759 __isl_give isl_map *isl_map_subtract_range(7760 __isl_take isl_map *map,7761 __isl_take isl_set *dom);7762 7763 #include <isl/union_set.h>7764 __isl_give isl_union_set *isl_union_set_subtract(7765 __isl_take isl_union_set *uset1,7766 __isl_take isl_union_set *uset2);7767 7768 #include <isl/union_map.h>7769 __isl_give isl_union_map *isl_union_map_subtract(7770 __isl_take isl_union_map *umap1,7771 __isl_take isl_union_map *umap2);7772 __isl_give isl_union_map *isl_union_map_subtract_domain(7773 __isl_take isl_union_map *umap,7774 __isl_take isl_union_set *dom);7775 __isl_give isl_union_map *isl_union_map_subtract_range(7776 __isl_take isl_union_map *umap,7777 __isl_take isl_union_set *dom);7778 7779 #include <isl/aff.h>7780 __isl_give isl_pw_aff *isl_pw_aff_subtract_domain(7781 __isl_take isl_pw_aff *pa,7782 __isl_take isl_set *set);7783 __isl_give isl_pw_multi_aff *7784 isl_pw_multi_aff_subtract_domain(7785 __isl_take isl_pw_multi_aff *pma,7786 __isl_take isl_set *set);7787 __isl_give isl_union_pw_aff *7788 isl_union_pw_aff_subtract_domain_union_set(7789 __isl_take isl_union_pw_aff *upa,7790 __isl_take isl_union_set *uset);7791 __isl_give isl_union_pw_aff *7792 isl_union_pw_aff_subtract_domain_space(7793 __isl_take isl_union_pw_aff *upa,7794 __isl_take isl_space *space);7795 __isl_give isl_union_pw_aff *7796 isl_union_pw_aff_subtract_domain(7797 __isl_take isl_union_pw_aff *upa,7798 __isl_take isl_union_set *uset);7799 __isl_give isl_union_pw_multi_aff *7800 isl_union_pw_multi_aff_subtract_domain_union_set(7801 __isl_take isl_union_pw_multi_aff *upma,7802 __isl_take isl_set *set);7803 __isl_give isl_union_pw_multi_aff *7804 isl_union_pw_multi_aff_subtract_domain_space(7805 __isl_take isl_union_pw_multi_aff *upma,7806 __isl_take isl_space *space);7807 __isl_give isl_union_pw_multi_aff *7808 isl_union_pw_multi_aff_subtract_domain(7809 __isl_take isl_union_pw_multi_aff *upma,7810 __isl_take isl_union_set *uset);7811 7812 #include <isl/polynomial.h>7813 __isl_give isl_pw_qpolynomial *7814 isl_pw_qpolynomial_subtract_domain(7815 __isl_take isl_pw_qpolynomial *pwpq,7816 __isl_take isl_set *set);7817 __isl_give isl_pw_qpolynomial_fold *7818 isl_pw_qpolynomial_fold_subtract_domain(7819 __isl_take isl_pw_qpolynomial_fold *pwf,7820 __isl_take isl_set *set);7821 __isl_give isl_union_pw_qpolynomial *7822 isl_union_pw_qpolynomial_subtract_domain_union_set(7823 __isl_take isl_union_pw_qpolynomial *upwpq,7824 __isl_take isl_union_set *uset);7825 __isl_give isl_union_pw_qpolynomial *7826 isl_union_pw_qpolynomial_subtract_domain_space(7827 __isl_take isl_union_pw_qpolynomial *upwpq,7828 __isl_take isl_space *space);7829 __isl_give isl_union_pw_qpolynomial *7830 isl_union_pw_qpolynomial_subtract_domain(7831 __isl_take isl_union_pw_qpolynomial *upwpq,7832 __isl_take isl_union_set *uset);7833 __isl_give isl_union_pw_qpolynomial_fold *7834 isl_union_pw_qpolynomial_fold_subtract_domain_union_set(7835 __isl_take isl_union_pw_qpolynomial_fold *upwf,7836 __isl_take isl_union_set *uset);7837 __isl_give isl_union_pw_qpolynomial_fold *7838 isl_union_pw_qpolynomial_fold_subtract_domain_space(7839 __isl_take isl_union_pw_qpolynomial_fold *upwf,7840 __isl_take isl_space *space);7841 __isl_give isl_union_pw_qpolynomial_fold *7842 isl_union_pw_qpolynomial_fold_subtract_domain(7843 __isl_take isl_union_pw_qpolynomial_fold *upwf,7844 __isl_take isl_union_set *uset);7845 7846C<isl_union_pw_aff_subtract_domain> is an alternative name for7847C<isl_union_pw_aff_subtract_domain_union_set>.7848Similarly for the other pairs of functions.7849 7850=item * Application7851 7852 #include <isl/space.h>7853 __isl_give isl_space *isl_space_join(7854 __isl_take isl_space *left,7855 __isl_take isl_space *right);7856 7857 #include <isl/set.h>7858 __isl_give isl_basic_set *isl_basic_set_apply(7859 __isl_take isl_basic_set *bset,7860 __isl_take isl_basic_map *bmap);7861 __isl_give isl_set *isl_set_apply(7862 __isl_take isl_set *set,7863 __isl_take isl_map *map);7864 7865 #include <isl/union_set.h>7866 __isl_give isl_union_set *isl_union_set_apply(7867 __isl_take isl_union_set *uset,7868 __isl_take isl_union_map *umap);7869 7870 #include <isl/map.h>7871 __isl_give isl_basic_map *isl_basic_map_apply_domain(7872 __isl_take isl_basic_map *bmap1,7873 __isl_take isl_basic_map *bmap2);7874 __isl_give isl_basic_map *isl_basic_map_apply_range(7875 __isl_take isl_basic_map *bmap1,7876 __isl_take isl_basic_map *bmap2);7877 __isl_give isl_map *isl_map_apply_domain(7878 __isl_take isl_map *map1,7879 __isl_take isl_map *map2);7880 __isl_give isl_map *isl_map_apply_range(7881 __isl_take isl_map *map1,7882 __isl_take isl_map *map2);7883 7884 #include <isl/union_map.h>7885 __isl_give isl_union_map *isl_union_map_apply_domain(7886 __isl_take isl_union_map *umap1,7887 __isl_take isl_union_map *umap2);7888 __isl_give isl_union_map *isl_union_map_apply_range(7889 __isl_take isl_union_map *umap1,7890 __isl_take isl_union_map *umap2);7891 7892 #include <isl/aff.h>7893 __isl_give isl_union_pw_multi_aff *7894 isl_union_pw_multi_aff_apply_union_pw_multi_aff(7895 __isl_take isl_union_pw_multi_aff *upma1,7896 __isl_take isl_union_pw_multi_aff *upma2);7897 __isl_give isl_union_pw_aff *7898 isl_multi_union_pw_aff_apply_aff(7899 __isl_take isl_multi_union_pw_aff *mupa,7900 __isl_take isl_aff *aff);7901 __isl_give isl_union_pw_aff *7902 isl_multi_union_pw_aff_apply_pw_aff(7903 __isl_take isl_multi_union_pw_aff *mupa,7904 __isl_take isl_pw_aff *pa);7905 __isl_give isl_multi_union_pw_aff *7906 isl_multi_union_pw_aff_apply_multi_aff(7907 __isl_take isl_multi_union_pw_aff *mupa,7908 __isl_take isl_multi_aff *ma);7909 __isl_give isl_multi_union_pw_aff *7910 isl_multi_union_pw_aff_apply_pw_multi_aff(7911 __isl_take isl_multi_union_pw_aff *mupa,7912 __isl_take isl_pw_multi_aff *pma);7913 7914The result of C<isl_multi_union_pw_aff_apply_aff> is defined7915over the shared domain of the elements of the input. The dimension is7916required to be greater than zero.7917The C<isl_multi_union_pw_aff> argument of7918C<isl_multi_union_pw_aff_apply_multi_aff> is allowed to be zero-dimensional,7919but only if the range of the C<isl_multi_aff> argument7920is also zero-dimensional.7921Similarly for C<isl_multi_union_pw_aff_apply_pw_multi_aff>.7922 7923 #include <isl/polynomial.h>7924 __isl_give isl_pw_qpolynomial_fold *7925 isl_set_apply_pw_qpolynomial_fold(7926 __isl_take isl_set *set,7927 __isl_take isl_pw_qpolynomial_fold *pwf,7928 isl_bool *tight);7929 __isl_give isl_pw_qpolynomial_fold *7930 isl_map_apply_pw_qpolynomial_fold(7931 __isl_take isl_map *map,7932 __isl_take isl_pw_qpolynomial_fold *pwf,7933 isl_bool *tight);7934 __isl_give isl_union_pw_qpolynomial_fold *7935 isl_union_set_apply_union_pw_qpolynomial_fold(7936 __isl_take isl_union_set *uset,7937 __isl_take isl_union_pw_qpolynomial_fold *upwf,7938 isl_bool *tight);7939 __isl_give isl_union_pw_qpolynomial_fold *7940 isl_union_map_apply_union_pw_qpolynomial_fold(7941 __isl_take isl_union_map *umap,7942 __isl_take isl_union_pw_qpolynomial_fold *upwf,7943 isl_bool *tight);7944 7945The functions taking a map7946compose the given map with the given piecewise quasipolynomial reduction.7947That is, compute a bound (of the same type as C<pwf> or C<upwf> itself)7948over all elements in the intersection of the range of the map7949and the domain of the piecewise quasipolynomial reduction7950as a function of an element in the domain of the map.7951The functions taking a set compute a bound over all elements in the7952intersection of the set and the domain of the7953piecewise quasipolynomial reduction.7954 7955=item * Preimage7956 7957 #include <isl/set.h>7958 __isl_give isl_basic_set *7959 isl_basic_set_preimage_multi_aff(7960 __isl_take isl_basic_set *bset,7961 __isl_take isl_multi_aff *ma);7962 __isl_give isl_set *isl_set_preimage_multi_aff(7963 __isl_take isl_set *set,7964 __isl_take isl_multi_aff *ma);7965 __isl_give isl_set *isl_set_preimage_pw_multi_aff(7966 __isl_take isl_set *set,7967 __isl_take isl_pw_multi_aff *pma);7968 __isl_give isl_set *isl_set_preimage_multi_pw_aff(7969 __isl_take isl_set *set,7970 __isl_take isl_multi_pw_aff *mpa);7971 7972 #include <isl/union_set.h>7973 __isl_give isl_union_set *7974 isl_union_set_preimage_multi_aff(7975 __isl_take isl_union_set *uset,7976 __isl_take isl_multi_aff *ma);7977 __isl_give isl_union_set *7978 isl_union_set_preimage_pw_multi_aff(7979 __isl_take isl_union_set *uset,7980 __isl_take isl_pw_multi_aff *pma);7981 __isl_give isl_union_set *7982 isl_union_set_preimage_union_pw_multi_aff(7983 __isl_take isl_union_set *uset,7984 __isl_take isl_union_pw_multi_aff *upma);7985 7986 #include <isl/map.h>7987 __isl_give isl_basic_map *7988 isl_basic_map_preimage_domain_multi_aff(7989 __isl_take isl_basic_map *bmap,7990 __isl_take isl_multi_aff *ma);7991 __isl_give isl_map *isl_map_preimage_domain_multi_aff(7992 __isl_take isl_map *map,7993 __isl_take isl_multi_aff *ma);7994 __isl_give isl_map *isl_map_preimage_range_multi_aff(7995 __isl_take isl_map *map,7996 __isl_take isl_multi_aff *ma);7997 __isl_give isl_map *7998 isl_map_preimage_domain_pw_multi_aff(7999 __isl_take isl_map *map,8000 __isl_take isl_pw_multi_aff *pma);8001 __isl_give isl_map *8002 isl_map_preimage_range_pw_multi_aff(8003 __isl_take isl_map *map,8004 __isl_take isl_pw_multi_aff *pma);8005 __isl_give isl_map *8006 isl_map_preimage_domain_multi_pw_aff(8007 __isl_take isl_map *map,8008 __isl_take isl_multi_pw_aff *mpa);8009 __isl_give isl_basic_map *8010 isl_basic_map_preimage_range_multi_aff(8011 __isl_take isl_basic_map *bmap,8012 __isl_take isl_multi_aff *ma);8013 8014 #include <isl/union_map.h>8015 __isl_give isl_union_map *8016 isl_union_map_preimage_domain_multi_aff(8017 __isl_take isl_union_map *umap,8018 __isl_take isl_multi_aff *ma);8019 __isl_give isl_union_map *8020 isl_union_map_preimage_range_multi_aff(8021 __isl_take isl_union_map *umap,8022 __isl_take isl_multi_aff *ma);8023 __isl_give isl_union_map *8024 isl_union_map_preimage_domain_pw_multi_aff(8025 __isl_take isl_union_map *umap,8026 __isl_take isl_pw_multi_aff *pma);8027 __isl_give isl_union_map *8028 isl_union_map_preimage_range_pw_multi_aff(8029 __isl_take isl_union_map *umap,8030 __isl_take isl_pw_multi_aff *pma);8031 __isl_give isl_union_map *8032 isl_union_map_preimage_domain_union_pw_multi_aff(8033 __isl_take isl_union_map *umap,8034 __isl_take isl_union_pw_multi_aff *upma);8035 __isl_give isl_union_map *8036 isl_union_map_preimage_range_union_pw_multi_aff(8037 __isl_take isl_union_map *umap,8038 __isl_take isl_union_pw_multi_aff *upma);8039 8040 #include <isl/aff.h>8041 __isl_give isl_pw_multi_aff *8042 isl_pw_multi_aff_preimage_domain_wrapped_domain_pw_multi_aff(8043 __isl_take isl_pw_multi_aff *pma1,8044 __isl_take isl_pw_multi_aff *pma2);8045 __isl_give isl_union_pw_multi_aff *8046 isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff(8047 __isl_take isl_union_pw_multi_aff *upma1,8048 __isl_take isl_union_pw_multi_aff *upma2);8049 8050These functions compute the preimage of the given set or map domain/range under8051the given function. In other words, the expression is plugged8052into the set description or into the domain/range of the map or function.8053 8054=item * Pullback8055 8056 #include <isl/aff.h>8057 __isl_give isl_aff *isl_aff_pullback_aff(8058 __isl_take isl_aff *aff1,8059 __isl_take isl_aff *aff2);8060 __isl_give isl_aff *isl_aff_pullback_multi_aff(8061 __isl_take isl_aff *aff,8062 __isl_take isl_multi_aff *ma);8063 __isl_give isl_pw_aff *isl_pw_aff_pullback_multi_aff(8064 __isl_take isl_pw_aff *pa,8065 __isl_take isl_multi_aff *ma);8066 __isl_give isl_pw_aff *isl_pw_aff_pullback_pw_multi_aff(8067 __isl_take isl_pw_aff *pa,8068 __isl_take isl_pw_multi_aff *pma);8069 __isl_give isl_pw_aff *isl_pw_aff_pullback_multi_pw_aff(8070 __isl_take isl_pw_aff *pa,8071 __isl_take isl_multi_pw_aff *mpa);8072 __isl_give isl_multi_aff *isl_multi_aff_pullback_multi_aff(8073 __isl_take isl_multi_aff *ma1,8074 __isl_take isl_multi_aff *ma2);8075 __isl_give isl_pw_multi_aff *8076 isl_pw_multi_aff_pullback_multi_aff(8077 __isl_take isl_pw_multi_aff *pma,8078 __isl_take isl_multi_aff *ma);8079 __isl_give isl_multi_pw_aff *8080 isl_multi_pw_aff_pullback_multi_aff(8081 __isl_take isl_multi_pw_aff *mpa,8082 __isl_take isl_multi_aff *ma);8083 __isl_give isl_pw_multi_aff *8084 isl_pw_multi_aff_pullback_pw_multi_aff(8085 __isl_take isl_pw_multi_aff *pma1,8086 __isl_take isl_pw_multi_aff *pma2);8087 __isl_give isl_multi_pw_aff *8088 isl_multi_pw_aff_pullback_pw_multi_aff(8089 __isl_take isl_multi_pw_aff *mpa,8090 __isl_take isl_pw_multi_aff *pma);8091 __isl_give isl_multi_pw_aff *8092 isl_multi_pw_aff_pullback_multi_pw_aff(8093 __isl_take isl_multi_pw_aff *mpa1,8094 __isl_take isl_multi_pw_aff *mpa2);8095 __isl_give isl_union_pw_aff *8096 isl_union_pw_aff_pullback_union_pw_multi_aff(8097 __isl_take isl_union_pw_aff *upa,8098 __isl_take isl_union_pw_multi_aff *upma);8099 __isl_give isl_union_pw_multi_aff *8100 isl_union_pw_multi_aff_pullback_union_pw_multi_aff(8101 __isl_take isl_union_pw_multi_aff *upma1,8102 __isl_take isl_union_pw_multi_aff *upma2);8103 __isl_give isl_multi_union_pw_aff *8104 isl_multi_union_pw_aff_pullback_union_pw_multi_aff(8105 __isl_take isl_multi_union_pw_aff *mupa,8106 __isl_take isl_union_pw_multi_aff *upma);8107 8108These functions precompose the first expression by the second function.8109In other words, the second function is plugged8110into the first expression.8111 8112=item * Locus8113 8114 #include <isl/aff.h>8115 __isl_give isl_basic_set *isl_aff_eq_basic_set(8116 __isl_take isl_aff *aff1,8117 __isl_take isl_aff *aff2);8118 __isl_give isl_set *isl_aff_eq_set(8119 __isl_take isl_aff *aff1,8120 __isl_take isl_aff *aff2);8121 __isl_give isl_set *isl_aff_ne_set(8122 __isl_take isl_aff *aff1,8123 __isl_take isl_aff *aff2);8124 __isl_give isl_basic_set *isl_aff_le_basic_set(8125 __isl_take isl_aff *aff1,8126 __isl_take isl_aff *aff2);8127 __isl_give isl_set *isl_aff_le_set(8128 __isl_take isl_aff *aff1,8129 __isl_take isl_aff *aff2);8130 __isl_give isl_basic_set *isl_aff_lt_basic_set(8131 __isl_take isl_aff *aff1,8132 __isl_take isl_aff *aff2);8133 __isl_give isl_set *isl_aff_lt_set(8134 __isl_take isl_aff *aff1,8135 __isl_take isl_aff *aff2);8136 __isl_give isl_basic_set *isl_aff_ge_basic_set(8137 __isl_take isl_aff *aff1,8138 __isl_take isl_aff *aff2);8139 __isl_give isl_set *isl_aff_ge_set(8140 __isl_take isl_aff *aff1,8141 __isl_take isl_aff *aff2);8142 __isl_give isl_basic_set *isl_aff_gt_basic_set(8143 __isl_take isl_aff *aff1,8144 __isl_take isl_aff *aff2);8145 __isl_give isl_set *isl_aff_gt_set(8146 __isl_take isl_aff *aff1,8147 __isl_take isl_aff *aff2);8148 __isl_give isl_set *isl_pw_aff_eq_set(8149 __isl_take isl_pw_aff *pwaff1,8150 __isl_take isl_pw_aff *pwaff2);8151 __isl_give isl_set *isl_pw_aff_ne_set(8152 __isl_take isl_pw_aff *pwaff1,8153 __isl_take isl_pw_aff *pwaff2);8154 __isl_give isl_set *isl_pw_aff_le_set(8155 __isl_take isl_pw_aff *pwaff1,8156 __isl_take isl_pw_aff *pwaff2);8157 __isl_give isl_set *isl_pw_aff_lt_set(8158 __isl_take isl_pw_aff *pwaff1,8159 __isl_take isl_pw_aff *pwaff2);8160 __isl_give isl_set *isl_pw_aff_ge_set(8161 __isl_take isl_pw_aff *pwaff1,8162 __isl_take isl_pw_aff *pwaff2);8163 __isl_give isl_set *isl_pw_aff_gt_set(8164 __isl_take isl_pw_aff *pwaff1,8165 __isl_take isl_pw_aff *pwaff2);8166 8167 __isl_give isl_set *isl_multi_aff_lex_le_set(8168 __isl_take isl_multi_aff *ma1,8169 __isl_take isl_multi_aff *ma2);8170 __isl_give isl_set *isl_multi_aff_lex_lt_set(8171 __isl_take isl_multi_aff *ma1,8172 __isl_take isl_multi_aff *ma2);8173 __isl_give isl_set *isl_multi_aff_lex_ge_set(8174 __isl_take isl_multi_aff *ma1,8175 __isl_take isl_multi_aff *ma2);8176 __isl_give isl_set *isl_multi_aff_lex_gt_set(8177 __isl_take isl_multi_aff *ma1,8178 __isl_take isl_multi_aff *ma2);8179 8180 __isl_give isl_set *isl_pw_aff_list_eq_set(8181 __isl_take isl_pw_aff_list *list1,8182 __isl_take isl_pw_aff_list *list2);8183 __isl_give isl_set *isl_pw_aff_list_ne_set(8184 __isl_take isl_pw_aff_list *list1,8185 __isl_take isl_pw_aff_list *list2);8186 __isl_give isl_set *isl_pw_aff_list_le_set(8187 __isl_take isl_pw_aff_list *list1,8188 __isl_take isl_pw_aff_list *list2);8189 __isl_give isl_set *isl_pw_aff_list_lt_set(8190 __isl_take isl_pw_aff_list *list1,8191 __isl_take isl_pw_aff_list *list2);8192 __isl_give isl_set *isl_pw_aff_list_ge_set(8193 __isl_take isl_pw_aff_list *list1,8194 __isl_take isl_pw_aff_list *list2);8195 __isl_give isl_set *isl_pw_aff_list_gt_set(8196 __isl_take isl_pw_aff_list *list1,8197 __isl_take isl_pw_aff_list *list2);8198 8199The function C<isl_aff_ge_basic_set> returns a basic set8200containing those elements in the shared space8201of C<aff1> and C<aff2> where C<aff1> is greater than or equal to C<aff2>.8202The function C<isl_pw_aff_ge_set> returns a set8203containing those elements in the shared domain8204of C<pwaff1> and C<pwaff2> where C<pwaff1> is8205greater than or equal to C<pwaff2>.8206The function C<isl_multi_aff_lex_le_set> returns a set8207containing those elements in the shared domain space8208where C<ma1> is lexicographically smaller than or8209equal to C<ma2>.8210The functions operating on C<isl_pw_aff_list> apply the corresponding8211C<isl_pw_aff> function to each pair of elements in the two lists.8212 8213 #include <isl/aff.h>8214 __isl_give isl_map *isl_pw_aff_eq_map(8215 __isl_take isl_pw_aff *pa1,8216 __isl_take isl_pw_aff *pa2);8217 __isl_give isl_map *isl_pw_aff_le_map(8218 __isl_take isl_pw_aff *pa1,8219 __isl_take isl_pw_aff *pa2);8220 __isl_give isl_map *isl_pw_aff_lt_map(8221 __isl_take isl_pw_aff *pa1,8222 __isl_take isl_pw_aff *pa2);8223 __isl_give isl_map *isl_pw_aff_ge_map(8224 __isl_take isl_pw_aff *pa1,8225 __isl_take isl_pw_aff *pa2);8226 __isl_give isl_map *isl_pw_aff_gt_map(8227 __isl_take isl_pw_aff *pa1,8228 __isl_take isl_pw_aff *pa2);8229 8230 __isl_give isl_map *isl_multi_pw_aff_eq_map(8231 __isl_take isl_multi_pw_aff *mpa1,8232 __isl_take isl_multi_pw_aff *mpa2);8233 __isl_give isl_map *isl_multi_pw_aff_lex_le_map(8234 __isl_take isl_multi_pw_aff *mpa1,8235 __isl_take isl_multi_pw_aff *mpa2);8236 __isl_give isl_map *isl_multi_pw_aff_lex_lt_map(8237 __isl_take isl_multi_pw_aff *mpa1,8238 __isl_take isl_multi_pw_aff *mpa2);8239 __isl_give isl_map *isl_multi_pw_aff_lex_ge_map(8240 __isl_take isl_multi_pw_aff *mpa1,8241 __isl_take isl_multi_pw_aff *mpa2);8242 __isl_give isl_map *isl_multi_pw_aff_lex_gt_map(8243 __isl_take isl_multi_pw_aff *mpa1,8244 __isl_take isl_multi_pw_aff *mpa2);8245 8246These functions return a map between domain elements of the arguments8247where the function values satisfy the given relation.8248 8249 #include <isl/map.h>8250 __isl_give isl_map *isl_map_eq_at_multi_pw_aff(8251 __isl_take isl_map *map,8252 __isl_take isl_multi_pw_aff *mpa);8253 __isl_give isl_map *isl_map_lex_lt_at_multi_pw_aff(8254 __isl_take isl_map *map,8255 __isl_take isl_multi_pw_aff *mpa);8256 __isl_give isl_map *isl_map_lex_le_at_multi_pw_aff(8257 __isl_take isl_map *map,8258 __isl_take isl_multi_pw_aff *mpa);8259 __isl_give isl_map *isl_map_lex_gt_at_multi_pw_aff(8260 __isl_take isl_map *map,8261 __isl_take isl_multi_pw_aff *mpa);8262 __isl_give isl_map *isl_map_lex_ge_at_multi_pw_aff(8263 __isl_take isl_map *map,8264 __isl_take isl_multi_pw_aff *mpa);8265 8266 #include <isl/union_map.h>8267 __isl_give isl_union_map *8268 isl_union_map_eq_at_multi_union_pw_aff(8269 __isl_take isl_union_map *umap,8270 __isl_take isl_multi_union_pw_aff *mupa);8271 __isl_give isl_union_map *8272 isl_union_map_lex_lt_at_multi_union_pw_aff(8273 __isl_take isl_union_map *umap,8274 __isl_take isl_multi_union_pw_aff *mupa);8275 __isl_give isl_union_map *8276 isl_union_map_lex_le_at_multi_union_pw_aff(8277 __isl_take isl_union_map *umap,8278 __isl_take isl_multi_union_pw_aff *mupa);8279 __isl_give isl_union_map *8280 isl_union_map_lex_gt_at_multi_union_pw_aff(8281 __isl_take isl_union_map *umap,8282 __isl_take isl_multi_union_pw_aff *mupa);8283 __isl_give isl_union_map *8284 isl_union_map_lex_ge_at_multi_union_pw_aff(8285 __isl_take isl_union_map *umap,8286 __isl_take isl_multi_union_pw_aff *mupa);8287 8288These functions select the subset of elements in the union map8289that have an equal or lexicographically smaller or greater function value.8290 8291=item * Cartesian Product8292 8293 #include <isl/space.h>8294 __isl_give isl_space *isl_space_product(8295 __isl_take isl_space *space1,8296 __isl_take isl_space *space2);8297 __isl_give isl_space *isl_space_domain_product(8298 __isl_take isl_space *space1,8299 __isl_take isl_space *space2);8300 __isl_give isl_space *isl_space_range_product(8301 __isl_take isl_space *space1,8302 __isl_take isl_space *space2);8303 8304The functions8305C<isl_space_product>, C<isl_space_domain_product>8306and C<isl_space_range_product> take pairs or relation spaces and8307produce a single relations space, where either the domain, the range8308or both domain and range are wrapped spaces of relations between8309the domains and/or ranges of the input spaces.8310If the product is only constructed over the domain or the range8311then the ranges or the domains of the inputs should be the same.8312The function C<isl_space_product> also accepts a pair of set spaces,8313in which case it returns a wrapped space of a relation between the8314two input spaces.8315 8316 #include <isl/set.h>8317 __isl_give isl_set *isl_set_product(8318 __isl_take isl_set *set1,8319 __isl_take isl_set *set2);8320 8321 #include <isl/map.h>8322 __isl_give isl_basic_map *isl_basic_map_domain_product(8323 __isl_take isl_basic_map *bmap1,8324 __isl_take isl_basic_map *bmap2);8325 __isl_give isl_basic_map *isl_basic_map_range_product(8326 __isl_take isl_basic_map *bmap1,8327 __isl_take isl_basic_map *bmap2);8328 __isl_give isl_basic_map *isl_basic_map_product(8329 __isl_take isl_basic_map *bmap1,8330 __isl_take isl_basic_map *bmap2);8331 __isl_give isl_map *isl_map_domain_product(8332 __isl_take isl_map *map1,8333 __isl_take isl_map *map2);8334 __isl_give isl_map *isl_map_range_product(8335 __isl_take isl_map *map1,8336 __isl_take isl_map *map2);8337 __isl_give isl_map *isl_map_product(8338 __isl_take isl_map *map1,8339 __isl_take isl_map *map2);8340 8341 #include <isl/union_set.h>8342 __isl_give isl_union_set *isl_union_set_product(8343 __isl_take isl_union_set *uset1,8344 __isl_take isl_union_set *uset2);8345 8346 #include <isl/union_map.h>8347 __isl_give isl_union_map *isl_union_map_domain_product(8348 __isl_take isl_union_map *umap1,8349 __isl_take isl_union_map *umap2);8350 __isl_give isl_union_map *isl_union_map_range_product(8351 __isl_take isl_union_map *umap1,8352 __isl_take isl_union_map *umap2);8353 __isl_give isl_union_map *isl_union_map_product(8354 __isl_take isl_union_map *umap1,8355 __isl_take isl_union_map *umap2);8356 8357 #include <isl/id.h>8358 __isl_give isl_multi_id *isl_multi_id_range_product(8359 __isl_take isl_multi_id *mi1,8360 __isl_take isl_multi_id *mi2);8361 8362 #include <isl/val.h>8363 __isl_give isl_multi_val *isl_multi_val_range_product(8364 __isl_take isl_multi_val *mv1,8365 __isl_take isl_multi_val *mv2);8366 __isl_give isl_multi_val *isl_multi_val_product(8367 __isl_take isl_multi_val *mv1,8368 __isl_take isl_multi_val *mv2);8369 8370 #include <isl/aff.h>8371 __isl_give isl_multi_aff *isl_multi_aff_range_product(8372 __isl_take isl_multi_aff *ma1,8373 __isl_take isl_multi_aff *ma2);8374 __isl_give isl_multi_aff *isl_multi_aff_product(8375 __isl_take isl_multi_aff *ma1,8376 __isl_take isl_multi_aff *ma2);8377 __isl_give isl_multi_pw_aff *8378 isl_multi_pw_aff_range_product(8379 __isl_take isl_multi_pw_aff *mpa1,8380 __isl_take isl_multi_pw_aff *mpa2);8381 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_product(8382 __isl_take isl_multi_pw_aff *mpa1,8383 __isl_take isl_multi_pw_aff *mpa2);8384 __isl_give isl_pw_multi_aff *8385 isl_pw_multi_aff_range_product(8386 __isl_take isl_pw_multi_aff *pma1,8387 __isl_take isl_pw_multi_aff *pma2);8388 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_product(8389 __isl_take isl_pw_multi_aff *pma1,8390 __isl_take isl_pw_multi_aff *pma2);8391 __isl_give isl_union_pw_multi_aff *8392 isl_union_pw_multi_aff_range_product(8393 __isl_take isl_union_pw_multi_aff *upma1,8394 __isl_take isl_union_pw_multi_aff *upma2);8395 __isl_give isl_multi_union_pw_aff *8396 isl_multi_union_pw_aff_range_product(8397 __isl_take isl_multi_union_pw_aff *mupa1,8398 __isl_take isl_multi_union_pw_aff *mupa2);8399 8400The above functions compute the cross product of the given8401sets, relations or functions. The domains and ranges of the results8402are wrapped maps between domains and ranges of the inputs.8403To obtain a ``flat'' product, use the following functions8404instead.8405 8406 #include <isl/set.h>8407 __isl_give isl_basic_set *isl_basic_set_flat_product(8408 __isl_take isl_basic_set *bset1,8409 __isl_take isl_basic_set *bset2);8410 __isl_give isl_set *isl_set_flat_product(8411 __isl_take isl_set *set1,8412 __isl_take isl_set *set2);8413 8414 #include <isl/map.h>8415 __isl_give isl_basic_map *isl_basic_map_flat_range_product(8416 __isl_take isl_basic_map *bmap1,8417 __isl_take isl_basic_map *bmap2);8418 __isl_give isl_map *isl_map_flat_domain_product(8419 __isl_take isl_map *map1,8420 __isl_take isl_map *map2);8421 __isl_give isl_map *isl_map_flat_range_product(8422 __isl_take isl_map *map1,8423 __isl_take isl_map *map2);8424 __isl_give isl_basic_map *isl_basic_map_flat_product(8425 __isl_take isl_basic_map *bmap1,8426 __isl_take isl_basic_map *bmap2);8427 __isl_give isl_map *isl_map_flat_product(8428 __isl_take isl_map *map1,8429 __isl_take isl_map *map2);8430 8431 #include <isl/union_map.h>8432 __isl_give isl_union_map *8433 isl_union_map_flat_domain_product(8434 __isl_take isl_union_map *umap1,8435 __isl_take isl_union_map *umap2);8436 __isl_give isl_union_map *8437 isl_union_map_flat_range_product(8438 __isl_take isl_union_map *umap1,8439 __isl_take isl_union_map *umap2);8440 8441 #include <isl/id.h>8442 __isl_give isl_multi_id *8443 isl_multi_id_flat_range_product(8444 __isl_take isl_multi_id *mi1,8445 __isl_take isl_multi_id *mi2);8446 8447 #include <isl/val.h>8448 __isl_give isl_multi_val *isl_multi_val_flat_range_product(8449 __isl_take isl_multi_val *mv1,8450 __isl_take isl_multi_val *mv2);8451 8452 #include <isl/aff.h>8453 __isl_give isl_multi_aff *isl_multi_aff_flat_range_product(8454 __isl_take isl_multi_aff *ma1,8455 __isl_take isl_multi_aff *ma2);8456 __isl_give isl_pw_multi_aff *8457 isl_pw_multi_aff_flat_range_product(8458 __isl_take isl_pw_multi_aff *pma1,8459 __isl_take isl_pw_multi_aff *pma2);8460 __isl_give isl_multi_pw_aff *8461 isl_multi_pw_aff_flat_range_product(8462 __isl_take isl_multi_pw_aff *mpa1,8463 __isl_take isl_multi_pw_aff *mpa2);8464 __isl_give isl_union_pw_multi_aff *8465 isl_union_pw_multi_aff_flat_range_product(8466 __isl_take isl_union_pw_multi_aff *upma1,8467 __isl_take isl_union_pw_multi_aff *upma2);8468 __isl_give isl_multi_union_pw_aff *8469 isl_multi_union_pw_aff_flat_range_product(8470 __isl_take isl_multi_union_pw_aff *mupa1,8471 __isl_take isl_multi_union_pw_aff *mupa2);8472 8473 #include <isl/space.h>8474 __isl_give isl_space *isl_space_factor_domain(8475 __isl_take isl_space *space);8476 __isl_give isl_space *isl_space_factor_range(8477 __isl_take isl_space *space);8478 __isl_give isl_space *isl_space_domain_factor_domain(8479 __isl_take isl_space *space);8480 __isl_give isl_space *isl_space_domain_factor_range(8481 __isl_take isl_space *space);8482 __isl_give isl_space *isl_space_range_factor_domain(8483 __isl_take isl_space *space);8484 __isl_give isl_space *isl_space_range_factor_range(8485 __isl_take isl_space *space);8486 8487The functions C<isl_space_range_factor_domain> and8488C<isl_space_range_factor_range> extract the two arguments from8489the result of a call to C<isl_space_range_product>.8490 8491The arguments of a call to a product can be extracted8492from the result using the following functions.8493 8494 #include <isl/map.h>8495 __isl_give isl_map *isl_map_factor_domain(8496 __isl_take isl_map *map);8497 __isl_give isl_map *isl_map_factor_range(8498 __isl_take isl_map *map);8499 __isl_give isl_map *isl_map_domain_factor_domain(8500 __isl_take isl_map *map);8501 __isl_give isl_map *isl_map_domain_factor_range(8502 __isl_take isl_map *map);8503 __isl_give isl_map *isl_map_range_factor_domain(8504 __isl_take isl_map *map);8505 __isl_give isl_map *isl_map_range_factor_range(8506 __isl_take isl_map *map);8507 8508 #include <isl/union_map.h>8509 __isl_give isl_union_map *isl_union_map_factor_domain(8510 __isl_take isl_union_map *umap);8511 __isl_give isl_union_map *isl_union_map_factor_range(8512 __isl_take isl_union_map *umap);8513 __isl_give isl_union_map *8514 isl_union_map_domain_factor_domain(8515 __isl_take isl_union_map *umap);8516 __isl_give isl_union_map *8517 isl_union_map_domain_factor_range(8518 __isl_take isl_union_map *umap);8519 __isl_give isl_union_map *8520 isl_union_map_range_factor_domain(8521 __isl_take isl_union_map *umap);8522 __isl_give isl_union_map *8523 isl_union_map_range_factor_range(8524 __isl_take isl_union_map *umap);8525 8526 #include <isl/id.h>8527 __isl_give isl_multi_id *isl_multi_id_factor_range(8528 __isl_take isl_multi_id *mi);8529 __isl_give isl_multi_id *8530 isl_multi_id_range_factor_domain(8531 __isl_take isl_multi_id *mi);8532 __isl_give isl_multi_id *8533 isl_multi_id_range_factor_range(8534 __isl_take isl_multi_id *mi);8535 8536 #include <isl/val.h>8537 __isl_give isl_multi_val *isl_multi_val_factor_range(8538 __isl_take isl_multi_val *mv);8539 __isl_give isl_multi_val *8540 isl_multi_val_range_factor_domain(8541 __isl_take isl_multi_val *mv);8542 __isl_give isl_multi_val *8543 isl_multi_val_range_factor_range(8544 __isl_take isl_multi_val *mv);8545 8546 #include <isl/aff.h>8547 __isl_give isl_multi_aff *isl_multi_aff_factor_range(8548 __isl_take isl_multi_aff *ma);8549 __isl_give isl_multi_aff *8550 isl_multi_aff_range_factor_domain(8551 __isl_take isl_multi_aff *ma);8552 __isl_give isl_multi_aff *8553 isl_multi_aff_range_factor_range(8554 __isl_take isl_multi_aff *ma);8555 __isl_give isl_multi_pw_aff *8556 isl_multi_pw_aff_factor_range(8557 __isl_take isl_multi_pw_aff *mpa);8558 __isl_give isl_multi_pw_aff *8559 isl_multi_pw_aff_range_factor_domain(8560 __isl_take isl_multi_pw_aff *mpa);8561 __isl_give isl_multi_pw_aff *8562 isl_multi_pw_aff_range_factor_range(8563 __isl_take isl_multi_pw_aff *mpa);8564 __isl_give isl_pw_multi_aff *8565 isl_pw_multi_aff_range_factor_domain(8566 __isl_take isl_pw_multi_aff *pma);8567 __isl_give isl_pw_multi_aff *8568 isl_pw_multi_aff_range_factor_range(8569 __isl_take isl_pw_multi_aff *pma);8570 __isl_give isl_union_pw_multi_aff *8571 isl_union_pw_multi_aff_range_factor_domain(8572 __isl_take isl_union_pw_multi_aff *upma);8573 __isl_give isl_union_pw_multi_aff *8574 isl_union_pw_multi_aff_range_factor_range(8575 __isl_take isl_union_pw_multi_aff *upma);8576 __isl_give isl_multi_union_pw_aff *8577 isl_multi_union_pw_aff_factor_range(8578 __isl_take isl_multi_union_pw_aff *mupa);8579 __isl_give isl_multi_union_pw_aff *8580 isl_multi_union_pw_aff_range_factor_domain(8581 __isl_take isl_multi_union_pw_aff *mupa);8582 __isl_give isl_multi_union_pw_aff *8583 isl_multi_union_pw_aff_range_factor_range(8584 __isl_take isl_multi_union_pw_aff *mupa);8585 8586The splice functions are a generalization of the flat product functions,8587where the second argument may be inserted at any position inside8588the first argument rather than being placed at the end.8589The functions C<isl_multi_val_factor_range>,8590C<isl_multi_aff_factor_range>,8591C<isl_multi_pw_aff_factor_range> and8592C<isl_multi_union_pw_aff_factor_range>8593take functions that live in a set space.8594 8595 #include <isl/id.h>8596 __isl_give isl_multi_id *isl_multi_id_range_splice(8597 __isl_take isl_multi_id *mi1, unsigned pos,8598 __isl_take isl_multi_id *mi2);8599 8600 #include <isl/val.h>8601 __isl_give isl_multi_val *isl_multi_val_range_splice(8602 __isl_take isl_multi_val *mv1, unsigned pos,8603 __isl_take isl_multi_val *mv2);8604 8605 #include <isl/aff.h>8606 __isl_give isl_multi_aff *isl_multi_aff_range_splice(8607 __isl_take isl_multi_aff *ma1, unsigned pos,8608 __isl_take isl_multi_aff *ma2);8609 __isl_give isl_multi_aff *isl_multi_aff_splice(8610 __isl_take isl_multi_aff *ma1,8611 unsigned in_pos, unsigned out_pos,8612 __isl_take isl_multi_aff *ma2);8613 __isl_give isl_multi_pw_aff *8614 isl_multi_pw_aff_range_splice(8615 __isl_take isl_multi_pw_aff *mpa1, unsigned pos,8616 __isl_take isl_multi_pw_aff *mpa2);8617 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_splice(8618 __isl_take isl_multi_pw_aff *mpa1,8619 unsigned in_pos, unsigned out_pos,8620 __isl_take isl_multi_pw_aff *mpa2);8621 __isl_give isl_multi_union_pw_aff *8622 isl_multi_union_pw_aff_range_splice(8623 __isl_take isl_multi_union_pw_aff *mupa1,8624 unsigned pos,8625 __isl_take isl_multi_union_pw_aff *mupa2);8626 8627=item * Simplification8628 8629When applied to a set or relation,8630the gist operation returns a set or relation that has the8631same intersection with the context as the input set or relation.8632Any implicit equality in the intersection is made explicit in the result,8633while all inequalities that are redundant with respect to the intersection8634are removed.8635In case of union sets and relations, the gist operation is performed8636per space.8637 8638When applied to a function,8639the gist operation applies the set gist operation to each of8640the cells in the domain of the input piecewise expression.8641The context is also exploited8642to simplify the expression associated to each cell.8643 8644 #include <isl/set.h>8645 __isl_give isl_basic_set *isl_basic_set_gist(8646 __isl_take isl_basic_set *bset,8647 __isl_take isl_basic_set *context);8648 __isl_give isl_set *isl_set_gist(__isl_take isl_set *set,8649 __isl_take isl_set *context);8650 __isl_give isl_set *isl_set_gist_params(8651 __isl_take isl_set *set,8652 __isl_take isl_set *context);8653 8654 #include <isl/map.h>8655 __isl_give isl_basic_map *isl_basic_map_gist(8656 __isl_take isl_basic_map *bmap,8657 __isl_take isl_basic_map *context);8658 __isl_give isl_basic_map *isl_basic_map_gist_domain(8659 __isl_take isl_basic_map *bmap,8660 __isl_take isl_basic_set *context);8661 __isl_give isl_map *isl_map_gist(__isl_take isl_map *map,8662 __isl_take isl_map *context);8663 __isl_give isl_map *isl_map_gist_params(8664 __isl_take isl_map *map,8665 __isl_take isl_set *context);8666 __isl_give isl_map *isl_map_gist_domain(8667 __isl_take isl_map *map,8668 __isl_take isl_set *context);8669 __isl_give isl_map *isl_map_gist_range(8670 __isl_take isl_map *map,8671 __isl_take isl_set *context);8672 8673 #include <isl/union_set.h>8674 __isl_give isl_union_set *isl_union_set_gist(8675 __isl_take isl_union_set *uset,8676 __isl_take isl_union_set *context);8677 __isl_give isl_union_set *isl_union_set_gist_params(8678 __isl_take isl_union_set *uset,8679 __isl_take isl_set *set);8680 8681 #include <isl/union_map.h>8682 __isl_give isl_union_map *isl_union_map_gist(8683 __isl_take isl_union_map *umap,8684 __isl_take isl_union_map *context);8685 __isl_give isl_union_map *isl_union_map_gist_params(8686 __isl_take isl_union_map *umap,8687 __isl_take isl_set *set);8688 __isl_give isl_union_map *isl_union_map_gist_domain(8689 __isl_take isl_union_map *umap,8690 __isl_take isl_union_set *uset);8691 __isl_give isl_union_map *isl_union_map_gist_range(8692 __isl_take isl_union_map *umap,8693 __isl_take isl_union_set *uset);8694 8695 #include <isl/aff.h>8696 __isl_give isl_aff *isl_aff_gist_params(8697 __isl_take isl_aff *aff,8698 __isl_take isl_set *context);8699 __isl_give isl_aff *isl_aff_gist(__isl_take isl_aff *aff,8700 __isl_take isl_set *context);8701 __isl_give isl_multi_aff *isl_multi_aff_gist_params(8702 __isl_take isl_multi_aff *maff,8703 __isl_take isl_set *context);8704 __isl_give isl_multi_aff *isl_multi_aff_gist(8705 __isl_take isl_multi_aff *maff,8706 __isl_take isl_set *context);8707 __isl_give isl_pw_aff *isl_pw_aff_gist_params(8708 __isl_take isl_pw_aff *pwaff,8709 __isl_take isl_set *context);8710 __isl_give isl_pw_aff *isl_pw_aff_gist(8711 __isl_take isl_pw_aff *pwaff,8712 __isl_take isl_set *context);8713 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist_params(8714 __isl_take isl_pw_multi_aff *pma,8715 __isl_take isl_set *set);8716 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist(8717 __isl_take isl_pw_multi_aff *pma,8718 __isl_take isl_set *set);8719 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_gist_params(8720 __isl_take isl_multi_pw_aff *mpa,8721 __isl_take isl_set *set);8722 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_gist(8723 __isl_take isl_multi_pw_aff *mpa,8724 __isl_take isl_set *set);8725 __isl_give isl_union_pw_aff *isl_union_pw_aff_gist(8726 __isl_take isl_union_pw_aff *upa,8727 __isl_take isl_union_set *context);8728 __isl_give isl_union_pw_aff *isl_union_pw_aff_gist_params(8729 __isl_take isl_union_pw_aff *upa,8730 __isl_take isl_set *context);8731 __isl_give isl_union_pw_multi_aff *8732 isl_union_pw_multi_aff_gist_params(8733 __isl_take isl_union_pw_multi_aff *upma,8734 __isl_take isl_set *context);8735 __isl_give isl_union_pw_multi_aff *8736 isl_union_pw_multi_aff_gist(8737 __isl_take isl_union_pw_multi_aff *upma,8738 __isl_take isl_union_set *context);8739 __isl_give isl_multi_union_pw_aff *8740 isl_multi_union_pw_aff_gist_params(8741 __isl_take isl_multi_union_pw_aff *mupa,8742 __isl_take isl_set *context);8743 __isl_give isl_multi_union_pw_aff *8744 isl_multi_union_pw_aff_gist(8745 __isl_take isl_multi_union_pw_aff *mupa,8746 __isl_take isl_union_set *context);8747 8748 #include <isl/polynomial.h>8749 __isl_give isl_qpolynomial *isl_qpolynomial_gist_params(8750 __isl_take isl_qpolynomial *qp,8751 __isl_take isl_set *context);8752 __isl_give isl_qpolynomial *isl_qpolynomial_gist(8753 __isl_take isl_qpolynomial *qp,8754 __isl_take isl_set *context);8755 __isl_give isl_qpolynomial_fold *8756 isl_qpolynomial_fold_gist_params(8757 __isl_take isl_qpolynomial_fold *fold,8758 __isl_take isl_set *context);8759 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist(8760 __isl_take isl_qpolynomial_fold *fold,8761 __isl_take isl_set *context);8762 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist_params(8763 __isl_take isl_pw_qpolynomial *pwqp,8764 __isl_take isl_set *context);8765 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist(8766 __isl_take isl_pw_qpolynomial *pwqp,8767 __isl_take isl_set *context);8768 __isl_give isl_pw_qpolynomial_fold *8769 isl_pw_qpolynomial_fold_gist(8770 __isl_take isl_pw_qpolynomial_fold *pwf,8771 __isl_take isl_set *context);8772 __isl_give isl_pw_qpolynomial_fold *8773 isl_pw_qpolynomial_fold_gist_params(8774 __isl_take isl_pw_qpolynomial_fold *pwf,8775 __isl_take isl_set *context);8776 __isl_give isl_union_pw_qpolynomial *8777 isl_union_pw_qpolynomial_gist_params(8778 __isl_take isl_union_pw_qpolynomial *upwqp,8779 __isl_take isl_set *context);8780 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_gist(8781 __isl_take isl_union_pw_qpolynomial *upwqp,8782 __isl_take isl_union_set *context);8783 __isl_give isl_union_pw_qpolynomial_fold *8784 isl_union_pw_qpolynomial_fold_gist(8785 __isl_take isl_union_pw_qpolynomial_fold *upwf,8786 __isl_take isl_union_set *context);8787 __isl_give isl_union_pw_qpolynomial_fold *8788 isl_union_pw_qpolynomial_fold_gist_params(8789 __isl_take isl_union_pw_qpolynomial_fold *upwf,8790 __isl_take isl_set *context);8791 8792=item * Binary Arithmetic Operations8793 8794 #include <isl/set.h>8795 __isl_give isl_set *isl_set_sum(8796 __isl_take isl_set *set1,8797 __isl_take isl_set *set2);8798 #include <isl/map.h>8799 __isl_give isl_map *isl_map_sum(8800 __isl_take isl_map *map1,8801 __isl_take isl_map *map2);8802 8803C<isl_set_sum> computes the Minkowski sum of its two arguments,8804i.e., the set containing the sums of pairs of elements from8805C<set1> and C<set2>.8806The domain of the result of C<isl_map_sum> is the intersection8807of the domains of its two arguments. The corresponding range8808elements are the sums of the corresponding range elements8809in the two arguments.8810 8811 #include <isl/val.h>8812 __isl_give isl_multi_val *isl_multi_val_add(8813 __isl_take isl_multi_val *mv1,8814 __isl_take isl_multi_val *mv2);8815 __isl_give isl_multi_val *isl_multi_val_sub(8816 __isl_take isl_multi_val *mv1,8817 __isl_take isl_multi_val *mv2);8818 __isl_give isl_multi_val *isl_multi_val_min(8819 __isl_take isl_multi_val *mv1,8820 __isl_take isl_multi_val *mv2);8821 __isl_give isl_multi_val *isl_multi_val_max(8822 __isl_take isl_multi_val *mv1,8823 __isl_take isl_multi_val *mv2);8824 8825 #include <isl/aff.h>8826 __isl_give isl_aff *isl_aff_add(8827 __isl_take isl_aff *aff1,8828 __isl_take isl_aff *aff2);8829 __isl_give isl_multi_aff *isl_multi_aff_add(8830 __isl_take isl_multi_aff *maff1,8831 __isl_take isl_multi_aff *maff2);8832 __isl_give isl_pw_aff *isl_pw_aff_add(8833 __isl_take isl_pw_aff *pwaff1,8834 __isl_take isl_pw_aff *pwaff2);8835 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_add(8836 __isl_take isl_multi_pw_aff *mpa1,8837 __isl_take isl_multi_pw_aff *mpa2);8838 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_add(8839 __isl_take isl_pw_multi_aff *pma1,8840 __isl_take isl_pw_multi_aff *pma2);8841 __isl_give isl_union_pw_aff *isl_union_pw_aff_add(8842 __isl_take isl_union_pw_aff *upa1,8843 __isl_take isl_union_pw_aff *upa2);8844 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_add(8845 __isl_take isl_union_pw_multi_aff *upma1,8846 __isl_take isl_union_pw_multi_aff *upma2);8847 __isl_give isl_multi_union_pw_aff *8848 isl_multi_union_pw_aff_add(8849 __isl_take isl_multi_union_pw_aff *mupa1,8850 __isl_take isl_multi_union_pw_aff *mupa2);8851 __isl_give isl_pw_aff *isl_pw_aff_add_constant_val(8852 __isl_take isl_pw_aff *pa,8853 __isl_take isl_val *v);8854 __isl_give isl_multi_aff *8855 isl_multi_aff_add_constant_val(8856 __isl_take isl_multi_aff *pa,8857 __isl_take isl_val *v);8858 __isl_give isl_pw_multi_aff *8859 isl_pw_multi_aff_add_constant_val(8860 __isl_take isl_pw_multi_aff *pma,8861 __isl_take isl_val *v);8862 __isl_give isl_pw_multi_aff *8863 isl_pw_multi_aff_add_constant_multi_val(8864 __isl_take isl_pw_multi_aff *pma,8865 __isl_take isl_multi_val *mv);8866 __isl_give isl_multi_pw_aff *8867 isl_multi_pw_aff_add_constant_val(8868 __isl_take isl_multi_pw_aff *mpa,8869 __isl_take isl_val *v);8870 __isl_give isl_multi_aff *8871 isl_multi_aff_add_constant_multi_val(8872 __isl_take isl_multi_aff *pa,8873 __isl_take isl_multi_val *mv);8874 __isl_give isl_multi_pw_aff *8875 isl_multi_pw_aff_add_constant_multi_val(8876 __isl_take isl_multi_pw_aff *mpa,8877 __isl_take isl_multi_val *mv);8878 __isl_give isl_pw_aff *isl_pw_aff_min(8879 __isl_take isl_pw_aff *pwaff1,8880 __isl_take isl_pw_aff *pwaff2);8881 __isl_give isl_pw_aff *isl_pw_aff_max(8882 __isl_take isl_pw_aff *pwaff1,8883 __isl_take isl_pw_aff *pwaff2);8884 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_min(8885 __isl_take isl_multi_pw_aff *mpa1,8886 __isl_take isl_multi_pw_aff *mpa2);8887 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_max(8888 __isl_take isl_multi_pw_aff *mpa1,8889 __isl_take isl_multi_pw_aff *mpa2);8890 __isl_give isl_aff *isl_aff_sub(8891 __isl_take isl_aff *aff1,8892 __isl_take isl_aff *aff2);8893 __isl_give isl_multi_aff *isl_multi_aff_sub(8894 __isl_take isl_multi_aff *ma1,8895 __isl_take isl_multi_aff *ma2);8896 __isl_give isl_pw_aff *isl_pw_aff_sub(8897 __isl_take isl_pw_aff *pwaff1,8898 __isl_take isl_pw_aff *pwaff2);8899 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_sub(8900 __isl_take isl_multi_pw_aff *mpa1,8901 __isl_take isl_multi_pw_aff *mpa2);8902 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_sub(8903 __isl_take isl_pw_multi_aff *pma1,8904 __isl_take isl_pw_multi_aff *pma2);8905 __isl_give isl_union_pw_aff *isl_union_pw_aff_sub(8906 __isl_take isl_union_pw_aff *upa1,8907 __isl_take isl_union_pw_aff *upa2);8908 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_sub(8909 __isl_take isl_union_pw_multi_aff *upma1,8910 __isl_take isl_union_pw_multi_aff *upma2);8911 __isl_give isl_multi_union_pw_aff *8912 isl_multi_union_pw_aff_sub(8913 __isl_take isl_multi_union_pw_aff *mupa1,8914 __isl_take isl_multi_union_pw_aff *mupa2);8915 8916C<isl_aff_sub> subtracts the second argument from the first.8917 8918 #include <isl/polynomial.h>8919 __isl_give isl_qpolynomial *isl_qpolynomial_add(8920 __isl_take isl_qpolynomial *qp1,8921 __isl_take isl_qpolynomial *qp2);8922 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add(8923 __isl_take isl_pw_qpolynomial *pwqp1,8924 __isl_take isl_pw_qpolynomial *pwqp2);8925 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add_disjoint(8926 __isl_take isl_pw_qpolynomial *pwqp1,8927 __isl_take isl_pw_qpolynomial *pwqp2);8928 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_add(8929 __isl_take isl_pw_qpolynomial_fold *pwf1,8930 __isl_take isl_pw_qpolynomial_fold *pwf2);8931 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add(8932 __isl_take isl_union_pw_qpolynomial *upwqp1,8933 __isl_take isl_union_pw_qpolynomial *upwqp2);8934 __isl_give isl_qpolynomial *isl_qpolynomial_sub(8935 __isl_take isl_qpolynomial *qp1,8936 __isl_take isl_qpolynomial *qp2);8937 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_sub(8938 __isl_take isl_pw_qpolynomial *pwqp1,8939 __isl_take isl_pw_qpolynomial *pwqp2);8940 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_sub(8941 __isl_take isl_union_pw_qpolynomial *upwqp1,8942 __isl_take isl_union_pw_qpolynomial *upwqp2);8943 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_fold(8944 __isl_take isl_pw_qpolynomial_fold *pwf1,8945 __isl_take isl_pw_qpolynomial_fold *pwf2);8946 __isl_give isl_union_pw_qpolynomial_fold *8947 isl_union_pw_qpolynomial_fold_fold(8948 __isl_take isl_union_pw_qpolynomial_fold *upwf1,8949 __isl_take isl_union_pw_qpolynomial_fold *upwf2);8950 8951 #include <isl/aff.h>8952 __isl_give isl_pw_aff *isl_pw_aff_union_add(8953 __isl_take isl_pw_aff *pwaff1,8954 __isl_take isl_pw_aff *pwaff2);8955 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_union_add(8956 __isl_take isl_multi_pw_aff *mpa1,8957 __isl_take isl_multi_pw_aff *mpa2);8958 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_add(8959 __isl_take isl_pw_multi_aff *pma1,8960 __isl_take isl_pw_multi_aff *pma2);8961 __isl_give isl_union_pw_aff *isl_union_pw_aff_union_add(8962 __isl_take isl_union_pw_aff *upa1,8963 __isl_take isl_union_pw_aff *upa2);8964 __isl_give isl_union_pw_multi_aff *8965 isl_union_pw_multi_aff_union_add(8966 __isl_take isl_union_pw_multi_aff *upma1,8967 __isl_take isl_union_pw_multi_aff *upma2);8968 __isl_give isl_multi_union_pw_aff *8969 isl_multi_union_pw_aff_union_add(8970 __isl_take isl_multi_union_pw_aff *mupa1,8971 __isl_take isl_multi_union_pw_aff *mupa2);8972 __isl_give isl_pw_aff *isl_pw_aff_union_min(8973 __isl_take isl_pw_aff *pwaff1,8974 __isl_take isl_pw_aff *pwaff2);8975 __isl_give isl_pw_aff *isl_pw_aff_union_max(8976 __isl_take isl_pw_aff *pwaff1,8977 __isl_take isl_pw_aff *pwaff2);8978 8979The function C<isl_pw_aff_union_max> computes a piecewise quasi-affine8980expression with a domain that is the union of those of C<pwaff1> and8981C<pwaff2> and such that on each cell, the quasi-affine expression is8982the maximum of those of C<pwaff1> and C<pwaff2>. If only one of8983C<pwaff1> or C<pwaff2> is defined on a given cell, then the8984associated expression is the defined one.8985This in contrast to the C<isl_pw_aff_max> function, which is8986only defined on the shared definition domain of the arguments.8987 8988 #include <isl/val.h>8989 __isl_give isl_multi_val *isl_multi_val_add_val(8990 __isl_take isl_multi_val *mv,8991 __isl_take isl_val *v);8992 __isl_give isl_multi_val *isl_multi_val_mod_val(8993 __isl_take isl_multi_val *mv,8994 __isl_take isl_val *v);8995 __isl_give isl_multi_val *isl_multi_val_scale_val(8996 __isl_take isl_multi_val *mv,8997 __isl_take isl_val *v);8998 __isl_give isl_multi_val *isl_multi_val_scale_down_val(8999 __isl_take isl_multi_val *mv,9000 __isl_take isl_val *v);9001 9002 #include <isl/aff.h>9003 __isl_give isl_aff *isl_aff_mod_val(__isl_take isl_aff *aff,9004 __isl_take isl_val *mod);9005 __isl_give isl_pw_aff *isl_pw_aff_mod_val(9006 __isl_take isl_pw_aff *pa,9007 __isl_take isl_val *mod);9008 __isl_give isl_union_pw_aff *isl_union_pw_aff_mod_val(9009 __isl_take isl_union_pw_aff *upa,9010 __isl_take isl_val *f);9011 __isl_give isl_aff *isl_aff_scale_val(__isl_take isl_aff *aff,9012 __isl_take isl_val *v);9013 __isl_give isl_multi_aff *isl_multi_aff_scale_val(9014 __isl_take isl_multi_aff *ma,9015 __isl_take isl_val *v);9016 __isl_give isl_pw_aff *isl_pw_aff_scale_val(9017 __isl_take isl_pw_aff *pa, __isl_take isl_val *v);9018 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_scale_val(9019 __isl_take isl_multi_pw_aff *mpa,9020 __isl_take isl_val *v);9021 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_val(9022 __isl_take isl_pw_multi_aff *pma,9023 __isl_take isl_val *v);9024 __isl_give isl_union_pw_aff *isl_union_pw_aff_scale_val(9025 __isl_take isl_union_pw_aff *upa,9026 __isl_take isl_val *f);9027 __isl_give isl_union_pw_multi_aff *9028 isl_union_pw_multi_aff_scale_val(9029 __isl_take isl_union_pw_multi_aff *upma,9030 __isl_take isl_val *val);9031 __isl_give isl_multi_union_pw_aff *9032 isl_multi_union_pw_aff_scale_val(9033 __isl_take isl_multi_union_pw_aff *mupa,9034 __isl_take isl_val *v);9035 __isl_give isl_aff *isl_aff_scale_down_ui(9036 __isl_take isl_aff *aff, unsigned f);9037 __isl_give isl_aff *isl_aff_scale_down_val(9038 __isl_take isl_aff *aff, __isl_take isl_val *v);9039 __isl_give isl_multi_aff *isl_multi_aff_scale_down_val(9040 __isl_take isl_multi_aff *ma,9041 __isl_take isl_val *v);9042 __isl_give isl_pw_aff *isl_pw_aff_scale_down_val(9043 __isl_take isl_pw_aff *pa,9044 __isl_take isl_val *f);9045 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_scale_down_val(9046 __isl_take isl_multi_pw_aff *mpa,9047 __isl_take isl_val *v);9048 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_down_val(9049 __isl_take isl_pw_multi_aff *pma,9050 __isl_take isl_val *v);9051 __isl_give isl_union_pw_aff *isl_union_pw_aff_scale_down_val(9052 __isl_take isl_union_pw_aff *upa,9053 __isl_take isl_val *v);9054 __isl_give isl_union_pw_multi_aff *9055 isl_union_pw_multi_aff_scale_down_val(9056 __isl_take isl_union_pw_multi_aff *upma,9057 __isl_take isl_val *val);9058 __isl_give isl_multi_union_pw_aff *9059 isl_multi_union_pw_aff_scale_down_val(9060 __isl_take isl_multi_union_pw_aff *mupa,9061 __isl_take isl_val *v);9062 9063 #include <isl/polynomial.h>9064 __isl_give isl_qpolynomial *isl_qpolynomial_scale_val(9065 __isl_take isl_qpolynomial *qp,9066 __isl_take isl_val *v);9067 __isl_give isl_qpolynomial_fold *9068 isl_qpolynomial_fold_scale_val(9069 __isl_take isl_qpolynomial_fold *fold,9070 __isl_take isl_val *v);9071 __isl_give isl_pw_qpolynomial *9072 isl_pw_qpolynomial_scale_val(9073 __isl_take isl_pw_qpolynomial *pwqp,9074 __isl_take isl_val *v);9075 __isl_give isl_pw_qpolynomial_fold *9076 isl_pw_qpolynomial_fold_scale_val(9077 __isl_take isl_pw_qpolynomial_fold *pwf,9078 __isl_take isl_val *v);9079 __isl_give isl_union_pw_qpolynomial *9080 isl_union_pw_qpolynomial_scale_val(9081 __isl_take isl_union_pw_qpolynomial *upwqp,9082 __isl_take isl_val *v);9083 __isl_give isl_union_pw_qpolynomial_fold *9084 isl_union_pw_qpolynomial_fold_scale_val(9085 __isl_take isl_union_pw_qpolynomial_fold *upwf,9086 __isl_take isl_val *v);9087 __isl_give isl_qpolynomial *9088 isl_qpolynomial_scale_down_val(9089 __isl_take isl_qpolynomial *qp,9090 __isl_take isl_val *v);9091 __isl_give isl_qpolynomial_fold *9092 isl_qpolynomial_fold_scale_down_val(9093 __isl_take isl_qpolynomial_fold *fold,9094 __isl_take isl_val *v);9095 __isl_give isl_pw_qpolynomial *9096 isl_pw_qpolynomial_scale_down_val(9097 __isl_take isl_pw_qpolynomial *pwqp,9098 __isl_take isl_val *v);9099 __isl_give isl_pw_qpolynomial_fold *9100 isl_pw_qpolynomial_fold_scale_down_val(9101 __isl_take isl_pw_qpolynomial_fold *pwf,9102 __isl_take isl_val *v);9103 __isl_give isl_union_pw_qpolynomial *9104 isl_union_pw_qpolynomial_scale_down_val(9105 __isl_take isl_union_pw_qpolynomial *upwqp,9106 __isl_take isl_val *v);9107 __isl_give isl_union_pw_qpolynomial_fold *9108 isl_union_pw_qpolynomial_fold_scale_down_val(9109 __isl_take isl_union_pw_qpolynomial_fold *upwf,9110 __isl_take isl_val *v);9111 9112 #include <isl/val.h>9113 __isl_give isl_multi_val *isl_multi_val_mod_multi_val(9114 __isl_take isl_multi_val *mv1,9115 __isl_take isl_multi_val *mv2);9116 __isl_give isl_multi_val *isl_multi_val_scale_multi_val(9117 __isl_take isl_multi_val *mv1,9118 __isl_take isl_multi_val *mv2);9119 __isl_give isl_multi_val *9120 isl_multi_val_scale_down_multi_val(9121 __isl_take isl_multi_val *mv1,9122 __isl_take isl_multi_val *mv2);9123 9124 #include <isl/aff.h>9125 __isl_give isl_multi_aff *isl_multi_aff_mod_multi_val(9126 __isl_take isl_multi_aff *ma,9127 __isl_take isl_multi_val *mv);9128 __isl_give isl_multi_union_pw_aff *9129 isl_multi_union_pw_aff_mod_multi_val(9130 __isl_take isl_multi_union_pw_aff *upma,9131 __isl_take isl_multi_val *mv);9132 __isl_give isl_multi_pw_aff *9133 isl_multi_pw_aff_mod_multi_val(9134 __isl_take isl_multi_pw_aff *mpa,9135 __isl_take isl_multi_val *mv);9136 __isl_give isl_multi_aff *isl_multi_aff_scale_multi_val(9137 __isl_take isl_multi_aff *ma,9138 __isl_take isl_multi_val *mv);9139 __isl_give isl_pw_multi_aff *9140 isl_pw_multi_aff_scale_multi_val(9141 __isl_take isl_pw_multi_aff *pma,9142 __isl_take isl_multi_val *mv);9143 __isl_give isl_multi_pw_aff *9144 isl_multi_pw_aff_scale_multi_val(9145 __isl_take isl_multi_pw_aff *mpa,9146 __isl_take isl_multi_val *mv);9147 __isl_give isl_multi_union_pw_aff *9148 isl_multi_union_pw_aff_scale_multi_val(9149 __isl_take isl_multi_union_pw_aff *mupa,9150 __isl_take isl_multi_val *mv);9151 __isl_give isl_union_pw_multi_aff *9152 isl_union_pw_multi_aff_scale_multi_val(9153 __isl_take isl_union_pw_multi_aff *upma,9154 __isl_take isl_multi_val *mv);9155 __isl_give isl_multi_aff *9156 isl_multi_aff_scale_down_multi_val(9157 __isl_take isl_multi_aff *ma,9158 __isl_take isl_multi_val *mv);9159 __isl_give isl_pw_multi_aff *9160 isl_pw_multi_aff_scale_down_multi_val(9161 __isl_take isl_pw_multi_aff *pma,9162 __isl_take isl_multi_val *mv);9163 __isl_give isl_multi_pw_aff *9164 isl_multi_pw_aff_scale_down_multi_val(9165 __isl_take isl_multi_pw_aff *mpa,9166 __isl_take isl_multi_val *mv);9167 __isl_give isl_multi_union_pw_aff *9168 isl_multi_union_pw_aff_scale_down_multi_val(9169 __isl_take isl_multi_union_pw_aff *mupa,9170 __isl_take isl_multi_val *mv);9171 9172C<isl_multi_aff_scale_multi_val> scales the elements of C<ma>9173by the corresponding elements of C<mv>.9174 9175 #include <isl/aff.h>9176 __isl_give isl_aff *isl_aff_mul(9177 __isl_take isl_aff *aff1,9178 __isl_take isl_aff *aff2);9179 __isl_give isl_aff *isl_aff_div(9180 __isl_take isl_aff *aff1,9181 __isl_take isl_aff *aff2);9182 __isl_give isl_pw_aff *isl_pw_aff_mul(9183 __isl_take isl_pw_aff *pwaff1,9184 __isl_take isl_pw_aff *pwaff2);9185 __isl_give isl_pw_aff *isl_pw_aff_div(9186 __isl_take isl_pw_aff *pa1,9187 __isl_take isl_pw_aff *pa2);9188 __isl_give isl_pw_aff *isl_pw_aff_tdiv_q(9189 __isl_take isl_pw_aff *pa1,9190 __isl_take isl_pw_aff *pa2);9191 __isl_give isl_pw_aff *isl_pw_aff_tdiv_r(9192 __isl_take isl_pw_aff *pa1,9193 __isl_take isl_pw_aff *pa2);9194 9195When multiplying two affine expressions, at least one of the two needs9196to be a constant. Similarly, when dividing an affine expression by another,9197the second expression needs to be a constant.9198C<isl_pw_aff_tdiv_q> computes the quotient of an integer division with9199rounding towards zero. C<isl_pw_aff_tdiv_r> computes the corresponding9200remainder.9201 9202 #include <isl/polynomial.h>9203 __isl_give isl_qpolynomial *isl_qpolynomial_mul(9204 __isl_take isl_qpolynomial *qp1,9205 __isl_take isl_qpolynomial *qp2);9206 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_mul(9207 __isl_take isl_pw_qpolynomial *pwqp1,9208 __isl_take isl_pw_qpolynomial *pwqp2);9209 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_mul(9210 __isl_take isl_union_pw_qpolynomial *upwqp1,9211 __isl_take isl_union_pw_qpolynomial *upwqp2);9212 9213=back9214 9215=head3 Lexicographic Optimization9216 9217Given a (basic) set C<set> (or C<bset>) and a zero-dimensional domain C<dom>,9218the following functions9219compute a set that contains the lexicographic minimum or maximum9220of the elements in C<set> (or C<bset>) for those values of the parameters9221that satisfy C<dom>.9222If C<empty> is not C<NULL>, then C<*empty> is assigned a set9223that contains the parameter values in C<dom> for which C<set> (or C<bset>)9224has no elements.9225In other words, the union of the parameter values9226for which the result is non-empty and of C<*empty>9227is equal to C<dom>.9228 9229 #include <isl/set.h>9230 __isl_give isl_set *isl_basic_set_partial_lexmin(9231 __isl_take isl_basic_set *bset,9232 __isl_take isl_basic_set *dom,9233 __isl_give isl_set **empty);9234 __isl_give isl_set *isl_basic_set_partial_lexmax(9235 __isl_take isl_basic_set *bset,9236 __isl_take isl_basic_set *dom,9237 __isl_give isl_set **empty);9238 __isl_give isl_set *isl_set_partial_lexmin(9239 __isl_take isl_set *set, __isl_take isl_set *dom,9240 __isl_give isl_set **empty);9241 __isl_give isl_set *isl_set_partial_lexmax(9242 __isl_take isl_set *set, __isl_take isl_set *dom,9243 __isl_give isl_set **empty);9244 9245Given a (basic) set C<set> (or C<bset>), the following functions simply9246return a set containing the lexicographic minimum or maximum9247of the elements in C<set> (or C<bset>).9248In case of union sets, the optimum is computed per space.9249 9250 #include <isl/set.h>9251 __isl_give isl_set *isl_basic_set_lexmin(9252 __isl_take isl_basic_set *bset);9253 __isl_give isl_set *isl_basic_set_lexmax(9254 __isl_take isl_basic_set *bset);9255 __isl_give isl_set *isl_set_lexmin(9256 __isl_take isl_set *set);9257 __isl_give isl_set *isl_set_lexmax(9258 __isl_take isl_set *set);9259 __isl_give isl_union_set *isl_union_set_lexmin(9260 __isl_take isl_union_set *uset);9261 __isl_give isl_union_set *isl_union_set_lexmax(9262 __isl_take isl_union_set *uset);9263 9264Given a (basic) relation C<map> (or C<bmap>) and a domain C<dom>,9265the following functions9266compute a relation that maps each element of C<dom>9267to the single lexicographic minimum or maximum9268of the elements that are associated to that same9269element in C<map> (or C<bmap>).9270If C<empty> is not C<NULL>, then C<*empty> is assigned a set9271that contains the elements in C<dom> that do not map9272to any elements in C<map> (or C<bmap>).9273In other words, the union of the domain of the result and of C<*empty>9274is equal to C<dom>.9275 9276 #include <isl/map.h>9277 __isl_give isl_map *isl_basic_map_partial_lexmax(9278 __isl_take isl_basic_map *bmap,9279 __isl_take isl_basic_set *dom,9280 __isl_give isl_set **empty);9281 __isl_give isl_map *isl_basic_map_partial_lexmin(9282 __isl_take isl_basic_map *bmap,9283 __isl_take isl_basic_set *dom,9284 __isl_give isl_set **empty);9285 __isl_give isl_map *isl_map_partial_lexmax(9286 __isl_take isl_map *map, __isl_take isl_set *dom,9287 __isl_give isl_set **empty);9288 __isl_give isl_map *isl_map_partial_lexmin(9289 __isl_take isl_map *map, __isl_take isl_set *dom,9290 __isl_give isl_set **empty);9291 9292Given a (basic) map C<map> (or C<bmap>), the following functions simply9293return a map mapping each element in the domain of9294C<map> (or C<bmap>) to the lexicographic minimum or maximum9295of all elements associated to that element.9296In case of union relations, the optimum is computed per space.9297 9298 #include <isl/map.h>9299 __isl_give isl_map *isl_basic_map_lexmin(9300 __isl_take isl_basic_map *bmap);9301 __isl_give isl_map *isl_basic_map_lexmax(9302 __isl_take isl_basic_map *bmap);9303 __isl_give isl_map *isl_map_lexmin(9304 __isl_take isl_map *map);9305 __isl_give isl_map *isl_map_lexmax(9306 __isl_take isl_map *map);9307 __isl_give isl_union_map *isl_union_map_lexmin(9308 __isl_take isl_union_map *umap);9309 __isl_give isl_union_map *isl_union_map_lexmax(9310 __isl_take isl_union_map *umap);9311 9312The following functions return their result in the form of9313a piecewise multi-affine expression,9314but are otherwise equivalent to the corresponding functions9315returning a basic set or relation.9316 9317 #include <isl/set.h>9318 __isl_give isl_pw_multi_aff *9319 isl_basic_set_partial_lexmin_pw_multi_aff(9320 __isl_take isl_basic_set *bset,9321 __isl_take isl_basic_set *dom,9322 __isl_give isl_set **empty);9323 __isl_give isl_pw_multi_aff *9324 isl_basic_set_partial_lexmax_pw_multi_aff(9325 __isl_take isl_basic_set *bset,9326 __isl_take isl_basic_set *dom,9327 __isl_give isl_set **empty);9328 __isl_give isl_pw_multi_aff *isl_set_lexmin_pw_multi_aff(9329 __isl_take isl_set *set);9330 __isl_give isl_pw_multi_aff *isl_set_lexmax_pw_multi_aff(9331 __isl_take isl_set *set);9332 9333 #include <isl/map.h>9334 __isl_give isl_pw_multi_aff *9335 isl_basic_map_lexmin_pw_multi_aff(9336 __isl_take isl_basic_map *bmap);9337 __isl_give isl_pw_multi_aff *9338 isl_basic_map_partial_lexmin_pw_multi_aff(9339 __isl_take isl_basic_map *bmap,9340 __isl_take isl_basic_set *dom,9341 __isl_give isl_set **empty);9342 __isl_give isl_pw_multi_aff *9343 isl_basic_map_partial_lexmax_pw_multi_aff(9344 __isl_take isl_basic_map *bmap,9345 __isl_take isl_basic_set *dom,9346 __isl_give isl_set **empty);9347 __isl_give isl_pw_multi_aff *isl_map_lexmin_pw_multi_aff(9348 __isl_take isl_map *map);9349 __isl_give isl_pw_multi_aff *isl_map_lexmax_pw_multi_aff(9350 __isl_take isl_map *map);9351 9352The following functions return the lexicographic minimum or maximum9353on the shared domain of the inputs and the single defined function9354on those parts of the domain where only a single function is defined.9355 9356 #include <isl/aff.h>9357 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmin(9358 __isl_take isl_pw_multi_aff *pma1,9359 __isl_take isl_pw_multi_aff *pma2);9360 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmax(9361 __isl_take isl_pw_multi_aff *pma1,9362 __isl_take isl_pw_multi_aff *pma2);9363 9364If the input to a lexicographic optimization problem has9365multiple constraints with the same coefficients for the optimized9366variables, then, by default, this symmetry is exploited by9367replacing those constraints by a single constraint with9368an abstract bound, which is in turn bounded by the corresponding terms9369in the original constraints.9370Without this optimization, the solver would typically consider9371all possible orderings of those original bounds, resulting in a needless9372decomposition of the domain.9373However, the optimization can also result in slowdowns since9374an extra parameter is introduced that may get used in additional9375integer divisions.9376The following option determines whether symmetry detection is applied9377during lexicographic optimization.9378 9379 #include <isl/options.h>9380 isl_stat isl_options_set_pip_symmetry(isl_ctx *ctx,9381 int val);9382 int isl_options_get_pip_symmetry(isl_ctx *ctx);9383 9384=begin latex9385 9386See also \autoref{s:offline}.9387 9388=end latex9389 9390=head2 Ternary Operations9391 9392 #include <isl/aff.h>9393 __isl_give isl_pw_aff *isl_pw_aff_cond(9394 __isl_take isl_pw_aff *cond,9395 __isl_take isl_pw_aff *pwaff_true,9396 __isl_take isl_pw_aff *pwaff_false);9397 9398The function C<isl_pw_aff_cond> performs a conditional operator9399and returns an expression that is equal to C<pwaff_true>9400for elements where C<cond> is non-zero and equal to C<pwaff_false> for elements9401where C<cond> is zero.9402 9403=head2 Lists9404 9405Lists are defined over several element types, including9406C<isl_val>, C<isl_id>, C<isl_aff>, C<isl_pw_aff>, C<isl_pw_multi_aff>,9407C<isl_union_pw_aff>,9408C<isl_union_pw_multi_aff>,9409C<isl_qpolynomial>, C<isl_pw_qpolynomial>, C<isl_pw_qpolynomial_fold>,9410C<isl_constraint>,9411C<isl_basic_set>, C<isl_set>, C<isl_basic_map>, C<isl_map>, C<isl_union_set>,9412C<isl_union_map>, C<isl_ast_expr> and C<isl_ast_node>.9413Here we take lists of C<isl_set>s as an example.9414Lists can be created, copied, modified and freed using the following functions.9415 9416 #include <isl/set.h>9417 __isl_give isl_set_list *isl_set_to_list(9418 __isl_take isl_set *el);9419 __isl_give isl_set_list *isl_set_list_from_set(9420 __isl_take isl_set *el);9421 __isl_give isl_set_list *isl_set_list_alloc(9422 isl_ctx *ctx, int n);9423 __isl_give isl_set_list *isl_set_list_copy(9424 __isl_keep isl_set_list *list);9425 __isl_give isl_set_list *isl_set_list_insert(9426 __isl_take isl_set_list *list, unsigned pos,9427 __isl_take isl_set *el);9428 __isl_give isl_set_list *isl_set_list_add(9429 __isl_take isl_set_list *list,9430 __isl_take isl_set *el);9431 __isl_give isl_set_list *isl_set_list_drop(9432 __isl_take isl_set_list *list,9433 unsigned first, unsigned n);9434 __isl_give isl_set_list *isl_set_list_clear(9435 __isl_take isl_set_list *list);9436 __isl_give isl_set_list *isl_set_list_swap(9437 __isl_take isl_set_list *list,9438 unsigned pos1, unsigned pos2);9439 __isl_give isl_set_list *isl_set_list_reverse(9440 __isl_take isl_set_list *list);9441 __isl_give isl_set_list *isl_set_list_set_at(9442 __isl_take isl_set_list *list, int index,9443 __isl_take isl_set *set);9444 __isl_give isl_set_list *isl_set_list_set_set(9445 __isl_take isl_set_list *list, int index,9446 __isl_take isl_set *set);9447 __isl_give isl_set_list *isl_set_list_concat(9448 __isl_take isl_set_list *list1,9449 __isl_take isl_set_list *list2);9450 __isl_give isl_set_list *isl_set_list_map(9451 __isl_take isl_set_list *list,9452 __isl_give isl_set *(*fn)(__isl_take isl_set *el,9453 void *user),9454 void *user);9455 __isl_give isl_set_list *isl_set_list_sort(9456 __isl_take isl_set_list *list,9457 int (*cmp)(__isl_keep isl_set *a,9458 __isl_keep isl_set *b, void *user),9459 void *user);9460 __isl_null isl_set_list *isl_set_list_free(9461 __isl_take isl_set_list *list);9462 9463C<isl_set_list_alloc> creates an empty list with an initial capacity9464for C<n> elements. C<isl_set_list_insert> and C<isl_set_list_add>9465add elements to a list, increasing its capacity as needed.9466C<isl_set_to_list> creates a list with a single element.9467C<isl_set_list_from_set> performs the same operation.9468C<isl_set_list_clear> removes all elements from a list.9469C<isl_set_list_swap> swaps the elements at the specified locations.9470C<isl_set_list_reverse> reverses the elements in the list.9471C<isl_set_list_set_set> is an alternative name for C<isl_set_list_set_at>.9472 9473Lists can be inspected using the following functions.9474 9475 #include <isl/set.h>9476 isl_size isl_set_list_size(__isl_keep isl_set_list *list);9477 isl_size isl_set_list_n_set(__isl_keep isl_set_list *list);9478 __isl_give isl_set *isl_set_list_get_at(9479 __isl_keep isl_set_list *list, int index);9480 __isl_give isl_set *isl_set_list_get_set(9481 __isl_keep isl_set_list *list, int index);9482 isl_stat isl_set_list_foreach(__isl_keep isl_set_list *list,9483 isl_stat (*fn)(__isl_take isl_set *el, void *user),9484 void *user);9485 isl_bool isl_set_list_every(__isl_keep isl_set_list *list,9486 isl_bool (*test)(__isl_take isl_set *el,9487 void *user),9488 void *user);9489 isl_stat isl_set_list_foreach_scc(9490 __isl_keep isl_set_list *list,9491 isl_bool (*follows)(__isl_keep isl_set *a,9492 __isl_keep isl_set *b, void *user),9493 void *follows_user,9494 isl_stat (*fn)(__isl_take isl_set_list *scc,9495 void *user),9496 void *fn_user);9497 9498C<isl_set_list_n_set> is an alternative name for C<isl_set_list_size>.9499Similarly,9500C<isl_set_list_get_set> is an alternative name for C<isl_set_list_get_at>.9501The function C<isl_set_list_foreach_scc> calls C<fn> on each of the9502strongly connected components of the graph with as vertices the elements9503of C<list> and a directed edge from vertex C<b> to vertex C<a>9504iff C<follows(a, b)> returns C<isl_bool_true>. The callbacks C<follows> and9505C<fn> should return C<isl_bool_error> or C<isl_stat_error> on error.9506 9507Lists can be printed using9508 9509 #include <isl/set.h>9510 __isl_give isl_printer *isl_printer_print_set_list(9511 __isl_take isl_printer *p,9512 __isl_keep isl_set_list *list);9513 9514Alternatively, a string representation can be obtained9515directly using the following function, which always prints9516in isl format.9517 9518 #include <isl/set.h>9519 __isl_give char *isl_set_list_to_str(9520 __isl_keep isl_set_list *list);9521 9522An C<isl_val_list>, C<isl_id_list>,9523C<isl_aff_list>, C<isl_pw_aff_list>, C<isl_pw_multi_aff_list>,9524C<isl_union_pw_aff_list>,9525C<isl_set_list>, C<isl_map_list> or C<isl_union_set_list> object9526can also be read from input using the following functions.9527 9528 #include <isl/val.h>9529 __isl_give isl_val_list *isl_val_list_read_from_str(9530 isl_ctx *ctx, const char *str);9531 9532 #include <isl/id.h>9533 __isl_give isl_id_list *isl_id_list_read_from_str(9534 isl_ctx *ctx, const char *str);9535 9536 #include <isl/aff.h>9537 __isl_give isl_aff_list *9538 isl_aff_list_read_from_str(isl_ctx *ctx,9539 const char *str);9540 __isl_give isl_pw_aff_list *9541 isl_pw_aff_list_read_from_str(isl_ctx *ctx,9542 const char *str);9543 __isl_give isl_pw_multi_aff_list *9544 isl_pw_multi_aff_list_read_from_str(isl_ctx *ctx,9545 const char *str);9546 __isl_give isl_union_pw_aff_list *9547 isl_union_pw_aff_list_read_from_str(isl_ctx *ctx,9548 const char *str);9549 9550 #include <isl/set.h>9551 __isl_give isl_set_list *isl_set_list_read_from_str(9552 isl_ctx *ctx, const char *str);9553 9554 #include <isl/map.h>9555 __isl_give isl_map_list *isl_map_list_read_from_str(9556 isl_ctx *ctx, const char *str);9557 9558 #include <isl/union_set.h>9559 __isl_give isl_union_set_list *9560 isl_union_set_list_read_from_str(isl_ctx *ctx,9561 const char *str);9562 9563=head2 Associative arrays9564 9565Associative arrays map isl objects of a specific type to isl objects9566of some (other) specific type. They are defined for several pairs9567of types, including (C<isl_map>, C<isl_basic_set>),9568(C<isl_id>, C<isl_ast_expr>),9569(C<isl_id>, C<isl_id>) and9570(C<isl_id>, C<isl_pw_aff>).9571Here, we take associative arrays that map C<isl_id>s to C<isl_ast_expr>s9572as an example.9573 9574Associative arrays can be created, copied and freed using9575the following functions.9576 9577 #include <isl/id_to_ast_expr.h>9578 __isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_alloc(9579 isl_ctx *ctx, int min_size);9580 __isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_copy(9581 __isl_keep isl_id_to_ast_expr *id2expr);9582 __isl_null isl_id_to_ast_expr *isl_id_to_ast_expr_free(9583 __isl_take isl_id_to_ast_expr *id2expr);9584 9585The C<min_size> argument to C<isl_id_to_ast_expr_alloc> can be used9586to specify the expected size of the associative array.9587The associative array will be grown automatically as needed.9588 9589Associative arrays can be inspected using the following functions.9590 9591 #include <isl/id_to_ast_expr.h>9592 __isl_give isl_maybe_isl_ast_expr9593 isl_id_to_ast_expr_try_get(9594 __isl_keep isl_id_to_ast_expr *id2expr,9595 __isl_keep isl_id *key);9596 isl_bool isl_id_to_ast_expr_has(9597 __isl_keep isl_id_to_ast_expr *id2expr,9598 __isl_keep isl_id *key);9599 __isl_give isl_ast_expr *isl_id_to_ast_expr_get(9600 __isl_keep isl_id_to_ast_expr *id2expr,9601 __isl_take isl_id *key);9602 isl_stat isl_id_to_ast_expr_foreach(9603 __isl_keep isl_id_to_ast_expr *id2expr,9604 isl_stat (*fn)(__isl_take isl_id *key,9605 __isl_take isl_ast_expr *val, void *user),9606 void *user);9607 isl_bool isl_id_to_ast_expr_every(9608 __isl_keep isl_id_to_ast_expr *id2expr,9609 isl_bool (*test)(__isl_keep isl_id *key,9610 __isl_keep isl_ast_expr *val, void *user),9611 void *user);9612 9613The function C<isl_id_to_ast_expr_try_get> returns a structure9614containing two elements, C<valid> and C<value>.9615If there is a value associated to the key, then C<valid>9616is set to C<isl_bool_true> and C<value> contains a copy of9617the associated value. Otherwise C<value> is C<NULL> and9618C<valid> may be C<isl_bool_error> or C<isl_bool_false> depending9619on whether some error has occurred or there simply is no associated value.9620The function C<isl_id_to_ast_expr_has> returns the C<valid> field9621in the structure and9622the function C<isl_id_to_ast_expr_get> returns the C<value> field.9623 9624Associative arrays can be modified using the following functions.9625 9626 #include <isl/id_to_ast_expr.h>9627 __isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_set(9628 __isl_take isl_id_to_ast_expr *id2expr,9629 __isl_take isl_id *key,9630 __isl_take isl_ast_expr *val);9631 __isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_drop(9632 __isl_take isl_id_to_ast_expr *id2expr,9633 __isl_take isl_id *key);9634 9635Associative arrays can be checked for (obvious) equality9636using the following function.9637 9638 #include <isl/id_to_ast_expr.h>9639 isl_bool isl_id_to_ast_expr_is_equal(9640 __isl_take isl_id_to_ast_expr *id2expr1,9641 __isl_take isl_id_to_ast_expr *id2expr2);9642 9643Note that depending on how the keys and values are being compared,9644for other types of keys and/or values, this function may be called9645C<plain_is_equal> rather than C<is_equal>.9646 9647Associative arrays can be printed using the following functions.9648 9649 #include <isl/id_to_ast_expr.h>9650 __isl_give isl_printer *isl_printer_print_id_to_ast_expr(9651 __isl_take isl_printer *p,9652 __isl_keep isl_id_to_ast_expr *id2expr);9653 __isl_give char *isl_id_to_ast_expr_to_str(9654 __isl_keep isl_id_to_ast_expr *id2expr);9655 9656They can be read from input using the following function.9657 9658 #include <isl/id_to_ast_expr.h>9659 __isl_give isl_id_to_ast_expr *9660 isl_id_to_ast_expr_read_from_str(isl_ctx *ctx,9661 const char *str);9662 9663=head2 Vectors9664 9665Vectors can be created, copied and freed using the following functions.9666 9667 #include <isl/vec.h>9668 __isl_give isl_vec *isl_vec_alloc(isl_ctx *ctx,9669 unsigned size);9670 __isl_give isl_vec *isl_vec_zero(isl_ctx *ctx,9671 unsigned size);9672 __isl_give isl_vec *isl_vec_copy(__isl_keep isl_vec *vec);9673 __isl_null isl_vec *isl_vec_free(__isl_take isl_vec *vec);9674 9675Note that the elements of a vector created by C<isl_vec_alloc>9676may have arbitrary values.9677A vector created by C<isl_vec_zero> has elements with value zero.9678The elements can be changed and inspected using the following functions.9679 9680 isl_size isl_vec_size(__isl_keep isl_vec *vec);9681 __isl_give isl_val *isl_vec_get_element_val(9682 __isl_keep isl_vec *vec, int pos);9683 __isl_give isl_vec *isl_vec_set_element_si(9684 __isl_take isl_vec *vec, int pos, int v);9685 __isl_give isl_vec *isl_vec_set_element_val(9686 __isl_take isl_vec *vec, int pos,9687 __isl_take isl_val *v);9688 __isl_give isl_vec *isl_vec_set_si(__isl_take isl_vec *vec,9689 int v);9690 __isl_give isl_vec *isl_vec_set_val(9691 __isl_take isl_vec *vec, __isl_take isl_val *v);9692 int isl_vec_cmp_element(__isl_keep isl_vec *vec1,9693 __isl_keep isl_vec *vec2, int pos);9694 9695C<isl_vec_get_element> will return a negative value if anything went wrong.9696In that case, the value of C<*v> is undefined.9697 9698The following function can be used to concatenate two vectors.9699 9700 __isl_give isl_vec *isl_vec_concat(__isl_take isl_vec *vec1,9701 __isl_take isl_vec *vec2);9702 9703=head2 Matrices9704 9705Matrices can be created, copied and freed using the following functions.9706 9707 #include <isl/mat.h>9708 __isl_give isl_mat *isl_mat_alloc(isl_ctx *ctx,9709 unsigned n_row, unsigned n_col);9710 __isl_give isl_mat *isl_mat_copy(__isl_keep isl_mat *mat);9711 __isl_null isl_mat *isl_mat_free(__isl_take isl_mat *mat);9712 9713Note that the elements of a newly created matrix may have arbitrary values.9714The elements can be changed and inspected using the following functions.9715 9716 isl_size isl_mat_rows(__isl_keep isl_mat *mat);9717 isl_size isl_mat_cols(__isl_keep isl_mat *mat);9718 __isl_give isl_val *isl_mat_get_element_val(9719 __isl_keep isl_mat *mat, int row, int col);9720 __isl_give isl_mat *isl_mat_set_element_si(__isl_take isl_mat *mat,9721 int row, int col, int v);9722 __isl_give isl_mat *isl_mat_set_element_val(9723 __isl_take isl_mat *mat, int row, int col,9724 __isl_take isl_val *v);9725 9726The following function computes the rank of a matrix.9727The return value may be -1 if some error occurred.9728 9729 #include <isl/mat.h>9730 isl_size isl_mat_rank(__isl_keep isl_mat *mat);9731 9732The following function can be used to compute the (right) inverse9733of a matrix, i.e., a matrix such that the product of the original9734and the inverse (in that order) is a multiple of the identity matrix.9735The input matrix is assumed to be of full row-rank.9736 9737 __isl_give isl_mat *isl_mat_right_inverse(__isl_take isl_mat *mat);9738 9739The following function can be used to compute the (right) kernel9740(or null space) of a matrix, i.e., a matrix such that the product of9741the original and the kernel (in that order) is the zero matrix.9742 9743 __isl_give isl_mat *isl_mat_right_kernel(__isl_take isl_mat *mat);9744 9745The following function computes a basis for the space spanned9746by the rows of a matrix.9747 9748 __isl_give isl_mat *isl_mat_row_basis(9749 __isl_take isl_mat *mat);9750 9751The following function computes rows that extend a basis of C<mat1>9752to a basis that also covers C<mat2>.9753 9754 __isl_give isl_mat *isl_mat_row_basis_extension(9755 __isl_take isl_mat *mat1,9756 __isl_take isl_mat *mat2);9757 9758The following function checks whether there is no linear dependence9759among the combined rows of "mat1" and "mat2" that is not already present9760in "mat1" or "mat2" individually.9761If "mat1" and "mat2" have linearly independent rows by themselves,9762then this means that there is no linear dependence among all rows together.9763 9764 isl_bool isl_mat_has_linearly_independent_rows(9765 __isl_keep isl_mat *mat1,9766 __isl_keep isl_mat *mat2);9767 9768=head2 Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions9769 9770The following functions determine9771an upper or lower bound on a quasipolynomial over its domain.9772 9773 __isl_give isl_pw_qpolynomial_fold *9774 isl_pw_qpolynomial_bound(9775 __isl_take isl_pw_qpolynomial *pwqp,9776 enum isl_fold type, isl_bool *tight);9777 9778 __isl_give isl_union_pw_qpolynomial_fold *9779 isl_union_pw_qpolynomial_bound(9780 __isl_take isl_union_pw_qpolynomial *upwqp,9781 enum isl_fold type, isl_bool *tight);9782 9783The C<type> argument may be either C<isl_fold_min> or C<isl_fold_max>.9784If C<tight> is not C<NULL>, then C<*tight> is set to C<1>9785is the returned bound is known be tight, i.e., for each value9786of the parameters there is at least9787one element in the domain that reaches the bound.9788If the domain of C<pwqp> is not wrapping, then the bound is computed9789over all elements in that domain and the result has a purely parametric9790domain. If the domain of C<pwqp> is wrapping, then the bound is9791computed over the range of the wrapped relation. The domain of the9792wrapped relation becomes the domain of the result.9793 9794=head2 Parametric Vertex Enumeration9795 9796The parametric vertex enumeration described in this section9797is mainly intended to be used internally and by the C<barvinok>9798library.9799 9800 #include <isl/vertices.h>9801 __isl_give isl_vertices *isl_basic_set_compute_vertices(9802 __isl_keep isl_basic_set *bset);9803 9804The function C<isl_basic_set_compute_vertices> performs the9805actual computation of the parametric vertices and the chamber9806decomposition and stores the result in an C<isl_vertices> object.9807This information can be queried by either iterating over all9808the vertices or iterating over all the chambers or cells9809and then iterating over all vertices that are active on the chamber.9810 9811 isl_stat isl_vertices_foreach_vertex(9812 __isl_keep isl_vertices *vertices,9813 isl_stat (*fn)(__isl_take isl_vertex *vertex,9814 void *user), void *user);9815 9816 isl_stat isl_vertices_foreach_cell(9817 __isl_keep isl_vertices *vertices,9818 isl_stat (*fn)(__isl_take isl_cell *cell,9819 void *user), void *user);9820 isl_stat isl_cell_foreach_vertex(__isl_keep isl_cell *cell,9821 isl_stat (*fn)(__isl_take isl_vertex *vertex,9822 void *user), void *user);9823 9824Other operations that can be performed on an C<isl_vertices> object are9825the following.9826 9827 isl_size isl_vertices_get_n_vertices(9828 __isl_keep isl_vertices *vertices);9829 __isl_null isl_vertices *isl_vertices_free(9830 __isl_take isl_vertices *vertices);9831 9832Vertices can be inspected and destroyed using the following functions.9833 9834 isl_size isl_vertex_get_id(__isl_keep isl_vertex *vertex);9835 __isl_give isl_basic_set *isl_vertex_get_domain(9836 __isl_keep isl_vertex *vertex);9837 __isl_give isl_multi_aff *isl_vertex_get_expr(9838 __isl_keep isl_vertex *vertex);9839 __isl_null isl_vertex *isl_vertex_free(9840 __isl_take isl_vertex *vertex);9841 9842C<isl_vertex_get_expr> returns a multiple quasi-affine expression9843describing the vertex in terms of the parameters,9844while C<isl_vertex_get_domain> returns the activity domain9845of the vertex.9846 9847Chambers can be inspected and destroyed using the following functions.9848 9849 __isl_give isl_basic_set *isl_cell_get_domain(9850 __isl_keep isl_cell *cell);9851 __isl_null isl_cell *isl_cell_free(9852 __isl_take isl_cell *cell);9853 9854=head1 Polyhedral Compilation Library9855 9856This section collects functionality in C<isl> that has been specifically9857designed for use during polyhedral compilation.9858 9859=head2 Schedule Trees9860 9861A schedule tree is a structured representation of a schedule,9862assigning a relative order to a set of domain elements.9863The relative order expressed by the schedule tree is9864defined recursively. In particular, the order between9865two domain elements is determined by the node that is closest9866to the root that refers to both elements and that orders them apart.9867Each node in the tree is of one of several types.9868The root node is always of type C<isl_schedule_node_domain>9869(or C<isl_schedule_node_extension>)9870and it describes the (extra) domain elements to which the schedule applies.9871The other types of nodes are as follows.9872 9873=over9874 9875=item C<isl_schedule_node_band>9876 9877A band of schedule dimensions. Each schedule dimension is represented9878by a union piecewise quasi-affine expression. If this expression9879assigns a different value to two domain elements, while all previous9880schedule dimensions in the same band assign them the same value,9881then the two domain elements are ordered according to these two9882different values.9883Each expression is required to be total in the domain elements9884that reach the band node.9885 9886=item C<isl_schedule_node_expansion>9887 9888An expansion node maps each of the domain elements that reach the node9889to one or more domain elements. The image of this mapping forms9890the set of domain elements that reach the child of the expansion node.9891The function that maps each of the expanded domain elements9892to the original domain element from which it was expanded9893is called the contraction.9894 9895=item C<isl_schedule_node_filter>9896 9897A filter node does not impose any ordering, but rather intersects9898the set of domain elements that the current subtree refers to9899with a given union set. The subtree of the filter node only9900refers to domain elements in the intersection.9901A filter node is typically only used as a child of a sequence or9902set node.9903 9904=item C<isl_schedule_node_leaf>9905 9906A leaf of the schedule tree. Leaf nodes do not impose any ordering.9907 9908=item C<isl_schedule_node_mark>9909 9910A mark node can be used to attach any kind of information to a subtree9911of the schedule tree.9912 9913=item C<isl_schedule_node_sequence>9914 9915A sequence node has one or more children, each of which is a filter node.9916The filters on these filter nodes form a partition of9917the domain elements that the current subtree refers to.9918If two domain elements appear in distinct filters then the sequence9919node orders them according to the child positions of the corresponding9920filter nodes.9921 9922=item C<isl_schedule_node_set>9923 9924A set node is similar to a sequence node, except that9925it expresses that domain elements appearing in distinct filters9926may have any order. The order of the children of a set node9927is therefore also immaterial.9928 9929=back9930 9931The following node types are only supported by the AST generator.9932 9933=over9934 9935=item C<isl_schedule_node_context>9936 9937The context describes constraints on the parameters and9938the schedule dimensions of outer9939bands that the AST generator may assume to hold. It is also the only9940kind of node that may introduce additional parameters.9941The space of the context is that of the flat product of the outer9942band nodes. In particular, if there are no outer band nodes, then9943this space is the unnamed zero-dimensional space.9944Since a context node references the outer band nodes, any tree9945containing a context node is considered to be anchored.9946 9947=item C<isl_schedule_node_extension>9948 9949An extension node instructs the AST generator to add additional9950domain elements that need to be scheduled.9951The additional domain elements are described by the range of9952the extension map in terms of the outer schedule dimensions,9953i.e., the flat product of the outer band nodes.9954Note that domain elements are added whenever the AST generator9955reaches the extension node, meaning that there are still some9956active domain elements for which an AST needs to be generated.9957The conditions under which some domain elements are still active9958may however not be completely described by the outer AST nodes9959generated at that point.9960Since an extension node references the outer band nodes, any tree9961containing an extension node is considered to be anchored.9962 9963An extension node may also appear as the root of a schedule tree,9964when it is intended to be inserted into another tree9965using C<isl_schedule_node_graft_before> or C<isl_schedule_node_graft_after>.9966In this case, the domain of the extension node should9967correspond to the flat product of the outer band nodes9968in this other schedule tree at the point where the extension tree9969will be inserted.9970 9971=item C<isl_schedule_node_guard>9972 9973The guard describes constraints on the parameters and9974the schedule dimensions of outer9975bands that need to be enforced by the outer nodes9976in the generated AST.9977That is, the part of the AST that is generated from descendants9978of the guard node can assume that these constraints are satisfied.9979The space of the guard is that of the flat product of the outer9980band nodes. In particular, if there are no outer band nodes, then9981this space is the unnamed zero-dimensional space.9982Since a guard node references the outer band nodes, any tree9983containing a guard node is considered to be anchored.9984 9985=back9986 9987Except for the C<isl_schedule_node_context> nodes,9988none of the nodes may introduce any parameters that were not9989already present in the root domain node.9990 9991A schedule tree is encapsulated in an C<isl_schedule> object.9992The simplest such objects, those with a tree consisting of single domain node,9993can be created using the following functions with either an empty9994domain or a given domain.9995 9996 #include <isl/schedule.h>9997 __isl_give isl_schedule *isl_schedule_empty(9998 __isl_take isl_space *space);9999 __isl_give isl_schedule *isl_schedule_from_domain(10000 __isl_take isl_union_set *domain);10001 10002The function C<isl_schedule_constraints_compute_schedule> described10003in L</"Scheduling"> can also be used to construct schedules.10004 10005C<isl_schedule> objects may be copied and freed using the following functions.10006 10007 #include <isl/schedule.h>10008 __isl_give isl_schedule *isl_schedule_copy(10009 __isl_keep isl_schedule *sched);10010 __isl_null isl_schedule *isl_schedule_free(10011 __isl_take isl_schedule *sched);10012 10013The following functions checks whether two C<isl_schedule> objects10014are obviously the same.10015 10016 #include <isl/schedule.h>10017 isl_bool isl_schedule_plain_is_equal(10018 __isl_keep isl_schedule *schedule1,10019 __isl_keep isl_schedule *schedule2);10020 10021The domain of the schedule, i.e., the domain described by the root node,10022can be obtained using the following function.10023 10024 #include <isl/schedule.h>10025 __isl_give isl_union_set *isl_schedule_get_domain(10026 __isl_keep isl_schedule *schedule);10027 10028An extra top-level band node (right underneath the domain node) can10029be introduced into the schedule using the following function.10030The schedule tree is assumed not to have any anchored nodes.10031 10032 #include <isl/schedule.h>10033 __isl_give isl_schedule *10034 isl_schedule_insert_partial_schedule(10035 __isl_take isl_schedule *schedule,10036 __isl_take isl_multi_union_pw_aff *partial);10037 10038A top-level context node (right underneath the domain node) can10039be introduced into the schedule using the following function.10040 10041 #include <isl/schedule.h>10042 __isl_give isl_schedule *isl_schedule_insert_context(10043 __isl_take isl_schedule *schedule,10044 __isl_take isl_set *context)10045 10046A top-level guard node (right underneath the domain node) can10047be introduced into the schedule using the following function.10048 10049 #include <isl/schedule.h>10050 __isl_give isl_schedule *isl_schedule_insert_guard(10051 __isl_take isl_schedule *schedule,10052 __isl_take isl_set *guard)10053 10054A schedule that combines two schedules either in the given10055order or in an arbitrary order, i.e., with an C<isl_schedule_node_sequence>10056or an C<isl_schedule_node_set> node,10057can be created using the following functions.10058 10059 #include <isl/schedule.h>10060 __isl_give isl_schedule *isl_schedule_sequence(10061 __isl_take isl_schedule *schedule1,10062 __isl_take isl_schedule *schedule2);10063 __isl_give isl_schedule *isl_schedule_set(10064 __isl_take isl_schedule *schedule1,10065 __isl_take isl_schedule *schedule2);10066 10067The domains of the two input schedules need to be disjoint.10068 10069The following function can be used to restrict the domain10070of a schedule with a domain node as root to be a subset of the given union set.10071This operation may remove nodes in the tree that have become10072redundant.10073 10074 #include <isl/schedule.h>10075 __isl_give isl_schedule *isl_schedule_intersect_domain(10076 __isl_take isl_schedule *schedule,10077 __isl_take isl_union_set *domain);10078 10079The following function can be used to simplify the domain10080of a schedule with a domain node as root with respect to the given10081parameter domain.10082 10083 #include <isl/schedule.h>10084 __isl_give isl_schedule *isl_schedule_gist_domain_params(10085 __isl_take isl_schedule *schedule,10086 __isl_take isl_set *context);10087 10088The following function resets the user pointers on all parameter10089and tuple identifiers referenced by the nodes of the given schedule.10090 10091 #include <isl/schedule.h>10092 __isl_give isl_schedule *isl_schedule_reset_user(10093 __isl_take isl_schedule *schedule);10094 10095The following function aligns the parameters of all nodes10096in the given schedule to the given space.10097 10098 #include <isl/schedule.h>10099 __isl_give isl_schedule *isl_schedule_align_params(10100 __isl_take isl_schedule *schedule,10101 __isl_take isl_space *space);10102 10103The following function allows the user to plug in a given function10104in the iteration domains. The input schedule is not allowed to contain10105any expansion nodes.10106 10107 #include <isl/schedule.h>10108 __isl_give isl_schedule *10109 isl_schedule_pullback_union_pw_multi_aff(10110 __isl_take isl_schedule *schedule,10111 __isl_take isl_union_pw_multi_aff *upma);10112 10113The following function can be used to plug in the schedule C<expansion>10114in the leaves of C<schedule>, where C<contraction> describes how10115the domain elements of C<expansion> map to the domain elements10116at the original leaves of C<schedule>.10117The resulting schedule will contain expansion nodes, unless10118C<contraction> is an identity function.10119 10120 #include <isl/schedule.h>10121 __isl_give isl_schedule *isl_schedule_expand(10122 __isl_take isl_schedule *schedule,10123 __isl_take isl_union_pw_multi_aff *contraction,10124 __isl_take isl_schedule *expansion);10125 10126An C<isl_union_map> representation of the schedule can be obtained10127from an C<isl_schedule> using the following function.10128 10129 #include <isl/schedule.h>10130 __isl_give isl_union_map *isl_schedule_get_map(10131 __isl_keep isl_schedule *sched);10132 10133The resulting relation encodes the same relative ordering as10134the schedule by mapping the domain elements to a common schedule space.10135If the schedule_separate_components option is set, then the order10136of the children of a set node is explicitly encoded in the result.10137If the tree contains any expansion nodes, then the relation10138is formulated in terms of the expanded domain elements.10139 10140Schedules can be read from input using the following functions.10141 10142 #include <isl/schedule.h>10143 __isl_give isl_schedule *isl_schedule_read_from_file(10144 isl_ctx *ctx, FILE *input);10145 __isl_give isl_schedule *isl_schedule_read_from_str(10146 isl_ctx *ctx, const char *str);10147 10148A representation of the schedule can be printed using10149 10150 #include <isl/schedule.h>10151 __isl_give isl_printer *isl_printer_print_schedule(10152 __isl_take isl_printer *p,10153 __isl_keep isl_schedule *schedule);10154 __isl_give char *isl_schedule_to_str(10155 __isl_keep isl_schedule *schedule);10156 10157C<isl_schedule_to_str> prints the schedule in flow format.10158 10159The schedule tree can be traversed through the use of10160C<isl_schedule_node> objects that point to a particular10161position in the schedule tree. Whenever a C<isl_schedule_node>10162is used to modify a node in the schedule tree, the original schedule10163tree is left untouched and the modifications are performed to a copy10164of the tree. The returned C<isl_schedule_node> then points to10165this modified copy of the tree.10166 10167The root of the schedule tree can be obtained using the following function.10168 10169 #include <isl/schedule.h>10170 __isl_give isl_schedule_node *isl_schedule_get_root(10171 __isl_keep isl_schedule *schedule);10172 10173A pointer to a newly created schedule tree with a single domain10174node can be created using the following functions.10175 10176 #include <isl/schedule_node.h>10177 __isl_give isl_schedule_node *10178 isl_schedule_node_from_domain(10179 __isl_take isl_union_set *domain);10180 __isl_give isl_schedule_node *10181 isl_schedule_node_from_extension(10182 __isl_take isl_union_map *extension);10183 10184C<isl_schedule_node_from_extension> creates a tree with an extension10185node as root.10186 10187Schedule nodes can be copied and freed using the following functions.10188 10189 #include <isl/schedule_node.h>10190 __isl_give isl_schedule_node *isl_schedule_node_copy(10191 __isl_keep isl_schedule_node *node);10192 __isl_null isl_schedule_node *isl_schedule_node_free(10193 __isl_take isl_schedule_node *node);10194 10195The following functions can be used to check if two schedule10196nodes point to the same position in the same schedule.10197 10198 #include <isl/schedule_node.h>10199 isl_bool isl_schedule_node_is_equal(10200 __isl_keep isl_schedule_node *node1,10201 __isl_keep isl_schedule_node *node2);10202 10203The following properties can be obtained from a schedule node.10204 10205 #include <isl/schedule_node.h>10206 enum isl_schedule_node_type isl_schedule_node_get_type(10207 __isl_keep isl_schedule_node *node);10208 enum isl_schedule_node_type10209 isl_schedule_node_get_parent_type(10210 __isl_keep isl_schedule_node *node);10211 __isl_give isl_schedule *isl_schedule_node_get_schedule(10212 __isl_keep isl_schedule_node *node);10213 10214The function C<isl_schedule_node_get_type> returns the type of10215the node, while C<isl_schedule_node_get_parent_type> returns10216type of the parent of the node, which is required to exist.10217The function C<isl_schedule_node_get_schedule> returns a copy10218to the schedule to which the node belongs.10219 10220The following functions can be used to move the schedule node10221to a different position in the tree or to check if such a position10222exists.10223 10224 #include <isl/schedule_node.h>10225 isl_bool isl_schedule_node_has_parent(10226 __isl_keep isl_schedule_node *node);10227 __isl_give isl_schedule_node *isl_schedule_node_parent(10228 __isl_take isl_schedule_node *node);10229 __isl_give isl_schedule_node *10230 isl_schedule_node_grandparent(10231 __isl_take isl_schedule_node *node);10232 __isl_give isl_schedule_node *isl_schedule_node_root(10233 __isl_take isl_schedule_node *node);10234 __isl_give isl_schedule_node *isl_schedule_node_ancestor(10235 __isl_take isl_schedule_node *node,10236 int generation);10237 isl_size isl_schedule_node_n_children(10238 __isl_keep isl_schedule_node *node);10239 __isl_give isl_schedule_node *isl_schedule_node_child(10240 __isl_take isl_schedule_node *node, int pos);10241 isl_bool isl_schedule_node_has_children(10242 __isl_keep isl_schedule_node *node);10243 __isl_give isl_schedule_node *10244 isl_schedule_node_grandchild(10245 __isl_take isl_schedule_node *node,10246 int pos1, int pos2);10247 __isl_give isl_schedule_node *isl_schedule_node_first_child(10248 __isl_take isl_schedule_node *node);10249 isl_bool isl_schedule_node_has_previous_sibling(10250 __isl_keep isl_schedule_node *node);10251 __isl_give isl_schedule_node *10252 isl_schedule_node_previous_sibling(10253 __isl_take isl_schedule_node *node);10254 isl_bool isl_schedule_node_has_next_sibling(10255 __isl_keep isl_schedule_node *node);10256 __isl_give isl_schedule_node *10257 isl_schedule_node_next_sibling(10258 __isl_take isl_schedule_node *node);10259 10260For C<isl_schedule_node_ancestor>, the ancestor of generation 010261is the node itself, the ancestor of generation 1 is its parent and so on.10262 10263It is also possible to query the number of ancestors of a node,10264the position of the current node10265within the children of its parent, the position of the subtree10266containing a node within the children of an ancestor10267or to obtain a copy of a given10268child without destroying the current node.10269Given two nodes that point to the same schedule, their closest10270shared ancestor can be obtained using10271C<isl_schedule_node_get_shared_ancestor>.10272 10273 #include <isl/schedule_node.h>10274 isl_size isl_schedule_node_get_tree_depth(10275 __isl_keep isl_schedule_node *node);10276 isl_size isl_schedule_node_get_child_position(10277 __isl_keep isl_schedule_node *node);10278 isl_size isl_schedule_node_get_ancestor_child_position(10279 __isl_keep isl_schedule_node *node,10280 __isl_keep isl_schedule_node *ancestor);10281 __isl_give isl_schedule_node *isl_schedule_node_get_child(10282 __isl_keep isl_schedule_node *node, int pos);10283 __isl_give isl_schedule_node *10284 isl_schedule_node_get_shared_ancestor(10285 __isl_keep isl_schedule_node *node1,10286 __isl_keep isl_schedule_node *node2);10287 10288All nodes in a schedule tree or10289all descendants of a specific node (including the node) can be visited10290in depth-first pre-order using the following functions.10291 10292 #include <isl/schedule.h>10293 isl_stat isl_schedule_foreach_schedule_node_top_down(10294 __isl_keep isl_schedule *sched,10295 isl_bool (*fn)(__isl_keep isl_schedule_node *node,10296 void *user), void *user);10297 10298 #include <isl/schedule_node.h>10299 isl_stat isl_schedule_node_foreach_descendant_top_down(10300 __isl_keep isl_schedule_node *node,10301 isl_bool (*fn)(__isl_keep isl_schedule_node *node,10302 void *user), void *user);10303 10304The callback function is slightly different from the usual10305callbacks in that it not only indicates success (non-negative result)10306or failure (negative result), but also indicates whether the children10307of the given node should be visited. In particular, if the callback10308returns a positive value, then the children are visited, but if10309the callback returns zero, then the children are not visited.10310 10311The following functions checks whether10312all descendants of a specific node (including the node itself)10313satisfy a user-specified test.10314 10315 #include <isl/schedule_node.h>10316 isl_bool isl_schedule_node_every_descendant(10317 __isl_keep isl_schedule_node *node,10318 isl_bool (*test)(__isl_keep isl_schedule_node *node,10319 void *user), void *user)10320 10321The ancestors of a node in a schedule tree can be visited from10322the root down to and including the parent of the node using10323the following function.10324 10325 #include <isl/schedule_node.h>10326 isl_stat isl_schedule_node_foreach_ancestor_top_down(10327 __isl_keep isl_schedule_node *node,10328 isl_stat (*fn)(__isl_keep isl_schedule_node *node,10329 void *user), void *user);10330 10331The following functions allows for a depth-first post-order10332traversal of the nodes in a schedule tree or10333of the descendants of a specific node (including the node10334itself), where the user callback is allowed to modify the10335visited node.10336 10337 #include <isl/schedule.h>10338 __isl_give isl_schedule *10339 isl_schedule_map_schedule_node_bottom_up(10340 __isl_take isl_schedule *schedule,10341 __isl_give isl_schedule_node *(*fn)(10342 __isl_take isl_schedule_node *node,10343 void *user), void *user);10344 10345 #include <isl/schedule_node.h>10346 __isl_give isl_schedule_node *10347 isl_schedule_node_map_descendant_bottom_up(10348 __isl_take isl_schedule_node *node,10349 __isl_give isl_schedule_node *(*fn)(10350 __isl_take isl_schedule_node *node,10351 void *user), void *user);10352 10353The traversal continues from the node returned by the callback function.10354It is the responsibility of the user to ensure that this does not10355lead to an infinite loop. It is safest to always return a pointer10356to the same position (same ancestors and child positions) as the input node.10357 10358The following function removes a node (along with its descendants)10359from a schedule tree and returns a pointer to the leaf at the10360same position in the updated tree.10361It is not allowed to remove the root of a schedule tree or10362a child of a set or sequence node.10363 10364 #include <isl/schedule_node.h>10365 __isl_give isl_schedule_node *isl_schedule_node_cut(10366 __isl_take isl_schedule_node *node);10367 10368The following function removes a single node10369from a schedule tree and returns a pointer to the child10370of the node, now located at the position of the original node10371or to a leaf node at that position if there was no child.10372It is not allowed to remove the root of a schedule tree,10373a set or sequence node, a child of a set or sequence node or10374a band node with an anchored subtree.10375 10376 #include <isl/schedule_node.h>10377 __isl_give isl_schedule_node *isl_schedule_node_delete(10378 __isl_take isl_schedule_node *node);10379 10380Most nodes in a schedule tree only contain local information.10381In some cases, however, a node may also refer to the schedule dimensions10382of its outer band nodes.10383This means that the position of the node within the tree should10384not be changed, or at least that no changes are performed to the10385outer band nodes. The following function can be used to test10386whether the subtree rooted at a given node contains any such nodes.10387 10388 #include <isl/schedule_node.h>10389 isl_bool isl_schedule_node_is_subtree_anchored(10390 __isl_keep isl_schedule_node *node);10391 10392The following function resets the user pointers on all parameter10393and tuple identifiers referenced by the given schedule node.10394 10395 #include <isl/schedule_node.h>10396 __isl_give isl_schedule_node *isl_schedule_node_reset_user(10397 __isl_take isl_schedule_node *node);10398 10399The following function aligns the parameters of the given schedule10400node to the given space.10401 10402 #include <isl/schedule_node.h>10403 __isl_give isl_schedule_node *10404 isl_schedule_node_align_params(10405 __isl_take isl_schedule_node *node,10406 __isl_take isl_space *space);10407 10408Several node types have their own functions for querying10409(and in some cases setting) some node type specific properties.10410 10411 #include <isl/schedule_node.h>10412 __isl_give isl_space *isl_schedule_node_band_get_space(10413 __isl_keep isl_schedule_node *node);10414 __isl_give isl_multi_union_pw_aff *10415 isl_schedule_node_band_get_partial_schedule(10416 __isl_keep isl_schedule_node *node);10417 __isl_give isl_union_map *10418 isl_schedule_node_band_get_partial_schedule_union_map(10419 __isl_keep isl_schedule_node *node);10420 isl_size isl_schedule_node_band_n_member(10421 __isl_keep isl_schedule_node *node);10422 isl_bool isl_schedule_node_band_member_get_coincident(10423 __isl_keep isl_schedule_node *node, int pos);10424 __isl_give isl_schedule_node *10425 isl_schedule_node_band_member_set_coincident(10426 __isl_take isl_schedule_node *node, int pos,10427 int coincident);10428 isl_bool isl_schedule_node_band_get_permutable(10429 __isl_keep isl_schedule_node *node);10430 __isl_give isl_schedule_node *10431 isl_schedule_node_band_set_permutable(10432 __isl_take isl_schedule_node *node, int permutable);10433 enum isl_ast_loop_type10434 isl_schedule_node_band_member_get_ast_loop_type(10435 __isl_keep isl_schedule_node *node, int pos);10436 __isl_give isl_schedule_node *10437 isl_schedule_node_band_member_set_ast_loop_type(10438 __isl_take isl_schedule_node *node, int pos,10439 enum isl_ast_loop_type type);10440 enum isl_ast_loop_type10441 isl_schedule_node_band_member_get_isolate_ast_loop_type(10442 __isl_keep isl_schedule_node *node, int pos);10443 __isl_give isl_schedule_node *10444 isl_schedule_node_band_member_set_isolate_ast_loop_type(10445 __isl_take isl_schedule_node *node, int pos,10446 enum isl_ast_loop_type type);10447 __isl_give isl_union_set *10448 isl_schedule_node_band_get_ast_build_options(10449 __isl_keep isl_schedule_node *node);10450 __isl_give isl_schedule_node *10451 isl_schedule_node_band_set_ast_build_options(10452 __isl_take isl_schedule_node *node,10453 __isl_take isl_union_set *options);10454 __isl_give isl_set *10455 isl_schedule_node_band_get_ast_isolate_option(10456 __isl_keep isl_schedule_node *node);10457 10458The function C<isl_schedule_node_band_get_space> returns the space10459of the partial schedule of the band.10460The function C<isl_schedule_node_band_get_partial_schedule_union_map>10461returns a representation of the partial schedule of the band node10462in the form of an C<isl_union_map>.10463The coincident and permutable properties are set by10464C<isl_schedule_constraints_compute_schedule> on the schedule tree10465it produces.10466A scheduling dimension is considered to be ``coincident''10467if it satisfies the coincidence constraints within its band.10468That is, if the dependence distances of the coincidence10469constraints are all zero in that direction (for fixed10470iterations of outer bands).10471A band is marked permutable if it was produced using the Pluto-like scheduler.10472Note that the scheduler may have to resort to a Feautrier style scheduling10473step even if the default scheduler is used.10474An C<isl_ast_loop_type> is one of C<isl_ast_loop_default>,10475C<isl_ast_loop_atomic>, C<isl_ast_loop_unroll> or C<isl_ast_loop_separate>.10476For the meaning of these loop AST generation types and the difference10477between the regular loop AST generation type and the isolate10478loop AST generation type, see L</"AST Generation Options (Schedule Tree)">.10479The functions C<isl_schedule_node_band_member_get_ast_loop_type>10480and C<isl_schedule_node_band_member_get_isolate_ast_loop_type>10481may return C<isl_ast_loop_error> if an error occurs.10482The AST build options govern how an AST is generated for10483the individual schedule dimensions during AST generation.10484See L</"AST Generation Options (Schedule Tree)">.10485The isolate option for the given node can be extracted from these10486AST build options using the function10487C<isl_schedule_node_band_get_ast_isolate_option>.10488 10489 #include <isl/schedule_node.h>10490 __isl_give isl_set *10491 isl_schedule_node_context_get_context(10492 __isl_keep isl_schedule_node *node);10493 10494 #include <isl/schedule_node.h>10495 __isl_give isl_union_set *10496 isl_schedule_node_domain_get_domain(10497 __isl_keep isl_schedule_node *node);10498 10499 #include <isl/schedule_node.h>10500 __isl_give isl_union_map *10501 isl_schedule_node_expansion_get_expansion(10502 __isl_keep isl_schedule_node *node);10503 __isl_give isl_union_pw_multi_aff *10504 isl_schedule_node_expansion_get_contraction(10505 __isl_keep isl_schedule_node *node);10506 10507 #include <isl/schedule_node.h>10508 __isl_give isl_union_map *10509 isl_schedule_node_extension_get_extension(10510 __isl_keep isl_schedule_node *node);10511 10512 #include <isl/schedule_node.h>10513 __isl_give isl_union_set *10514 isl_schedule_node_filter_get_filter(10515 __isl_keep isl_schedule_node *node);10516 10517 #include <isl/schedule_node.h>10518 __isl_give isl_set *isl_schedule_node_guard_get_guard(10519 __isl_keep isl_schedule_node *node);10520 10521 #include <isl/schedule_node.h>10522 __isl_give isl_id *isl_schedule_node_mark_get_id(10523 __isl_keep isl_schedule_node *node);10524 10525The following functions can be used to obtain an C<isl_multi_union_pw_aff>,10526an C<isl_union_pw_multi_aff> or C<isl_union_map> representation of10527partial schedules related to the node.10528 10529 #include <isl/schedule_node.h>10530 __isl_give isl_multi_union_pw_aff *10531 isl_schedule_node_get_prefix_schedule_multi_union_pw_aff(10532 __isl_keep isl_schedule_node *node);10533 __isl_give isl_union_pw_multi_aff *10534 isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(10535 __isl_keep isl_schedule_node *node);10536 __isl_give isl_union_map *10537 isl_schedule_node_get_prefix_schedule_union_map(10538 __isl_keep isl_schedule_node *node);10539 __isl_give isl_union_map *10540 isl_schedule_node_get_prefix_schedule_relation(10541 __isl_keep isl_schedule_node *node);10542 __isl_give isl_union_map *10543 isl_schedule_node_get_subtree_schedule_union_map(10544 __isl_keep isl_schedule_node *node);10545 10546In particular, the functions10547C<isl_schedule_node_get_prefix_schedule_multi_union_pw_aff>,10548C<isl_schedule_node_get_prefix_schedule_union_pw_multi_aff>10549and C<isl_schedule_node_get_prefix_schedule_union_map>10550return a relative ordering on the domain elements that reach the given10551node determined by its ancestors.10552The function C<isl_schedule_node_get_prefix_schedule_relation>10553additionally includes the domain constraints in the result.10554The function C<isl_schedule_node_get_subtree_schedule_union_map>10555returns a representation of the partial schedule defined by the10556subtree rooted at the given node.10557If the tree contains any expansion nodes, then the subtree schedule10558is formulated in terms of the expanded domain elements.10559The tree passed to functions returning a prefix schedule10560may only contain extension nodes if these would not affect10561the result of these functions. That is, if one of the ancestors10562is an extension node, then all of the domain elements that were10563added by the extension node need to have been filtered out10564by filter nodes between the extension node and the input node.10565The tree passed to C<isl_schedule_node_get_subtree_schedule_union_map>10566may not contain in extension nodes in the selected subtree.10567 10568The expansion/contraction defined by an entire subtree, combining10569the expansions/contractions10570on the expansion nodes in the subtree, can be obtained using10571the following functions.10572 10573 #include <isl/schedule_node.h>10574 __isl_give isl_union_map *10575 isl_schedule_node_get_subtree_expansion(10576 __isl_keep isl_schedule_node *node);10577 __isl_give isl_union_pw_multi_aff *10578 isl_schedule_node_get_subtree_contraction(10579 __isl_keep isl_schedule_node *node);10580 10581The total number of outer band members of given node, i.e.,10582the shared output dimension of the maps in the result10583of C<isl_schedule_node_get_prefix_schedule_union_map> can be obtained10584using the following function.10585 10586 #include <isl/schedule_node.h>10587 isl_size isl_schedule_node_get_schedule_depth(10588 __isl_keep isl_schedule_node *node);10589 10590The following functions return the elements that reach the given node10591or the union of universes in the spaces that contain these elements.10592 10593 #include <isl/schedule_node.h>10594 __isl_give isl_union_set *10595 isl_schedule_node_get_domain(10596 __isl_keep isl_schedule_node *node);10597 __isl_give isl_union_set *10598 isl_schedule_node_get_universe_domain(10599 __isl_keep isl_schedule_node *node);10600 10601The input tree of C<isl_schedule_node_get_domain>10602may only contain extension nodes if these would not affect10603the result of this function. That is, if one of the ancestors10604is an extension node, then all of the domain elements that were10605added by the extension node need to have been filtered out10606by filter nodes between the extension node and the input node.10607 10608The following functions can be used to introduce additional nodes10609in the schedule tree. The new node is introduced at the point10610in the tree where the C<isl_schedule_node> points to and10611the results points to the new node.10612 10613 #include <isl/schedule_node.h>10614 __isl_give isl_schedule_node *10615 isl_schedule_node_insert_partial_schedule(10616 __isl_take isl_schedule_node *node,10617 __isl_take isl_multi_union_pw_aff *schedule);10618 10619This function inserts a new band node with (the greatest integer10620part of) the given partial schedule.10621The subtree rooted at the given node is assumed not to have10622any anchored nodes.10623 10624 #include <isl/schedule_node.h>10625 __isl_give isl_schedule_node *10626 isl_schedule_node_insert_context(10627 __isl_take isl_schedule_node *node,10628 __isl_take isl_set *context);10629 10630This function inserts a new context node with the given context constraints.10631 10632 #include <isl/schedule_node.h>10633 __isl_give isl_schedule_node *10634 isl_schedule_node_insert_filter(10635 __isl_take isl_schedule_node *node,10636 __isl_take isl_union_set *filter);10637 10638This function inserts a new filter node with the given filter.10639If the original node already pointed to a filter node, then the10640two filter nodes are merged into one.10641 10642 #include <isl/schedule_node.h>10643 __isl_give isl_schedule_node *10644 isl_schedule_node_insert_guard(10645 __isl_take isl_schedule_node *node,10646 __isl_take isl_set *guard);10647 10648This function inserts a new guard node with the given guard constraints.10649 10650 #include <isl/schedule_node.h>10651 __isl_give isl_schedule_node *10652 isl_schedule_node_insert_mark(10653 __isl_take isl_schedule_node *node,10654 __isl_take isl_id *mark);10655 10656This function inserts a new mark node with the give mark identifier.10657 10658 #include <isl/schedule_node.h>10659 __isl_give isl_schedule_node *10660 isl_schedule_node_insert_sequence(10661 __isl_take isl_schedule_node *node,10662 __isl_take isl_union_set_list *filters);10663 __isl_give isl_schedule_node *10664 isl_schedule_node_insert_set(10665 __isl_take isl_schedule_node *node,10666 __isl_take isl_union_set_list *filters);10667 10668These functions insert a new sequence or set node with the given10669filters as children.10670 10671 #include <isl/schedule_node.h>10672 __isl_give isl_schedule_node *isl_schedule_node_group(10673 __isl_take isl_schedule_node *node,10674 __isl_take isl_id *group_id);10675 10676This function introduces an expansion node in between the current10677node and its parent that expands instances of a space with tuple10678identifier C<group_id> to the original domain elements that reach10679the node. The group instances are identified by the prefix schedule10680of those domain elements. The ancestors of the node are adjusted10681to refer to the group instances instead of the original domain10682elements. The return value points to the same node in the updated10683schedule tree as the input node, i.e., to the child of the newly10684introduced expansion node. Grouping instances of different statements10685ensures that they will be treated as a single statement by the10686AST generator up to the point of the expansion node.10687 10688The following functions can be used to flatten a nested10689sequence.10690 10691 #include <isl/schedule_node.h>10692 __isl_give isl_schedule_node *10693 isl_schedule_node_sequence_splice_child(10694 __isl_take isl_schedule_node *node, int pos);10695 __isl_give isl_schedule_node *10696 isl_schedule_node_sequence_splice_children(10697 __isl_take isl_schedule_node *node);10698 10699That is, given a sequence node C<node> that has another sequence node10700in its child at position C<pos> (in particular, the child of that filter10701node is a sequence node), the function10702C<isl_schedule_node_sequence_splice_child>10703attaches the children of that other sequence10704node as children of C<node>, replacing the original child at position10705C<pos>.10706C<isl_schedule_node_sequence_splice_children> does this for all10707such children.10708 10709The partial schedule of a band node can be scaled (down) or reduced using10710the following functions.10711 10712 #include <isl/schedule_node.h>10713 __isl_give isl_schedule_node *10714 isl_schedule_node_band_scale(10715 __isl_take isl_schedule_node *node,10716 __isl_take isl_multi_val *mv);10717 __isl_give isl_schedule_node *10718 isl_schedule_node_band_scale_down(10719 __isl_take isl_schedule_node *node,10720 __isl_take isl_multi_val *mv);10721 __isl_give isl_schedule_node *10722 isl_schedule_node_band_mod(10723 __isl_take isl_schedule_node *node,10724 __isl_take isl_multi_val *mv);10725 10726The spaces of the two arguments need to match.10727After scaling, the partial schedule is replaced by its greatest10728integer part to ensure that the schedule remains integral.10729 10730The partial schedule of a band node can be shifted by an10731C<isl_multi_union_pw_aff> with a domain that is a superset10732of the domain of the partial schedule using10733the following function.10734 10735 #include <isl/schedule_node.h>10736 __isl_give isl_schedule_node *10737 isl_schedule_node_band_shift(10738 __isl_take isl_schedule_node *node,10739 __isl_take isl_multi_union_pw_aff *shift);10740 10741A band node can be tiled using the following function.10742 10743 #include <isl/schedule_node.h>10744 __isl_give isl_schedule_node *isl_schedule_node_band_tile(10745 __isl_take isl_schedule_node *node,10746 __isl_take isl_multi_val *sizes);10747 10748 isl_stat isl_options_set_tile_scale_tile_loops(isl_ctx *ctx,10749 int val);10750 int isl_options_get_tile_scale_tile_loops(isl_ctx *ctx);10751 isl_stat isl_options_set_tile_shift_point_loops(isl_ctx *ctx,10752 int val);10753 int isl_options_get_tile_shift_point_loops(isl_ctx *ctx);10754 10755The C<isl_schedule_node_band_tile> function tiles10756the band using the given tile sizes inside its schedule.10757A new child band node is created to represent the point loops and it is10758inserted between the modified band and its children.10759The subtree rooted at the given node is assumed not to have10760any anchored nodes.10761The C<tile_scale_tile_loops> option specifies whether the tile10762loops iterators should be scaled by the tile sizes.10763If the C<tile_shift_point_loops> option is set, then the point loops10764are shifted to start at zero.10765 10766A band node can be split into two nested band nodes10767using the following function.10768 10769 #include <isl/schedule_node.h>10770 __isl_give isl_schedule_node *isl_schedule_node_band_split(10771 __isl_take isl_schedule_node *node, int pos);10772 10773The resulting outer band node contains the first C<pos> dimensions of10774the schedule of C<node> while the inner band contains the remaining dimensions.10775The schedules of the two band nodes live in anonymous spaces.10776The loop AST generation type options and the isolate option10777are split over the two band nodes.10778 10779A band node can be moved down to the leaves of the subtree rooted10780at the band node using the following function.10781 10782 #include <isl/schedule_node.h>10783 __isl_give isl_schedule_node *isl_schedule_node_band_sink(10784 __isl_take isl_schedule_node *node);10785 10786The subtree rooted at the given node is assumed not to have10787any anchored nodes.10788The result points to the node in the resulting tree that is in the same10789position as the node pointed to by C<node> in the original tree.10790 10791 #include <isl/schedule_node.h>10792 __isl_give isl_schedule_node *10793 isl_schedule_node_order_before(10794 __isl_take isl_schedule_node *node,10795 __isl_take isl_union_set *filter);10796 __isl_give isl_schedule_node *10797 isl_schedule_node_order_after(10798 __isl_take isl_schedule_node *node,10799 __isl_take isl_union_set *filter);10800 10801These functions split the domain elements that reach C<node>10802into those that satisfy C<filter> and those that do not and10803arranges for the elements that do satisfy the filter to be10804executed before (in case of C<isl_schedule_node_order_before>)10805or after (in case of C<isl_schedule_node_order_after>)10806those that do not. The order is imposed by10807a sequence node, possibly reusing the grandparent of C<node>10808on two copies of the subtree attached to the original C<node>.10809Both copies are simplified with respect to their filter.10810 10811Return a pointer to the copy of the subtree that does not10812satisfy C<filter>. If there is no such copy (because all10813reaching domain elements satisfy the filter), then return10814the original pointer.10815 10816 #include <isl/schedule_node.h>10817 __isl_give isl_schedule_node *10818 isl_schedule_node_graft_before(10819 __isl_take isl_schedule_node *node,10820 __isl_take isl_schedule_node *graft);10821 __isl_give isl_schedule_node *10822 isl_schedule_node_graft_after(10823 __isl_take isl_schedule_node *node,10824 __isl_take isl_schedule_node *graft);10825 10826This function inserts the C<graft> tree into the tree containing C<node>10827such that it is executed before (in case of C<isl_schedule_node_graft_before>)10828or after (in case of C<isl_schedule_node_graft_after>) C<node>.10829The root node of C<graft>10830should be an extension node where the domain of the extension10831is the flat product of all outer band nodes of C<node>.10832The root node may also be a domain node.10833The elements of the domain or the range of the extension may not10834intersect with the domain elements that reach "node".10835The schedule tree of C<graft> may not be anchored.10836 10837The schedule tree of C<node> is modified to include an extension node10838corresponding to the root node of C<graft> as a child of the original10839parent of C<node>. The original node that C<node> points to and the10840child of the root node of C<graft> are attached to this extension node10841through a sequence, with appropriate filters and with the child10842of C<graft> appearing before or after the original C<node>.10843 10844If C<node> already appears inside a sequence that is the child of10845an extension node and if the spaces of the new domain elements10846do not overlap with those of the original domain elements,10847then that extension node is extended with the new extension10848rather than introducing a new segment of extension and sequence nodes.10849 10850Return a pointer to the same node in the modified tree that10851C<node> pointed to in the original tree.10852 10853A representation of the schedule node can be printed using10854 10855 #include <isl/schedule_node.h>10856 __isl_give isl_printer *isl_printer_print_schedule_node(10857 __isl_take isl_printer *p,10858 __isl_keep isl_schedule_node *node);10859 __isl_give char *isl_schedule_node_to_str(10860 __isl_keep isl_schedule_node *node);10861 10862C<isl_schedule_node_to_str> prints the schedule node in block format.10863 10864=head2 Dependence Analysis10865 10866C<isl> contains specialized functionality for performing10867array dataflow analysis. That is, given a I<sink> access relation,10868a collection of possible I<source> accesses and10869a collection of I<kill> accesses,10870C<isl> can compute relations that describe10871for each iteration of the sink access, which iterations10872of which of the source access relations may have10873accessed the same data element before the given iteration10874of the sink access without any intermediate kill of that data element.10875The resulting dependence relations map source iterations10876to either the corresponding sink iterations or10877pairs of corresponding sink iterations and accessed data elements.10878To compute standard flow dependences, the sink should be10879a read, while the sources should be writes.10880If no kills are specified,10881then memory based dependence analysis is performed.10882If, on the other hand, all sources are also kills,10883then value based dependence analysis is performed.10884If any of the source accesses are marked as being I<must>10885accesses, then they are also treated as kills.10886Furthermore, the specification of must-sources results10887in the computation of must-dependences.10888Only dependences originating in a must access not coscheduled10889with any other access to the same element and without10890any may accesses between the must access and the sink access10891are considered to be must dependences.10892 10893=head3 High-level Interface10894 10895A high-level interface to dependence analysis is provided10896by the following function.10897 10898 #include <isl/flow.h>10899 __isl_give isl_union_flow *10900 isl_union_access_info_compute_flow(10901 __isl_take isl_union_access_info *access);10902 10903The input C<isl_union_access_info> object describes the sink10904access relations, the source access relations and a schedule,10905while the output C<isl_union_flow> object describes10906the resulting dependence relations and the subsets of the10907sink relations for which no source was found.10908 10909An C<isl_union_access_info> is created, modified, copied and freed using10910the following functions.10911 10912 #include <isl/flow.h>10913 __isl_give isl_union_access_info *10914 isl_union_access_info_from_sink(10915 __isl_take isl_union_map *sink);10916 __isl_give isl_union_access_info *10917 isl_union_access_info_set_kill(10918 __isl_take isl_union_access_info *access,10919 __isl_take isl_union_map *kill);10920 __isl_give isl_union_access_info *10921 isl_union_access_info_set_may_source(10922 __isl_take isl_union_access_info *access,10923 __isl_take isl_union_map *may_source);10924 __isl_give isl_union_access_info *10925 isl_union_access_info_set_must_source(10926 __isl_take isl_union_access_info *access,10927 __isl_take isl_union_map *must_source);10928 __isl_give isl_union_access_info *10929 isl_union_access_info_set_schedule(10930 __isl_take isl_union_access_info *access,10931 __isl_take isl_schedule *schedule);10932 __isl_give isl_union_access_info *10933 isl_union_access_info_set_schedule_map(10934 __isl_take isl_union_access_info *access,10935 __isl_take isl_union_map *schedule_map);10936 __isl_give isl_union_access_info *10937 isl_union_access_info_copy(10938 __isl_keep isl_union_access_info *access);10939 __isl_null isl_union_access_info *10940 isl_union_access_info_free(10941 __isl_take isl_union_access_info *access);10942 10943The may sources set by C<isl_union_access_info_set_may_source>10944do not need to include the must sources set by10945C<isl_union_access_info_set_must_source> as a subset.10946The kills set by C<isl_union_access_info_set_kill> may overlap10947with the may-sources and/or must-sources.10948The user is free not to call one (or more) of these functions,10949in which case the corresponding set is kept to its empty default.10950Similarly, the default schedule initialized by10951C<isl_union_access_info_from_sink> is empty.10952The current schedule is determined by the last call to either10953C<isl_union_access_info_set_schedule> or10954C<isl_union_access_info_set_schedule_map>.10955The domain of the schedule corresponds to the domains of10956the access relations. In particular, the domains of the access10957relations are effectively intersected with the domain of the schedule10958and only the resulting accesses are considered by the dependence analysis.10959 10960An C<isl_union_access_info> object can be read from input10961using the following function.10962 10963 #include <isl/flow.h>10964 __isl_give isl_union_access_info *10965 isl_union_access_info_read_from_file(isl_ctx *ctx,10966 FILE *input);10967 10968A representation of the information contained in an object10969of type C<isl_union_access_info> can be obtained using10970 10971 #include <isl/flow.h>10972 __isl_give isl_printer *10973 isl_printer_print_union_access_info(10974 __isl_take isl_printer *p,10975 __isl_keep isl_union_access_info *access);10976 __isl_give char *isl_union_access_info_to_str(10977 __isl_keep isl_union_access_info *access);10978 10979C<isl_union_access_info_to_str> prints the information in flow format.10980 10981The output of C<isl_union_access_info_compute_flow> can be examined,10982copied, and freed using the following functions.10983 10984 #include <isl/flow.h>10985 __isl_give isl_union_map *isl_union_flow_get_must_dependence(10986 __isl_keep isl_union_flow *flow);10987 __isl_give isl_union_map *isl_union_flow_get_may_dependence(10988 __isl_keep isl_union_flow *flow);10989 __isl_give isl_union_map *10990 isl_union_flow_get_full_must_dependence(10991 __isl_keep isl_union_flow *flow);10992 __isl_give isl_union_map *10993 isl_union_flow_get_full_may_dependence(10994 __isl_keep isl_union_flow *flow);10995 __isl_give isl_union_map *isl_union_flow_get_must_no_source(10996 __isl_keep isl_union_flow *flow);10997 __isl_give isl_union_map *isl_union_flow_get_may_no_source(10998 __isl_keep isl_union_flow *flow);10999 __isl_give isl_union_flow *isl_union_flow_copy(11000 __isl_keep isl_union_flow *flow);11001 __isl_null isl_union_flow *isl_union_flow_free(11002 __isl_take isl_union_flow *flow);11003 11004The relation returned by C<isl_union_flow_get_must_dependence>11005relates domain elements of must sources to domain elements of the sink.11006The relation returned by C<isl_union_flow_get_may_dependence>11007relates domain elements of must or may sources to domain elements of the sink11008and includes the previous relation as a subset.11009The relation returned by C<isl_union_flow_get_full_must_dependence>11010relates domain elements of must sources to pairs of domain elements of the sink11011and accessed data elements.11012The relation returned by C<isl_union_flow_get_full_may_dependence>11013relates domain elements of must or may sources to pairs of11014domain elements of the sink and accessed data elements.11015This relation includes the previous relation as a subset.11016The relation returned by C<isl_union_flow_get_must_no_source> is the subset11017of the sink relation for which no dependences have been found.11018The relation returned by C<isl_union_flow_get_may_no_source> is the subset11019of the sink relation for which no definite dependences have been found.11020That is, it contains those sink access that do not contribute to any11021of the elements in the relation returned11022by C<isl_union_flow_get_must_dependence>.11023 11024A representation of the information contained in an object11025of type C<isl_union_flow> can be obtained using11026 11027 #include <isl/flow.h>11028 __isl_give isl_printer *isl_printer_print_union_flow(11029 __isl_take isl_printer *p,11030 __isl_keep isl_union_flow *flow);11031 __isl_give char *isl_union_flow_to_str(11032 __isl_keep isl_union_flow *flow);11033 11034C<isl_union_flow_to_str> prints the information in flow format.11035 11036=head3 Low-level Interface11037 11038A lower-level interface is provided by the following functions.11039 11040 #include <isl/flow.h>11041 11042 typedef int (*isl_access_level_before)(void *first, void *second);11043 11044 __isl_give isl_access_info *isl_access_info_alloc(11045 __isl_take isl_map *sink,11046 void *sink_user, isl_access_level_before fn,11047 int max_source);11048 __isl_give isl_access_info *isl_access_info_add_source(11049 __isl_take isl_access_info *acc,11050 __isl_take isl_map *source, int must,11051 void *source_user);11052 __isl_null isl_access_info *isl_access_info_free(11053 __isl_take isl_access_info *acc);11054 11055 __isl_give isl_flow *isl_access_info_compute_flow(11056 __isl_take isl_access_info *acc);11057 11058 isl_stat isl_flow_foreach(__isl_keep isl_flow *deps,11059 isl_stat (*fn)(__isl_take isl_map *dep, int must,11060 void *dep_user, void *user),11061 void *user);11062 __isl_give isl_map *isl_flow_get_no_source(11063 __isl_keep isl_flow *deps, int must);11064 __isl_null isl_flow *isl_flow_free(11065 __isl_take isl_flow *deps);11066 11067The function C<isl_access_info_compute_flow> performs the actual11068dependence analysis. The other functions are used to construct11069the input for this function or to read off the output.11070 11071The input is collected in an C<isl_access_info>, which can11072be created through a call to C<isl_access_info_alloc>.11073The arguments to this functions are the sink access relation11074C<sink>, a token C<sink_user> used to identify the sink11075access to the user, a callback function for specifying the11076relative order of source and sink accesses, and the number11077of source access relations that will be added.11078 11079The callback function has type C<int (*)(void *first, void *second)>.11080The function is called with two user supplied tokens identifying11081either a source or the sink and it should return the shared nesting11082level and the relative order of the two accesses.11083In particular, let I<n> be the number of loops shared by11084the two accesses. If C<first> precedes C<second> textually,11085then the function should return I<2 * n + 1>; otherwise,11086it should return I<2 * n>.11087The low-level interface assumes that no sources are coscheduled.11088If the information returned by the callback does not allow11089the relative order to be determined, then one of the sources11090is arbitrarily taken to be executed after the other(s).11091 11092The sources can be added to the C<isl_access_info> object by performing11093(at most) C<max_source> calls to C<isl_access_info_add_source>.11094C<must> indicates whether the source is a I<must> access11095or a I<may> access. Note that a multi-valued access relation11096should only be marked I<must> if every iteration in the domain11097of the relation accesses I<all> elements in its image.11098The C<source_user> token is again used to identify11099the source access. The range of the source access relation11100C<source> should have the same dimension as the range11101of the sink access relation.11102The C<isl_access_info_free> function should usually not be11103called explicitly, because it is already called implicitly by11104C<isl_access_info_compute_flow>.11105 11106The result of the dependence analysis is collected in an11107C<isl_flow>. There may be elements of11108the sink access for which no preceding source access could be11109found or for which all preceding sources are I<may> accesses.11110The relations containing these elements can be obtained through11111calls to C<isl_flow_get_no_source>, the first with C<must> set11112and the second with C<must> unset.11113In the case of standard flow dependence analysis,11114with the sink a read and the sources I<must> writes,11115the first relation corresponds to the reads from uninitialized11116array elements and the second relation is empty.11117The actual flow dependences can be extracted using11118C<isl_flow_foreach>. This function will call the user-specified11119callback function C<fn> for each B<non-empty> dependence between11120a source and the sink. The callback function is called11121with four arguments, the actual flow dependence relation11122mapping source iterations to sink iterations, a boolean that11123indicates whether it is a I<must> or I<may> dependence, a token11124identifying the source and an additional C<void *> with value11125equal to the third argument of the C<isl_flow_foreach> call.11126A dependence is marked I<must> if it originates from a I<must>11127source and if it is not followed by any I<may> sources.11128 11129After finishing with an C<isl_flow>, the user should call11130C<isl_flow_free> to free all associated memory.11131 11132=head3 Interaction with the Low-level Interface11133 11134During the dependence analysis, we frequently need to perform11135the following operation. Given a relation between sink iterations11136and potential source iterations from a particular source domain,11137what is the last potential source iteration corresponding to each11138sink iteration. It can sometimes be convenient to adjust11139the set of potential source iterations before or after each such operation.11140The prototypical example is fuzzy array dataflow analysis,11141where we need to analyze if, based on data-dependent constraints,11142the sink iteration can ever be executed without one or more of11143the corresponding potential source iterations being executed.11144If so, we can introduce extra parameters and select an unknown11145but fixed source iteration from the potential source iterations.11146To be able to perform such manipulations, C<isl> provides the following11147function.11148 11149 #include <isl/flow.h>11150 11151 typedef __isl_give isl_restriction *(*isl_access_restrict)(11152 __isl_keep isl_map *source_map,11153 __isl_keep isl_set *sink, void *source_user,11154 void *user);11155 __isl_give isl_access_info *isl_access_info_set_restrict(11156 __isl_take isl_access_info *acc,11157 isl_access_restrict fn, void *user);11158 11159The function C<isl_access_info_set_restrict> should be called11160before calling C<isl_access_info_compute_flow> and registers a callback function11161that will be called any time C<isl> is about to compute the last11162potential source. The first argument is the (reverse) proto-dependence,11163mapping sink iterations to potential source iterations.11164The second argument represents the sink iterations for which11165we want to compute the last source iteration.11166The third argument is the token corresponding to the source11167and the final argument is the token passed to C<isl_access_info_set_restrict>.11168The callback is expected to return a restriction on either the input or11169the output of the operation computing the last potential source.11170If the input needs to be restricted then restrictions are needed11171for both the source and the sink iterations. The sink iterations11172and the potential source iterations will be intersected with these sets.11173If the output needs to be restricted then only a restriction on the source11174iterations is required.11175If any error occurs, the callback should return C<NULL>.11176An C<isl_restriction> object can be created, freed and inspected11177using the following functions.11178 11179 #include <isl/flow.h>11180 11181 __isl_give isl_restriction *isl_restriction_input(11182 __isl_take isl_set *source_restr,11183 __isl_take isl_set *sink_restr);11184 __isl_give isl_restriction *isl_restriction_output(11185 __isl_take isl_set *source_restr);11186 __isl_give isl_restriction *isl_restriction_none(11187 __isl_take isl_map *source_map);11188 __isl_give isl_restriction *isl_restriction_empty(11189 __isl_take isl_map *source_map);11190 __isl_null isl_restriction *isl_restriction_free(11191 __isl_take isl_restriction *restr);11192 11193C<isl_restriction_none> and C<isl_restriction_empty> are special11194cases of C<isl_restriction_input>. C<isl_restriction_none>11195is essentially equivalent to11196 11197 isl_restriction_input(isl_set_universe(11198 isl_space_range(isl_map_get_space(source_map))),11199 isl_set_universe(11200 isl_space_domain(isl_map_get_space(source_map))));11201 11202whereas C<isl_restriction_empty> is essentially equivalent to11203 11204 isl_restriction_input(isl_set_empty(11205 isl_space_range(isl_map_get_space(source_map))),11206 isl_set_universe(11207 isl_space_domain(isl_map_get_space(source_map))));11208 11209=head2 Scheduling11210 11211 #include <isl/schedule.h>11212 __isl_give isl_schedule *11213 isl_schedule_constraints_compute_schedule(11214 __isl_take isl_schedule_constraints *sc);11215 11216The function C<isl_schedule_constraints_compute_schedule> can be11217used to compute a schedule that satisfies the given schedule constraints.11218These schedule constraints include the iteration domain for which11219a schedule should be computed and dependences between pairs of11220iterations. In particular, these dependences include11221I<validity> dependences and I<proximity> dependences.11222By default, the algorithm used to construct the schedule is similar11223to that of C<Pluto>.11224Alternatively, Feautrier's multi-dimensional scheduling algorithm can11225be selected.11226The generated schedule respects all validity dependences.11227That is, all dependence distances over these dependences in the11228scheduled space are lexicographically positive.11229 11230The default algorithm tries to ensure that the dependence distances11231over coincidence constraints are zero and to minimize the11232dependence distances over proximity dependences.11233Moreover, it tries to obtain sequences (bands) of schedule dimensions11234for groups of domains where the dependence distances over validity11235dependences have only non-negative values.11236Note that when minimizing the maximal dependence distance11237over proximity dependences, a single affine expression in the parameters11238is constructed that bounds all dependence distances. If no such expression11239exists, then the algorithm will fail and resort to an alternative11240scheduling algorithm. In particular, this means that adding proximity11241dependences may eliminate valid solutions. A typical example where this11242phenomenon may occur is when some subset of the proximity dependences11243has no restriction on some parameter, forcing the coefficient of that11244parameter to be zero, while some other subset forces the dependence11245distance to depend on that parameter, requiring the same coefficient11246to be non-zero.11247When using Feautrier's algorithm, the coincidence and proximity constraints11248are only taken into account during the extension to a11249full-dimensional schedule.11250 11251An C<isl_schedule_constraints> object can be constructed11252and manipulated using the following functions.11253 11254 #include <isl/schedule.h>11255 __isl_give isl_schedule_constraints *11256 isl_schedule_constraints_copy(11257 __isl_keep isl_schedule_constraints *sc);11258 __isl_give isl_schedule_constraints *11259 isl_schedule_constraints_on_domain(11260 __isl_take isl_union_set *domain);11261 __isl_give isl_schedule_constraints *11262 isl_schedule_constraints_set_context(11263 __isl_take isl_schedule_constraints *sc,11264 __isl_take isl_set *context);11265 __isl_give isl_schedule_constraints *11266 isl_schedule_constraints_set_validity(11267 __isl_take isl_schedule_constraints *sc,11268 __isl_take isl_union_map *validity);11269 __isl_give isl_schedule_constraints *11270 isl_schedule_constraints_set_coincidence(11271 __isl_take isl_schedule_constraints *sc,11272 __isl_take isl_union_map *coincidence);11273 __isl_give isl_schedule_constraints *11274 isl_schedule_constraints_set_proximity(11275 __isl_take isl_schedule_constraints *sc,11276 __isl_take isl_union_map *proximity);11277 __isl_give isl_schedule_constraints *11278 isl_schedule_constraints_set_conditional_validity(11279 __isl_take isl_schedule_constraints *sc,11280 __isl_take isl_union_map *condition,11281 __isl_take isl_union_map *validity);11282 __isl_give isl_schedule_constraints *11283 isl_schedule_constraints_apply(11284 __isl_take isl_schedule_constraints *sc,11285 __isl_take isl_union_map *umap);11286 __isl_null isl_schedule_constraints *11287 isl_schedule_constraints_free(11288 __isl_take isl_schedule_constraints *sc);11289 11290The initial C<isl_schedule_constraints> object created by11291C<isl_schedule_constraints_on_domain> does not impose any constraints.11292That is, it has an empty set of dependences.11293The function C<isl_schedule_constraints_set_context> allows the user11294to specify additional constraints on the parameters that may11295be assumed to hold during the construction of the schedule.11296The function C<isl_schedule_constraints_set_validity> replaces the11297validity dependences, mapping domain elements I<i> to domain11298elements that should be scheduled after I<i>.11299The function C<isl_schedule_constraints_set_coincidence> replaces the11300coincidence dependences, mapping domain elements I<i> to domain11301elements that should be scheduled together with I<I>, if possible.11302The function C<isl_schedule_constraints_set_proximity> replaces the11303proximity dependences, mapping domain elements I<i> to domain11304elements that should be scheduled either before I<I>11305or as early as possible after I<i>.11306 11307The function C<isl_schedule_constraints_set_conditional_validity>11308replaces the conditional validity constraints.11309A conditional validity constraint is only imposed when any of the corresponding11310conditions is satisfied, i.e., when any of them is non-zero.11311That is, the scheduler ensures that within each band if the dependence11312distances over the condition constraints are not all zero11313then all corresponding conditional validity constraints are respected.11314A conditional validity constraint corresponds to a condition11315if the two are adjacent, i.e., if the domain of one relation intersect11316the range of the other relation.11317The typical use case of conditional validity constraints is11318to allow order constraints between live ranges to be violated11319as long as the live ranges themselves are local to the band.11320To allow more fine-grained control over which conditions correspond11321to which conditional validity constraints, the domains and ranges11322of these relations may include I<tags>. That is, the domains and11323ranges of those relation may themselves be wrapped relations11324where the iteration domain appears in the domain of those wrapped relations11325and the range of the wrapped relations can be arbitrarily chosen11326by the user. Conditions and conditional validity constraints are only11327considered adjacent to each other if the entire wrapped relation matches.11328In particular, a relation with a tag will never be considered adjacent11329to a relation without a tag.11330 11331The function C<isl_schedule_constraints_apply> takes11332schedule constraints that are defined on some set of domain elements11333and transforms them to schedule constraints on the elements11334to which these domain elements are mapped by the given transformation.11335 11336An C<isl_schedule_constraints> object can be inspected11337using the following functions.11338 11339 #include <isl/schedule.h>11340 __isl_give isl_union_set *11341 isl_schedule_constraints_get_domain(11342 __isl_keep isl_schedule_constraints *sc);11343 __isl_give isl_set *isl_schedule_constraints_get_context(11344 __isl_keep isl_schedule_constraints *sc);11345 __isl_give isl_union_map *11346 isl_schedule_constraints_get_validity(11347 __isl_keep isl_schedule_constraints *sc);11348 __isl_give isl_union_map *11349 isl_schedule_constraints_get_coincidence(11350 __isl_keep isl_schedule_constraints *sc);11351 __isl_give isl_union_map *11352 isl_schedule_constraints_get_proximity(11353 __isl_keep isl_schedule_constraints *sc);11354 __isl_give isl_union_map *11355 isl_schedule_constraints_get_conditional_validity(11356 __isl_keep isl_schedule_constraints *sc);11357 __isl_give isl_union_map *11358 isl_schedule_constraints_get_conditional_validity_condition(11359 __isl_keep isl_schedule_constraints *sc);11360 11361An C<isl_schedule_constraints> object can be read from input11362using the following functions.11363 11364 #include <isl/schedule.h>11365 __isl_give isl_schedule_constraints *11366 isl_schedule_constraints_read_from_str(isl_ctx *ctx,11367 const char *str);11368 __isl_give isl_schedule_constraints *11369 isl_schedule_constraints_read_from_file(isl_ctx *ctx,11370 FILE *input);11371 11372The contents of an C<isl_schedule_constraints> object can be printed11373using the following functions.11374 11375 #include <isl/schedule.h>11376 __isl_give isl_printer *11377 isl_printer_print_schedule_constraints(11378 __isl_take isl_printer *p,11379 __isl_keep isl_schedule_constraints *sc);11380 __isl_give char *isl_schedule_constraints_to_str(11381 __isl_keep isl_schedule_constraints *sc);11382 11383The following function computes a schedule directly from11384an iteration domain and validity and proximity dependences11385and is implemented in terms of the functions described above.11386The use of C<isl_union_set_compute_schedule> is discouraged.11387 11388 #include <isl/schedule.h>11389 __isl_give isl_schedule *isl_union_set_compute_schedule(11390 __isl_take isl_union_set *domain,11391 __isl_take isl_union_map *validity,11392 __isl_take isl_union_map *proximity);11393 11394The generated schedule represents a schedule tree.11395For more information on schedule trees, see11396L</"Schedule Trees">.11397 11398=head3 Options11399 11400 #include <isl/schedule.h>11401 isl_stat isl_options_set_schedule_max_coefficient(11402 isl_ctx *ctx, int val);11403 int isl_options_get_schedule_max_coefficient(11404 isl_ctx *ctx);11405 isl_stat isl_options_set_schedule_max_constant_term(11406 isl_ctx *ctx, int val);11407 int isl_options_get_schedule_max_constant_term(11408 isl_ctx *ctx);11409 isl_stat isl_options_set_schedule_serialize_sccs(11410 isl_ctx *ctx, int val);11411 int isl_options_get_schedule_serialize_sccs(isl_ctx *ctx);11412 isl_stat isl_options_set_schedule_whole_component(11413 isl_ctx *ctx, int val);11414 int isl_options_get_schedule_whole_component(11415 isl_ctx *ctx);11416 isl_stat isl_options_set_schedule_maximize_band_depth(11417 isl_ctx *ctx, int val);11418 int isl_options_get_schedule_maximize_band_depth(11419 isl_ctx *ctx);11420 isl_stat isl_options_set_schedule_maximize_coincidence(11421 isl_ctx *ctx, int val);11422 int isl_options_get_schedule_maximize_coincidence(11423 isl_ctx *ctx);11424 isl_stat isl_options_set_schedule_outer_coincidence(11425 isl_ctx *ctx, int val);11426 int isl_options_get_schedule_outer_coincidence(11427 isl_ctx *ctx);11428 isl_stat isl_options_set_schedule_split_scaled(11429 isl_ctx *ctx, int val);11430 int isl_options_get_schedule_split_scaled(11431 isl_ctx *ctx);11432 isl_stat isl_options_set_schedule_treat_coalescing(11433 isl_ctx *ctx, int val);11434 int isl_options_get_schedule_treat_coalescing(11435 isl_ctx *ctx);11436 isl_stat isl_options_set_schedule_algorithm(11437 isl_ctx *ctx, int val);11438 int isl_options_get_schedule_algorithm(11439 isl_ctx *ctx);11440 isl_stat isl_options_set_schedule_carry_self_first(11441 isl_ctx *ctx, int val);11442 int isl_options_get_schedule_carry_self_first(11443 isl_ctx *ctx);11444 isl_stat isl_options_set_schedule_separate_components(11445 isl_ctx *ctx, int val);11446 int isl_options_get_schedule_separate_components(11447 isl_ctx *ctx);11448 11449=over11450 11451=item * schedule_max_coefficient11452 11453This option enforces that the coefficients for variable and parameter11454dimensions in the calculated schedule are not larger than the specified value.11455This option can significantly increase the speed of the scheduling calculation11456and may also prevent fusing of unrelated dimensions. A value of -1 means that11457this option does not introduce bounds on the variable or parameter11458coefficients.11459This option has no effect on the Feautrier style scheduler.11460 11461=item * schedule_max_constant_term11462 11463This option enforces that the constant coefficients in the calculated schedule11464are not larger than the maximal constant term. This option can significantly11465increase the speed of the scheduling calculation and may also prevent fusing of11466unrelated dimensions. A value of -1 means that this option does not introduce11467bounds on the constant coefficients.11468 11469=item * schedule_serialize_sccs11470 11471If this option is set, then all strongly connected components11472in the dependence graph are serialized as soon as they are detected.11473This means in particular that instances of statements will only11474appear in the same band node if these statements belong11475to the same strongly connected component at the point where11476the band node is constructed.11477 11478=item * schedule_whole_component11479 11480If this option is set, then entire (weakly) connected11481components in the dependence graph are scheduled together11482as a whole.11483Otherwise, each strongly connected component within11484such a weakly connected component is first scheduled separately11485and then combined with other strongly connected components.11486This option has no effect if C<schedule_serialize_sccs> is set.11487 11488=item * schedule_maximize_band_depth11489 11490If this option is set, then the scheduler tries to maximize11491the width of the bands. Wider bands give more possibilities for tiling.11492In particular, if the C<schedule_whole_component> option is set,11493then bands are split if this might result in wider bands.11494Otherwise, the effect of this option is to only allow11495strongly connected components to be combined if this does11496not reduce the width of the bands.11497Note that if the C<schedule_serialize_sccs> options is set, then11498the C<schedule_maximize_band_depth> option therefore has no effect.11499 11500=item * schedule_maximize_coincidence11501 11502This option is only effective if the C<schedule_whole_component>11503option is turned off.11504If the C<schedule_maximize_coincidence> option is set, then (clusters of)11505strongly connected components are only combined with each other11506if this does not reduce the number of coincident band members.11507 11508=item * schedule_outer_coincidence11509 11510If this option is set, then we try to construct schedules11511where the outermost scheduling dimension in each band11512satisfies the coincidence constraints.11513 11514=item * schedule_algorithm11515 11516Selects the scheduling algorithm to be used.11517Available scheduling algorithms are C<ISL_SCHEDULE_ALGORITHM_ISL>11518and C<ISL_SCHEDULE_ALGORITHM_FEAUTRIER>.11519 11520=item * schedule_split_scaled11521 11522If this option is set, then we try to construct schedules in which the11523constant term is split off from the linear part if the linear parts of11524the scheduling rows for all nodes in the graph have a common non-trivial11525divisor.11526The constant term is then dropped and the linear11527part is reduced.11528This option is only effective when the Feautrier style scheduler is11529being used, either as the main scheduler or as a fallback for the11530Pluto-like scheduler.11531 11532=item * schedule_treat_coalescing11533 11534If this option is set, then the scheduler will try and avoid11535producing schedules that perform loop coalescing.11536In particular, for the Pluto-like scheduler, this option places11537bounds on the schedule coefficients based on the sizes of the instance sets.11538For the Feautrier style scheduler, this option detects potentially11539coalescing schedules and then tries to adjust the schedule to avoid11540the coalescing.11541 11542=item * schedule_carry_self_first11543 11544If this option is set, then the Feautrier style scheduler11545(when used as a fallback for the Pluto-like scheduler) will11546first try to only carry self-dependences.11547 11548=item * schedule_separate_components11549 11550If this option is set then the function C<isl_schedule_get_map>11551will treat set nodes in the same way as sequence nodes.11552 11553=back11554 11555=head2 AST Generation11556 11557This section describes the C<isl> functionality for generating11558ASTs that visit all the elements11559in a domain in an order specified by a schedule tree or11560a schedule map.11561In case the schedule given as a C<isl_union_map>, an AST is generated11562that visits all the elements in the domain of the C<isl_union_map>11563according to the lexicographic order of the corresponding image11564element(s). If the range of the C<isl_union_map> consists of11565elements in more than one space, then each of these spaces is handled11566separately in an arbitrary order.11567It should be noted that the schedule tree or the image elements11568in a schedule map only specify the I<order>11569in which the corresponding domain elements should be visited.11570No direct relation between the partial schedule values11571or the image elements on the one hand and the loop iterators11572in the generated AST on the other hand should be assumed.11573 11574Each AST is generated within a build. The initial build11575simply specifies the constraints on the parameters (if any)11576and can be created, inspected, copied and freed using the following functions.11577 11578 #include <isl/ast_build.h>11579 __isl_give isl_ast_build *isl_ast_build_alloc(11580 isl_ctx *ctx);11581 __isl_give isl_ast_build *isl_ast_build_from_context(11582 __isl_take isl_set *set);11583 __isl_give isl_ast_build *isl_ast_build_copy(11584 __isl_keep isl_ast_build *build);11585 __isl_null isl_ast_build *isl_ast_build_free(11586 __isl_take isl_ast_build *build);11587 11588The C<set> argument is usually a parameter set with zero or more parameters.11589In fact, when creating an AST using C<isl_ast_build_node_from_schedule>,11590this set is required to be a parameter set.11591An C<isl_ast_build> created using C<isl_ast_build_alloc> does not11592specify any parameter constraints.11593More C<isl_ast_build> functions are described in L</"Nested AST Generation">11594and L</"Fine-grained Control over AST Generation">.11595Finally, the AST itself can be constructed using one of the following11596functions.11597 11598 #include <isl/ast_build.h>11599 __isl_give isl_ast_node *isl_ast_build_node_from_schedule(11600 __isl_keep isl_ast_build *build,11601 __isl_take isl_schedule *schedule);11602 __isl_give isl_ast_node *11603 isl_ast_build_node_from_schedule_map(11604 __isl_keep isl_ast_build *build,11605 __isl_take isl_union_map *schedule);11606 11607=head3 Inspecting the AST11608 11609The basic properties of an AST node can be obtained as follows.11610 11611 #include <isl/ast.h>11612 enum isl_ast_node_type isl_ast_node_get_type(11613 __isl_keep isl_ast_node *node);11614 11615The type of an AST node is one of11616C<isl_ast_node_for>,11617C<isl_ast_node_if>,11618C<isl_ast_node_block>,11619C<isl_ast_node_mark> or11620C<isl_ast_node_user>.11621An C<isl_ast_node_for> represents a for node.11622An C<isl_ast_node_if> represents an if node.11623An C<isl_ast_node_block> represents a compound node.11624An C<isl_ast_node_mark> introduces a mark in the AST.11625An C<isl_ast_node_user> represents an expression statement.11626An expression statement typically corresponds to a domain element, i.e.,11627one of the elements that is visited by the AST.11628 11629Each type of node has its own additional properties.11630 11631 #include <isl/ast.h>11632 __isl_give isl_ast_expr *isl_ast_node_for_get_iterator(11633 __isl_keep isl_ast_node *node);11634 __isl_give isl_ast_expr *isl_ast_node_for_get_init(11635 __isl_keep isl_ast_node *node);11636 __isl_give isl_ast_expr *isl_ast_node_for_get_cond(11637 __isl_keep isl_ast_node *node);11638 __isl_give isl_ast_expr *isl_ast_node_for_get_inc(11639 __isl_keep isl_ast_node *node);11640 __isl_give isl_ast_node *isl_ast_node_for_get_body(11641 __isl_keep isl_ast_node *node);11642 isl_bool isl_ast_node_for_is_degenerate(11643 __isl_keep isl_ast_node *node);11644 11645An C<isl_ast_for> is considered degenerate if it is known to execute11646exactly once.11647 11648 #include <isl/ast.h>11649 __isl_give isl_ast_expr *isl_ast_node_if_get_cond(11650 __isl_keep isl_ast_node *node);11651 __isl_give isl_ast_node *isl_ast_node_if_get_then_node(11652 __isl_keep isl_ast_node *node);11653 __isl_give isl_ast_node *isl_ast_node_if_get_then(11654 __isl_keep isl_ast_node *node);11655 isl_bool isl_ast_node_if_has_else_node(11656 __isl_keep isl_ast_node *node);11657 isl_bool isl_ast_node_if_has_else(11658 __isl_keep isl_ast_node *node);11659 __isl_give isl_ast_node *isl_ast_node_if_get_else_node(11660 __isl_keep isl_ast_node *node);11661 __isl_give isl_ast_node *isl_ast_node_if_get_else(11662 __isl_keep isl_ast_node *node);11663 11664C<isl_ast_node_if_get_then>,11665C<isl_ast_node_if_has_else> and11666C<isl_ast_node_if_get_else>11667are alternative names for11668C<isl_ast_node_if_get_then_node>,11669C<isl_ast_node_if_has_else_node> and11670C<isl_ast_node_if_get_else_node>, respectively.11671 11672 __isl_give isl_ast_node_list *11673 isl_ast_node_block_get_children(11674 __isl_keep isl_ast_node *node);11675 11676 __isl_give isl_id *isl_ast_node_mark_get_id(11677 __isl_keep isl_ast_node *node);11678 __isl_give isl_ast_node *isl_ast_node_mark_get_node(11679 __isl_keep isl_ast_node *node);11680 11681C<isl_ast_node_mark_get_id> returns the identifier of the mark.11682C<isl_ast_node_mark_get_node> returns the child node that is being marked.11683 11684 #include <isl/ast.h>11685 __isl_give isl_ast_expr *isl_ast_node_user_get_expr(11686 __isl_keep isl_ast_node *node);11687 11688All descendants of a specific node in the AST (including the node itself)11689can be visited11690in depth-first pre-order using the following function.11691 11692 #include <isl/ast.h>11693 isl_stat isl_ast_node_foreach_descendant_top_down(11694 __isl_keep isl_ast_node *node,11695 isl_bool (*fn)(__isl_keep isl_ast_node *node,11696 void *user), void *user);11697 11698The callback function should return C<isl_bool_true> if the children11699of the given node should be visited and C<isl_bool_false> if they should not.11700It should return C<isl_bool_error> in case of failure, in which case11701the entire traversal is aborted.11702 11703Each of the returned C<isl_ast_expr>s can in turn be inspected using11704the following functions.11705 11706 #include <isl/ast.h>11707 enum isl_ast_expr_type isl_ast_expr_get_type(11708 __isl_keep isl_ast_expr *expr);11709 11710The type of an AST expression is one of11711C<isl_ast_expr_op>,11712C<isl_ast_expr_id> or11713C<isl_ast_expr_int>.11714An C<isl_ast_expr_op> represents the result of an operation.11715An C<isl_ast_expr_id> represents an identifier.11716An C<isl_ast_expr_int> represents an integer value.11717 11718Each type of expression has its own additional properties.11719 11720 #include <isl/ast.h>11721 enum isl_ast_expr_op_type isl_ast_expr_op_get_type(11722 __isl_keep isl_ast_expr *expr);11723 enum isl_ast_expr_op_type isl_ast_expr_get_op_type(11724 __isl_keep isl_ast_expr *expr);11725 isl_size isl_ast_expr_op_get_n_arg(__isl_keep isl_ast_expr *expr);11726 isl_size isl_ast_expr_get_op_n_arg(__isl_keep isl_ast_expr *expr);11727 __isl_give isl_ast_expr *isl_ast_expr_op_get_arg(11728 __isl_keep isl_ast_expr *expr, int pos);11729 __isl_give isl_ast_expr *isl_ast_expr_get_op_arg(11730 __isl_keep isl_ast_expr *expr, int pos);11731 isl_stat isl_ast_expr_foreach_ast_expr_op_type(11732 __isl_keep isl_ast_expr *expr,11733 isl_stat (*fn)(enum isl_ast_expr_op_type type,11734 void *user), void *user);11735 isl_stat isl_ast_expr_foreach_ast_op_type(11736 __isl_keep isl_ast_expr *expr,11737 isl_stat (*fn)(enum isl_ast_expr_op_type type,11738 void *user), void *user);11739 isl_stat isl_ast_node_foreach_ast_expr_op_type(11740 __isl_keep isl_ast_node *node,11741 isl_stat (*fn)(enum isl_ast_expr_op_type type,11742 void *user), void *user);11743 isl_stat isl_ast_node_foreach_ast_op_type(11744 __isl_keep isl_ast_node *node,11745 isl_stat (*fn)(enum isl_ast_expr_op_type type,11746 void *user), void *user);11747 11748C<isl_ast_expr_op_get_type> returns the type of the operation11749performed. C<isl_ast_expr_op_get_n_arg> returns the number of11750arguments. C<isl_ast_expr_get_op_arg> returns the specified11751argument.11752C<isl_ast_expr_get_op_type> is an alternative name for11753C<isl_ast_expr_op_get_type>.11754Similarly,11755C<isl_ast_expr_get_op_n_arg> is an alternative name for11756C<isl_ast_expr_op_get_n_arg> and11757C<isl_ast_expr_get_op_arg> is an alternative name for11758C<isl_ast_expr_op_get_arg>.11759 11760C<isl_ast_expr_foreach_ast_expr_op_type> calls C<fn> for each distinct11761C<isl_ast_expr_op_type> that appears in C<expr>.11762C<isl_ast_expr_foreach_ast_op_type> is an alternative name for11763C<isl_ast_expr_foreach_ast_expr_op_type>.11764C<isl_ast_node_foreach_ast_expr_op_type> does the same for each distinct11765C<isl_ast_expr_op_type> that appears in C<node>.11766C<isl_ast_node_foreach_ast_op_type> is an alternative name for11767C<isl_ast_node_foreach_ast_expr_op_type>.11768The operation type is one of the following.11769 11770=over11771 11772=item C<isl_ast_expr_op_and>11773 11774Logical I<and> of two arguments.11775Both arguments can be evaluated.11776 11777=item C<isl_ast_expr_op_and_then>11778 11779Logical I<and> of two arguments.11780The second argument can only be evaluated if the first evaluates to true.11781 11782=item C<isl_ast_expr_op_or>11783 11784Logical I<or> of two arguments.11785Both arguments can be evaluated.11786 11787=item C<isl_ast_expr_op_or_else>11788 11789Logical I<or> of two arguments.11790The second argument can only be evaluated if the first evaluates to false.11791 11792=item C<isl_ast_expr_op_max>11793 11794Maximum of two or more arguments.11795 11796=item C<isl_ast_expr_op_min>11797 11798Minimum of two or more arguments.11799 11800=item C<isl_ast_expr_op_minus>11801 11802Change sign.11803 11804=item C<isl_ast_expr_op_add>11805 11806Sum of two arguments.11807 11808=item C<isl_ast_expr_op_sub>11809 11810Difference of two arguments.11811 11812=item C<isl_ast_expr_op_mul>11813 11814Product of two arguments.11815 11816=item C<isl_ast_expr_op_div>11817 11818Exact division. That is, the result is known to be an integer.11819 11820=item C<isl_ast_expr_op_fdiv_q>11821 11822Result of integer division, rounded towards negative11823infinity.11824The divisor is known to be positive.11825 11826=item C<isl_ast_expr_op_pdiv_q>11827 11828Result of integer division, where dividend is known to be non-negative.11829The divisor is known to be positive.11830 11831=item C<isl_ast_expr_op_pdiv_r>11832 11833Remainder of integer division, where dividend is known to be non-negative.11834The divisor is known to be positive.11835 11836=item C<isl_ast_expr_op_zdiv_r>11837 11838Equal to zero iff the remainder on integer division is zero.11839The divisor is known to be positive.11840 11841=item C<isl_ast_expr_op_cond>11842 11843Conditional operator defined on three arguments.11844If the first argument evaluates to true, then the result11845is equal to the second argument. Otherwise, the result11846is equal to the third argument.11847The second and third argument may only be evaluated if11848the first argument evaluates to true and false, respectively.11849Corresponds to C<a ? b : c> in C.11850 11851=item C<isl_ast_expr_op_select>11852 11853Conditional operator defined on three arguments.11854If the first argument evaluates to true, then the result11855is equal to the second argument. Otherwise, the result11856is equal to the third argument.11857The second and third argument may be evaluated independently11858of the value of the first argument.11859Corresponds to C<a * b + (1 - a) * c> in C.11860 11861=item C<isl_ast_expr_op_eq>11862 11863Equality relation.11864 11865=item C<isl_ast_expr_op_le>11866 11867Less than or equal relation.11868 11869=item C<isl_ast_expr_op_lt>11870 11871Less than relation.11872 11873=item C<isl_ast_expr_op_ge>11874 11875Greater than or equal relation.11876 11877=item C<isl_ast_expr_op_gt>11878 11879Greater than relation.11880 11881=item C<isl_ast_expr_op_call>11882 11883A function call.11884The number of arguments of the C<isl_ast_expr> is one more than11885the number of arguments in the function call, the first argument11886representing the function being called.11887 11888=item C<isl_ast_expr_op_access>11889 11890An array access.11891The number of arguments of the C<isl_ast_expr> is one more than11892the number of index expressions in the array access, the first argument11893representing the array being accessed.11894 11895=item C<isl_ast_expr_op_member>11896 11897A member access.11898This operation has two arguments, a structure and the name of11899the member of the structure being accessed.11900 11901=item C<isl_ast_expr_op_address_of>11902 11903The address of its single argument, which is always an array access.11904 11905=back11906 11907 #include <isl/ast.h>11908 __isl_give isl_id *isl_ast_expr_id_get_id(11909 __isl_keep isl_ast_expr *expr);11910 __isl_give isl_id *isl_ast_expr_get_id(11911 __isl_keep isl_ast_expr *expr);11912 11913Return the identifier represented by the AST expression.11914C<isl_ast_expr_get_id> is an alternative name for11915C<isl_ast_expr_id_get_id>.11916 11917 #include <isl/ast.h>11918 __isl_give isl_val *isl_ast_expr_int_get_val(11919 __isl_keep isl_ast_expr *expr);11920 __isl_give isl_val *isl_ast_expr_get_val(11921 __isl_keep isl_ast_expr *expr);11922 11923Return the integer represented by the AST expression.11924C<isl_ast_expr_get_val> is an alternative name for11925C<isl_ast_expr_int_get_val>.11926 11927=head3 Properties of ASTs11928 11929 #include <isl/ast.h>11930 isl_bool isl_ast_expr_is_equal(11931 __isl_keep isl_ast_expr *expr1,11932 __isl_keep isl_ast_expr *expr2);11933 11934Check if two C<isl_ast_expr>s are equal to each other.11935 11936=head3 Manipulating and printing the AST11937 11938AST nodes can be copied and freed using the following functions.11939 11940 #include <isl/ast.h>11941 __isl_give isl_ast_node *isl_ast_node_copy(11942 __isl_keep isl_ast_node *node);11943 __isl_null isl_ast_node *isl_ast_node_free(11944 __isl_take isl_ast_node *node);11945 11946AST expressions can be copied and freed using the following functions.11947 11948 #include <isl/ast.h>11949 __isl_give isl_ast_expr *isl_ast_expr_copy(11950 __isl_keep isl_ast_expr *expr);11951 __isl_null isl_ast_expr *isl_ast_expr_free(11952 __isl_take isl_ast_expr *expr);11953 11954New AST expressions can be created either directly or within11955the context of an C<isl_ast_build>.11956 11957 #include <isl/ast.h>11958 __isl_give isl_ast_expr *isl_ast_expr_from_val(11959 __isl_take isl_val *v);11960 __isl_give isl_ast_expr *isl_ast_expr_from_id(11961 __isl_take isl_id *id);11962 __isl_give isl_ast_expr *isl_ast_expr_neg(11963 __isl_take isl_ast_expr *expr);11964 __isl_give isl_ast_expr *isl_ast_expr_address_of(11965 __isl_take isl_ast_expr *expr);11966 __isl_give isl_ast_expr *isl_ast_expr_add(11967 __isl_take isl_ast_expr *expr1,11968 __isl_take isl_ast_expr *expr2);11969 __isl_give isl_ast_expr *isl_ast_expr_sub(11970 __isl_take isl_ast_expr *expr1,11971 __isl_take isl_ast_expr *expr2);11972 __isl_give isl_ast_expr *isl_ast_expr_mul(11973 __isl_take isl_ast_expr *expr1,11974 __isl_take isl_ast_expr *expr2);11975 __isl_give isl_ast_expr *isl_ast_expr_div(11976 __isl_take isl_ast_expr *expr1,11977 __isl_take isl_ast_expr *expr2);11978 __isl_give isl_ast_expr *isl_ast_expr_pdiv_q(11979 __isl_take isl_ast_expr *expr1,11980 __isl_take isl_ast_expr *expr2);11981 __isl_give isl_ast_expr *isl_ast_expr_pdiv_r(11982 __isl_take isl_ast_expr *expr1,11983 __isl_take isl_ast_expr *expr2);11984 __isl_give isl_ast_expr *isl_ast_expr_and(11985 __isl_take isl_ast_expr *expr1,11986 __isl_take isl_ast_expr *expr2)11987 __isl_give isl_ast_expr *isl_ast_expr_and_then(11988 __isl_take isl_ast_expr *expr1,11989 __isl_take isl_ast_expr *expr2)11990 __isl_give isl_ast_expr *isl_ast_expr_or(11991 __isl_take isl_ast_expr *expr1,11992 __isl_take isl_ast_expr *expr2)11993 __isl_give isl_ast_expr *isl_ast_expr_or_else(11994 __isl_take isl_ast_expr *expr1,11995 __isl_take isl_ast_expr *expr2)11996 __isl_give isl_ast_expr *isl_ast_expr_eq(11997 __isl_take isl_ast_expr *expr1,11998 __isl_take isl_ast_expr *expr2);11999 __isl_give isl_ast_expr *isl_ast_expr_le(12000 __isl_take isl_ast_expr *expr1,12001 __isl_take isl_ast_expr *expr2);12002 __isl_give isl_ast_expr *isl_ast_expr_lt(12003 __isl_take isl_ast_expr *expr1,12004 __isl_take isl_ast_expr *expr2);12005 __isl_give isl_ast_expr *isl_ast_expr_ge(12006 __isl_take isl_ast_expr *expr1,12007 __isl_take isl_ast_expr *expr2);12008 __isl_give isl_ast_expr *isl_ast_expr_gt(12009 __isl_take isl_ast_expr *expr1,12010 __isl_take isl_ast_expr *expr2);12011 __isl_give isl_ast_expr *isl_ast_expr_access(12012 __isl_take isl_ast_expr *array,12013 __isl_take isl_ast_expr_list *indices);12014 __isl_give isl_ast_expr *isl_ast_expr_call(12015 __isl_take isl_ast_expr *function,12016 __isl_take isl_ast_expr_list *arguments);12017 12018The function C<isl_ast_expr_address_of> can be applied to an12019C<isl_ast_expr> of type C<isl_ast_expr_op_access> only. It is meant12020to represent the address of the C<isl_ast_expr_access>.12021The second argument of the functions C<isl_ast_expr_pdiv_q> and12022C<isl_ast_expr_pdiv_r> should always evaluate to a positive number.12023The function12024C<isl_ast_expr_and_then> as well as C<isl_ast_expr_or_else> are short-circuit12025versions of C<isl_ast_expr_and> and C<isl_ast_expr_or>, respectively.12026 12027 #include <isl/ast_build.h>12028 __isl_give isl_ast_expr *isl_ast_build_expr_from_set(12029 __isl_keep isl_ast_build *build,12030 __isl_take isl_set *set);12031 __isl_give isl_ast_expr *isl_ast_build_expr_from_pw_aff(12032 __isl_keep isl_ast_build *build,12033 __isl_take isl_pw_aff *pa);12034 __isl_give isl_ast_expr *12035 isl_ast_build_access_from_pw_multi_aff(12036 __isl_keep isl_ast_build *build,12037 __isl_take isl_pw_multi_aff *pma);12038 __isl_give isl_ast_expr *12039 isl_ast_build_access_from_multi_pw_aff(12040 __isl_keep isl_ast_build *build,12041 __isl_take isl_multi_pw_aff *mpa);12042 __isl_give isl_ast_expr *12043 isl_ast_build_call_from_pw_multi_aff(12044 __isl_keep isl_ast_build *build,12045 __isl_take isl_pw_multi_aff *pma);12046 __isl_give isl_ast_expr *12047 isl_ast_build_call_from_multi_pw_aff(12048 __isl_keep isl_ast_build *build,12049 __isl_take isl_multi_pw_aff *mpa);12050 12051The set C<set> and12052the domains of C<pa>, C<mpa> and C<pma> should correspond12053to the schedule space of C<build>.12054The tuple id of C<mpa> or C<pma> is used as the array being accessed or12055the function being called.12056If the accessed space is a nested relation, then it is taken12057to represent an access of the member specified by the range12058of this nested relation of the structure specified by the domain12059of the nested relation.12060 12061The following functions can be used to modify an C<isl_ast_expr>.12062 12063 #include <isl/ast.h>12064 __isl_give isl_ast_expr *isl_ast_expr_set_op_arg(12065 __isl_take isl_ast_expr *expr, int pos,12066 __isl_take isl_ast_expr *arg);12067 12068Replace the argument of C<expr> at position C<pos> by C<arg>.12069 12070 #include <isl/ast.h>12071 __isl_give isl_ast_expr *isl_ast_expr_substitute_ids(12072 __isl_take isl_ast_expr *expr,12073 __isl_take isl_id_to_ast_expr *id2expr);12074 12075The function C<isl_ast_expr_substitute_ids> replaces the12076subexpressions of C<expr> of type C<isl_ast_expr_id>12077by the corresponding expression in C<id2expr>, if there is any.12078 12079 12080The following function can be used to modify the descendants12081of a specific node in an AST using a depth-first post-order12082traversal of those descendants (including the node itself).12083 12084 #include <isl/ast.h>12085 __isl_give isl_ast_node *12086 isl_ast_node_map_descendant_bottom_up(12087 __isl_take isl_ast_node *node,12088 __isl_give isl_ast_node *(*fn)(12089 __isl_take isl_ast_node *node,12090 void *user), void *user);12091 12092User specified data can be attached to an C<isl_ast_node> and obtained12093from the same C<isl_ast_node> using the following functions.12094 12095 #include <isl/ast.h>12096 __isl_give isl_ast_node *isl_ast_node_set_annotation(12097 __isl_take isl_ast_node *node,12098 __isl_take isl_id *annotation);12099 __isl_give isl_id *isl_ast_node_get_annotation(12100 __isl_keep isl_ast_node *node);12101 12102Basic printing can be performed using the following functions.12103 12104 #include <isl/ast.h>12105 __isl_give isl_printer *isl_printer_print_ast_expr(12106 __isl_take isl_printer *p,12107 __isl_keep isl_ast_expr *expr);12108 __isl_give isl_printer *isl_printer_print_ast_node(12109 __isl_take isl_printer *p,12110 __isl_keep isl_ast_node *node);12111 __isl_give char *isl_ast_expr_to_str(12112 __isl_keep isl_ast_expr *expr);12113 __isl_give char *isl_ast_node_to_str(12114 __isl_keep isl_ast_node *node);12115 __isl_give char *isl_ast_expr_to_C_str(12116 __isl_keep isl_ast_expr *expr);12117 __isl_give char *isl_ast_node_to_C_str(12118 __isl_keep isl_ast_node *node);12119 12120The functions C<isl_ast_expr_to_C_str> and12121C<isl_ast_node_to_C_str> are convenience functions12122that return a string representation of the input in C format.12123 12124More advanced printing can be performed using the following functions.12125 12126 #include <isl/ast.h>12127 __isl_give isl_printer *12128 isl_ast_expr_op_type_set_print_name(12129 __isl_take isl_printer *p,12130 enum isl_ast_expr_op_type type,12131 __isl_keep const char *name);12132 __isl_give isl_printer *isl_ast_op_type_set_print_name(12133 __isl_take isl_printer *p,12134 enum isl_ast_expr_op_type type,12135 __isl_keep const char *name);12136 isl_stat isl_options_set_ast_print_macro_once(12137 isl_ctx *ctx, int val);12138 int isl_options_get_ast_print_macro_once(isl_ctx *ctx);12139 __isl_give isl_printer *isl_ast_expr_op_type_print_macro(12140 enum isl_ast_expr_op_type type,12141 __isl_take isl_printer *p);12142 __isl_give isl_printer *isl_ast_op_type_print_macro(12143 enum isl_ast_expr_op_type type,12144 __isl_take isl_printer *p);12145 __isl_give isl_printer *isl_ast_expr_print_macros(12146 __isl_keep isl_ast_expr *expr,12147 __isl_take isl_printer *p);12148 __isl_give isl_printer *isl_ast_node_print_macros(12149 __isl_keep isl_ast_node *node,12150 __isl_take isl_printer *p);12151 __isl_give isl_printer *isl_ast_node_print(12152 __isl_keep isl_ast_node *node,12153 __isl_take isl_printer *p,12154 __isl_take isl_ast_print_options *options);12155 __isl_give isl_printer *isl_ast_node_for_print(12156 __isl_keep isl_ast_node *node,12157 __isl_take isl_printer *p,12158 __isl_take isl_ast_print_options *options);12159 __isl_give isl_printer *isl_ast_node_if_print(12160 __isl_keep isl_ast_node *node,12161 __isl_take isl_printer *p,12162 __isl_take isl_ast_print_options *options);12163 12164While printing an C<isl_ast_node> in C<ISL_FORMAT_C>,12165C<isl> may print out an AST that makes use of macros such12166as C<floord>, C<min> and C<max>.12167The names of these macros may be modified by a call12168to C<isl_ast_expr_op_type_set_print_name>. The user-specified12169names are associated to the printer object.12170C<isl_ast_op_type_set_print_name> is an alternative name for12171C<isl_ast_expr_op_type_set_print_name>.12172C<isl_ast_expr_op_type_print_macro> prints out the macro12173corresponding to a specific C<isl_ast_expr_op_type>.12174If the print-macro-once option is set, then a given macro definition12175is only printed once to any given printer object.12176C<isl_ast_op_type_print_macro> is an alternative name for12177C<isl_ast_expr_op_type_print_macro>.12178C<isl_ast_expr_print_macros> scans the C<isl_ast_expr>12179for subexpressions where these macros would be used and prints12180out the required macro definitions.12181Essentially, C<isl_ast_expr_print_macros> calls12182C<isl_ast_expr_foreach_ast_expr_op_type> with12183C<isl_ast_expr_op_type_print_macro>12184as function argument.12185C<isl_ast_node_print_macros> does the same12186for expressions in its C<isl_ast_node> argument.12187C<isl_ast_node_print>, C<isl_ast_node_for_print> and12188C<isl_ast_node_if_print> print an C<isl_ast_node>12189in C<ISL_FORMAT_C>, but allow for some extra control12190through an C<isl_ast_print_options> object.12191This object can be created using the following functions.12192 12193 #include <isl/ast.h>12194 __isl_give isl_ast_print_options *12195 isl_ast_print_options_alloc(isl_ctx *ctx);12196 __isl_give isl_ast_print_options *12197 isl_ast_print_options_copy(12198 __isl_keep isl_ast_print_options *options);12199 __isl_null isl_ast_print_options *12200 isl_ast_print_options_free(12201 __isl_take isl_ast_print_options *options);12202 12203 __isl_give isl_ast_print_options *12204 isl_ast_print_options_set_print_user(12205 __isl_take isl_ast_print_options *options,12206 __isl_give isl_printer *(*print_user)(12207 __isl_take isl_printer *p,12208 __isl_take isl_ast_print_options *options,12209 __isl_keep isl_ast_node *node, void *user),12210 void *user);12211 __isl_give isl_ast_print_options *12212 isl_ast_print_options_set_print_for(12213 __isl_take isl_ast_print_options *options,12214 __isl_give isl_printer *(*print_for)(12215 __isl_take isl_printer *p,12216 __isl_take isl_ast_print_options *options,12217 __isl_keep isl_ast_node *node, void *user),12218 void *user);12219 12220The callback set by C<isl_ast_print_options_set_print_user>12221is called whenever a node of type C<isl_ast_node_user> needs to12222be printed.12223The callback set by C<isl_ast_print_options_set_print_for>12224is called whenever a node of type C<isl_ast_node_for> needs to12225be printed.12226Note that C<isl_ast_node_for_print> will I<not> call the12227callback set by C<isl_ast_print_options_set_print_for> on the node12228on which C<isl_ast_node_for_print> is called, but only on nested12229nodes of type C<isl_ast_node_for>. It is therefore safe to12230call C<isl_ast_node_for_print> from within the callback set by12231C<isl_ast_print_options_set_print_for>.12232 12233The following option determines the type to be used for iterators12234while printing the AST.12235 12236 isl_stat isl_options_set_ast_iterator_type(12237 isl_ctx *ctx, const char *val);12238 const char *isl_options_get_ast_iterator_type(12239 isl_ctx *ctx);12240 12241The AST printer only prints body nodes of C<if> and C<for> nodes12242as blocks if these12243blocks cannot be safely omitted.12244For example, a C<for> node with one body node will not be12245surrounded with braces in C<ISL_FORMAT_C>.12246A block will always be printed by setting the following option.12247 12248 isl_stat isl_options_set_ast_always_print_block(isl_ctx *ctx,12249 int val);12250 int isl_options_get_ast_always_print_block(isl_ctx *ctx);12251 12252Explicit block nodes that appear inside the AST are always printed as blocks.12253If the block node appears as the outermost node,12254then it is only printed if the following option is set.12255 12256 isl_stat isl_options_set_ast_print_outermost_block(12257 isl_ctx *ctx, int val);12258 int isl_options_get_ast_print_outermost_block(12259 isl_ctx *ctx);12260 12261=head3 Options12262 12263 #include <isl/ast_build.h>12264 isl_stat isl_options_set_ast_build_atomic_upper_bound(12265 isl_ctx *ctx, int val);12266 int isl_options_get_ast_build_atomic_upper_bound(12267 isl_ctx *ctx);12268 isl_stat isl_options_set_ast_build_prefer_pdiv(isl_ctx *ctx,12269 int val);12270 int isl_options_get_ast_build_prefer_pdiv(isl_ctx *ctx);12271 isl_stat isl_options_set_ast_build_detect_min_max(12272 isl_ctx *ctx, int val);12273 int isl_options_get_ast_build_detect_min_max(12274 isl_ctx *ctx);12275 isl_stat isl_options_set_ast_build_exploit_nested_bounds(12276 isl_ctx *ctx, int val);12277 int isl_options_get_ast_build_exploit_nested_bounds(12278 isl_ctx *ctx);12279 isl_stat isl_options_set_ast_build_group_coscheduled(12280 isl_ctx *ctx, int val);12281 int isl_options_get_ast_build_group_coscheduled(12282 isl_ctx *ctx);12283 isl_stat isl_options_set_ast_build_separation_bounds(12284 isl_ctx *ctx, int val);12285 int isl_options_get_ast_build_separation_bounds(12286 isl_ctx *ctx);12287 isl_stat isl_options_set_ast_build_scale_strides(12288 isl_ctx *ctx, int val);12289 int isl_options_get_ast_build_scale_strides(12290 isl_ctx *ctx);12291 isl_stat isl_options_set_ast_build_allow_else(isl_ctx *ctx,12292 int val);12293 int isl_options_get_ast_build_allow_else(isl_ctx *ctx);12294 isl_stat isl_options_set_ast_build_allow_or(isl_ctx *ctx,12295 int val);12296 int isl_options_get_ast_build_allow_or(isl_ctx *ctx);12297 12298=over12299 12300=item * ast_build_atomic_upper_bound12301 12302Generate loop upper bounds that consist of the current loop iterator,12303an operator and an expression not involving the iterator.12304If this option is not set, then the current loop iterator may appear12305several times in the upper bound.12306For example, when this option is turned off, AST generation12307for the schedule12308 12309 [n] -> { A[i] -> [i] : 0 <= i <= 100, n }12310 12311produces12312 12313 for (int c0 = 0; c0 <= 100 && n >= c0; c0 += 1)12314 A(c0);12315 12316When the option is turned on, the following AST is generated12317 12318 for (int c0 = 0; c0 <= min(100, n); c0 += 1)12319 A(c0);12320 12321=item * ast_build_prefer_pdiv12322 12323If this option is turned off, then the AST generation will12324produce ASTs that may only contain C<isl_ast_expr_op_fdiv_q>12325operators, but no C<isl_ast_expr_op_pdiv_q> or12326C<isl_ast_expr_op_pdiv_r> operators.12327If this option is turned on, then C<isl> will try to convert12328some of the C<isl_ast_expr_op_fdiv_q> operators to (expressions containing)12329C<isl_ast_expr_op_pdiv_q> or C<isl_ast_expr_op_pdiv_r> operators.12330 12331=item * ast_build_detect_min_max12332 12333If this option is turned on, then C<isl> will try and detect12334min or max-expressions when building AST expressions from12335piecewise affine expressions.12336 12337=item * ast_build_exploit_nested_bounds12338 12339Simplify conditions based on bounds of nested for loops.12340In particular, remove conditions that are implied by the fact12341that one or more nested loops have at least one iteration,12342meaning that the upper bound is at least as large as the lower bound.12343For example, when this option is turned off, AST generation12344for the schedule12345 12346 [N,M] -> { A[i,j] -> [i,j] : 0 <= i <= N and12347 0 <= j <= M }12348 12349produces12350 12351 if (M >= 0)12352 for (int c0 = 0; c0 <= N; c0 += 1)12353 for (int c1 = 0; c1 <= M; c1 += 1)12354 A(c0, c1);12355 12356When the option is turned on, the following AST is generated12357 12358 for (int c0 = 0; c0 <= N; c0 += 1)12359 for (int c1 = 0; c1 <= M; c1 += 1)12360 A(c0, c1);12361 12362=item * ast_build_group_coscheduled12363 12364If two domain elements are assigned the same schedule point, then12365they may be executed in any order and they may even appear in different12366loops. If this options is set, then the AST generator will make12367sure that coscheduled domain elements do not appear in separate parts12368of the AST. This is useful in case of nested AST generation12369if the outer AST generation is given only part of a schedule12370and the inner AST generation should handle the domains that are12371coscheduled by this initial part of the schedule together.12372For example if an AST is generated for a schedule12373 12374 { A[i] -> [0]; B[i] -> [0] }12375 12376then the C<isl_ast_build_set_create_leaf> callback described12377below may get called twice, once for each domain.12378Setting this option ensures that the callback is only called once12379on both domains together.12380 12381=item * ast_build_separation_bounds12382 12383This option specifies which bounds to use during separation.12384If this option is set to C<ISL_AST_BUILD_SEPARATION_BOUNDS_IMPLICIT>12385then all (possibly implicit) bounds on the current dimension will12386be used during separation.12387If this option is set to C<ISL_AST_BUILD_SEPARATION_BOUNDS_EXPLICIT>12388then only those bounds that are explicitly available will12389be used during separation.12390 12391=item * ast_build_scale_strides12392 12393This option specifies whether the AST generator is allowed12394to scale down iterators of strided loops.12395 12396=item * ast_build_allow_else12397 12398This option specifies whether the AST generator is allowed12399to construct if statements with else branches.12400 12401=item * ast_build_allow_or12402 12403This option specifies whether the AST generator is allowed12404to construct if conditions with disjunctions.12405 12406=back12407 12408=head3 AST Generation Options (Schedule Tree)12409 12410In case of AST construction from a schedule tree, the options12411that control how an AST is created from the individual schedule12412dimensions are stored in the band nodes of the tree12413(see L</"Schedule Trees">).12414 12415In particular, a schedule dimension can be handled in four12416different ways, atomic, separate, unroll or the default.12417This loop AST generation type can be set using12418C<isl_schedule_node_band_member_set_ast_loop_type>.12419Alternatively,12420the first three can be selected by including a one-dimensional12421element with as value the position of the schedule dimension12422within the band and as name one of C<atomic>, C<separate>12423or C<unroll> in the options12424set by C<isl_schedule_node_band_set_ast_build_options>.12425Only one of these three may be specified for12426any given schedule dimension within a band node.12427If none of these is specified, then the default12428is used. The meaning of the options is as follows.12429 12430=over12431 12432=item C<atomic>12433 12434When this option is specified, the AST generator will make12435sure that a given domain space only appears in a single12436loop at the specified level.12437 12438For example, for the schedule tree12439 12440 domain: "{ a[i] : 0 <= i < 10; b[i] : 0 <= i < 10 }"12441 child:12442 schedule: "[{ a[i] -> [i]; b[i] -> [i+1] }]"12443 options: "{ atomic[x] }"12444 12445the following AST will be generated12446 12447 for (int c0 = 0; c0 <= 10; c0 += 1) {12448 if (c0 >= 1)12449 b(c0 - 1);12450 if (c0 <= 9)12451 a(c0);12452 }12453 12454On the other hand, for the schedule tree12455 12456 domain: "{ a[i] : 0 <= i < 10; b[i] : 0 <= i < 10 }"12457 child:12458 schedule: "[{ a[i] -> [i]; b[i] -> [i+1] }]"12459 options: "{ separate[x] }"12460 12461the following AST will be generated12462 12463 {12464 a(0);12465 for (int c0 = 1; c0 <= 9; c0 += 1) {12466 b(c0 - 1);12467 a(c0);12468 }12469 b(9);12470 }12471 12472If neither C<atomic> nor C<separate> is specified, then the AST generator12473may produce either of these two results or some intermediate form.12474 12475=item C<separate>12476 12477When this option is specified, the AST generator will12478split the domain of the specified schedule dimension12479into pieces with a fixed set of statements for which12480instances need to be executed by the iterations in12481the schedule domain part. This option tends to avoid12482the generation of guards inside the corresponding loops.12483See also the C<atomic> option.12484 12485=item C<unroll>12486 12487When this option is specified, the AST generator will12488I<completely> unroll the corresponding schedule dimension.12489It is the responsibility of the user to ensure that such12490unrolling is possible.12491To obtain a partial unrolling, the user should apply an additional12492strip-mining to the schedule and fully unroll the inner schedule12493dimension.12494 12495=back12496 12497The C<isolate> option is a bit more involved. It allows the user12498to isolate a range of schedule dimension values from smaller and12499greater values. Additionally, the user may specify a different12500atomic/separate/unroll choice for the isolated part and the remaining12501parts. The typical use case of the C<isolate> option is to isolate12502full tiles from partial tiles.12503The part that needs to be isolated may depend on outer schedule dimensions.12504The option therefore needs to be able to reference those outer schedule12505dimensions. In particular, the space of the C<isolate> option is that12506of a wrapped map with as domain the flat product of all outer band nodes12507and as range the space of the current band node.12508The atomic/separate/unroll choice for the isolated part is determined12509by an option that lives in an unnamed wrapped space with as domain12510a zero-dimensional C<isolate> space and as range the regular12511C<atomic>, C<separate> or C<unroll> space.12512This option may also be set directly using12513C<isl_schedule_node_band_member_set_isolate_ast_loop_type>.12514The atomic/separate/unroll choice for the remaining part is determined12515by the regular C<atomic>, C<separate> or C<unroll> option.12516Since the C<isolate> option references outer schedule dimensions,12517its use in a band node causes any tree containing the node12518to be considered anchored.12519 12520As an example, consider the isolation of full tiles from partial tiles12521in a tiling of a triangular domain. The original schedule is as follows.12522 12523 domain: "{ A[i,j] : 0 <= i,j and i + j <= 100 }"12524 child:12525 schedule: "[{ A[i,j] -> [floor(i/10)] }, \12526 { A[i,j] -> [floor(j/10)] }, \12527 { A[i,j] -> [i] }, { A[i,j] -> [j] }]"12528 12529The output is12530 12531 for (int c0 = 0; c0 <= 10; c0 += 1)12532 for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)12533 for (int c2 = 10 * c0;12534 c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)12535 for (int c3 = 10 * c1;12536 c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)12537 A(c2, c3);12538 12539Isolating the full tiles, we have the following input12540 12541 domain: "{ A[i,j] : 0 <= i,j and i + j <= 100 }"12542 child:12543 schedule: "[{ A[i,j] -> [floor(i/10)] }, \12544 { A[i,j] -> [floor(j/10)] }, \12545 { A[i,j] -> [i] }, { A[i,j] -> [j] }]"12546 options: "{ isolate[[] -> [a,b,c,d]] : 0 <= 10a,10b and \12547 10a+9+10b+9 <= 100 }"12548 12549and output12550 12551 {12552 for (int c0 = 0; c0 <= 8; c0 += 1) {12553 for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)12554 for (int c2 = 10 * c0;12555 c2 <= 10 * c0 + 9; c2 += 1)12556 for (int c3 = 10 * c1;12557 c3 <= 10 * c1 + 9; c3 += 1)12558 A(c2, c3);12559 for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)12560 for (int c2 = 10 * c0;12561 c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)12562 for (int c3 = 10 * c1;12563 c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)12564 A(c2, c3);12565 }12566 for (int c0 = 9; c0 <= 10; c0 += 1)12567 for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)12568 for (int c2 = 10 * c0;12569 c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)12570 for (int c3 = 10 * c1;12571 c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)12572 A(c2, c3);12573 }12574 12575We may then additionally unroll the innermost loop of the isolated part12576 12577 domain: "{ A[i,j] : 0 <= i,j and i + j <= 100 }"12578 child:12579 schedule: "[{ A[i,j] -> [floor(i/10)] }, \12580 { A[i,j] -> [floor(j/10)] }, \12581 { A[i,j] -> [i] }, { A[i,j] -> [j] }]"12582 options: "{ isolate[[] -> [a,b,c,d]] : 0 <= 10a,10b and \12583 10a+9+10b+9 <= 100; [isolate[] -> unroll[3]] }"12584 12585to obtain12586 12587 {12588 for (int c0 = 0; c0 <= 8; c0 += 1) {12589 for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)12590 for (int c2 = 10 * c0; c2 <= 10 * c0 + 9; c2 += 1) {12591 A(c2, 10 * c1);12592 A(c2, 10 * c1 + 1);12593 A(c2, 10 * c1 + 2);12594 A(c2, 10 * c1 + 3);12595 A(c2, 10 * c1 + 4);12596 A(c2, 10 * c1 + 5);12597 A(c2, 10 * c1 + 6);12598 A(c2, 10 * c1 + 7);12599 A(c2, 10 * c1 + 8);12600 A(c2, 10 * c1 + 9);12601 }12602 for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)12603 for (int c2 = 10 * c0;12604 c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)12605 for (int c3 = 10 * c1;12606 c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)12607 A(c2, c3);12608 }12609 for (int c0 = 9; c0 <= 10; c0 += 1)12610 for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)12611 for (int c2 = 10 * c0;12612 c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)12613 for (int c3 = 10 * c1;12614 c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)12615 A(c2, c3);12616 }12617 12618 12619=head3 AST Generation Options (Schedule Map)12620 12621In case of AST construction using12622C<isl_ast_build_node_from_schedule_map>, the options12623that control how an AST is created from the individual schedule12624dimensions are stored in the C<isl_ast_build>.12625They can be set using the following function.12626 12627 #include <isl/ast_build.h>12628 __isl_give isl_ast_build *12629 isl_ast_build_set_options(12630 __isl_take isl_ast_build *build,12631 __isl_take isl_union_map *options);12632 12633The options are encoded in an C<isl_union_map>.12634The domain of this union relation refers to the schedule domain,12635i.e., the range of the schedule passed12636to C<isl_ast_build_node_from_schedule_map>.12637In the case of nested AST generation (see L</"Nested AST Generation">),12638the domain of C<options> should refer to the extra piece of the schedule.12639That is, it should be equal to the range of the wrapped relation in the12640range of the schedule.12641The range of the options can consist of elements in one or more spaces,12642the names of which determine the effect of the option.12643The values of the range typically also refer to the schedule dimension12644to which the option applies, with value C<0> representing12645the outermost schedule dimension. In case of nested AST generation12646(see L</"Nested AST Generation">), these values refer to the position12647of the schedule dimension within the innermost AST generation.12648The constraints on the domain elements of12649the option should only refer to this dimension and earlier dimensions.12650We consider the following spaces.12651 12652=over12653 12654=item C<separation_class>12655 12656B<This option has been deprecated. Use the isolate option on12657schedule trees instead.>12658 12659This space is a wrapped relation between two one dimensional spaces.12660The input space represents the schedule dimension to which the option12661applies and the output space represents the separation class.12662While constructing a loop corresponding to the specified schedule12663dimension(s), the AST generator will try to generate separate loops12664for domain elements that are assigned different classes.12665If only some of the elements are assigned a class, then those elements12666that are not assigned any class will be treated as belonging to a class12667that is separate from the explicitly assigned classes.12668The typical use case for this option is to separate full tiles from12669partial tiles.12670The other options, described below, are applied after the separation12671into classes.12672 12673As an example, consider the separation into full and partial tiles12674of a tiling of a triangular domain.12675Take, for example, the domain12676 12677 { A[i,j] : 0 <= i,j and i + j <= 100 }12678 12679and a tiling into tiles of 10 by 10. The input to the AST generator12680is then the schedule12681 12682 { A[i,j] -> [([i/10]),[j/10],i,j] : 0 <= i,j and12683 i + j <= 100 }12684 12685Without any options, the following AST is generated12686 12687 for (int c0 = 0; c0 <= 10; c0 += 1)12688 for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)12689 for (int c2 = 10 * c0;12690 c2 <= min(-10 * c1 + 100, 10 * c0 + 9);12691 c2 += 1)12692 for (int c3 = 10 * c1;12693 c3 <= min(10 * c1 + 9, -c2 + 100);12694 c3 += 1)12695 A(c2, c3);12696 12697Separation into full and partial tiles can be obtained by assigning12698a class, say C<0>, to the full tiles. The full tiles are represented by those12699values of the first and second schedule dimensions for which there are12700values of the third and fourth dimensions to cover an entire tile.12701That is, we need to specify the following option12702 12703 { [a,b,c,d] -> separation_class[[0]->[0]] :12704 exists b': 0 <= 10a,10b' and12705 10a+9+10b'+9 <= 100;12706 [a,b,c,d] -> separation_class[[1]->[0]] :12707 0 <= 10a,10b and 10a+9+10b+9 <= 100 }12708 12709which simplifies to12710 12711 { [a, b, c, d] -> separation_class[[1] -> [0]] :12712 a >= 0 and b >= 0 and b <= 8 - a;12713 [a, b, c, d] -> separation_class[[0] -> [0]] :12714 a >= 0 and a <= 8 }12715 12716With this option, the generated AST is as follows12717 12718 {12719 for (int c0 = 0; c0 <= 8; c0 += 1) {12720 for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)12721 for (int c2 = 10 * c0;12722 c2 <= 10 * c0 + 9; c2 += 1)12723 for (int c3 = 10 * c1;12724 c3 <= 10 * c1 + 9; c3 += 1)12725 A(c2, c3);12726 for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)12727 for (int c2 = 10 * c0;12728 c2 <= min(-10 * c1 + 100, 10 * c0 + 9);12729 c2 += 1)12730 for (int c3 = 10 * c1;12731 c3 <= min(-c2 + 100, 10 * c1 + 9);12732 c3 += 1)12733 A(c2, c3);12734 }12735 for (int c0 = 9; c0 <= 10; c0 += 1)12736 for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)12737 for (int c2 = 10 * c0;12738 c2 <= min(-10 * c1 + 100, 10 * c0 + 9);12739 c2 += 1)12740 for (int c3 = 10 * c1;12741 c3 <= min(10 * c1 + 9, -c2 + 100);12742 c3 += 1)12743 A(c2, c3);12744 }12745 12746=item C<separate>12747 12748This is a single-dimensional space representing the schedule dimension(s)12749to which ``separation'' should be applied. Separation tries to split12750a loop into several pieces if this can avoid the generation of guards12751inside the loop.12752See also the C<atomic> option.12753 12754=item C<atomic>12755 12756This is a single-dimensional space representing the schedule dimension(s)12757for which the domains should be considered ``atomic''. That is, the12758AST generator will make sure that any given domain space will only appear12759in a single loop at the specified level.12760 12761Consider the following schedule12762 12763 { a[i] -> [i] : 0 <= i < 10;12764 b[i] -> [i+1] : 0 <= i < 10 }12765 12766If the following option is specified12767 12768 { [i] -> separate[x] }12769 12770then the following AST will be generated12771 12772 {12773 a(0);12774 for (int c0 = 1; c0 <= 9; c0 += 1) {12775 a(c0);12776 b(c0 - 1);12777 }12778 b(9);12779 }12780 12781If, on the other hand, the following option is specified12782 12783 { [i] -> atomic[x] }12784 12785then the following AST will be generated12786 12787 for (int c0 = 0; c0 <= 10; c0 += 1) {12788 if (c0 <= 9)12789 a(c0);12790 if (c0 >= 1)12791 b(c0 - 1);12792 }12793 12794If neither C<atomic> nor C<separate> is specified, then the AST generator12795may produce either of these two results or some intermediate form.12796 12797=item C<unroll>12798 12799This is a single-dimensional space representing the schedule dimension(s)12800that should be I<completely> unrolled.12801To obtain a partial unrolling, the user should apply an additional12802strip-mining to the schedule and fully unroll the inner loop.12803 12804=back12805 12806=head3 Fine-grained Control over AST Generation12807 12808Besides specifying the constraints on the parameters,12809an C<isl_ast_build> object can be used to control12810various aspects of the AST generation process.12811In case of AST construction using12812C<isl_ast_build_node_from_schedule_map>,12813the most prominent way of control is through ``options'',12814as explained above.12815 12816Additional control is available through the following functions.12817 12818 #include <isl/ast_build.h>12819 __isl_give isl_ast_build *12820 isl_ast_build_set_iterators(12821 __isl_take isl_ast_build *build,12822 __isl_take isl_id_list *iterators);12823 12824The function C<isl_ast_build_set_iterators> allows the user to12825specify a list of iterator C<isl_id>s to be used as iterators.12826If the input schedule is injective, then12827the number of elements in this list should be as large as the dimension12828of the schedule space, but no direct correspondence should be assumed12829between dimensions and elements.12830If the input schedule is not injective, then an additional number12831of C<isl_id>s equal to the largest dimension of the input domains12832may be required.12833If the number of provided C<isl_id>s is insufficient, then additional12834names are automatically generated.12835 12836 #include <isl/ast_build.h>12837 __isl_give isl_ast_build *12838 isl_ast_build_set_create_leaf(12839 __isl_take isl_ast_build *build,12840 __isl_give isl_ast_node *(*fn)(12841 __isl_take isl_ast_build *build,12842 void *user), void *user);12843 12844The12845C<isl_ast_build_set_create_leaf> function allows for the12846specification of a callback that should be called whenever the AST12847generator arrives at an element of the schedule domain.12848The callback should return an AST node that should be inserted12849at the corresponding position of the AST. The default action (when12850the callback is not set) is to continue generating parts of the AST to scan12851all the domain elements associated to the schedule domain element12852and to insert user nodes, ``calling'' the domain element, for each of them.12853The C<build> argument contains the current state of the C<isl_ast_build>.12854To ease nested AST generation (see L</"Nested AST Generation">),12855all control information that is12856specific to the current AST generation such as the options and12857the callbacks has been removed from this C<isl_ast_build>.12858The callback would typically return the result of a nested12859AST generation or a12860user defined node created using the following function.12861 12862 #include <isl/ast.h>12863 __isl_give isl_ast_node *isl_ast_node_user_from_expr(12864 __isl_take isl_ast_expr *expr);12865 __isl_give isl_ast_node *isl_ast_node_alloc_user(12866 __isl_take isl_ast_expr *expr);12867 12868C<isl_ast_node_alloc_user> is an alternative name for12869C<isl_ast_node_user_from_expr>.12870 12871In some cases, a single user defined node is not enough,12872in which case the following function can be used12873to create a block node from multiple AST nodes.12874 12875 #include <isl/ast.h>12876 __isl_give isl_ast_node *isl_ast_node_block_from_children(12877 __isl_take isl_ast_node_list *list);12878 12879 #include <isl/ast_build.h>12880 __isl_give isl_ast_build *12881 isl_ast_build_set_at_each_domain(12882 __isl_take isl_ast_build *build,12883 __isl_give isl_ast_node *(*fn)(12884 __isl_take isl_ast_node *node,12885 __isl_keep isl_ast_build *build,12886 void *user), void *user);12887 __isl_give isl_ast_build *12888 isl_ast_build_set_before_each_for(12889 __isl_take isl_ast_build *build,12890 __isl_give isl_id *(*fn)(12891 __isl_keep isl_ast_build *build,12892 void *user), void *user);12893 __isl_give isl_ast_build *12894 isl_ast_build_set_after_each_for(12895 __isl_take isl_ast_build *build,12896 __isl_give isl_ast_node *(*fn)(12897 __isl_take isl_ast_node *node,12898 __isl_keep isl_ast_build *build,12899 void *user), void *user);12900 __isl_give isl_ast_build *12901 isl_ast_build_set_before_each_mark(12902 __isl_take isl_ast_build *build,12903 isl_stat (*fn)(__isl_keep isl_id *mark,12904 __isl_keep isl_ast_build *build,12905 void *user), void *user);12906 __isl_give isl_ast_build *12907 isl_ast_build_set_after_each_mark(12908 __isl_take isl_ast_build *build,12909 __isl_give isl_ast_node *(*fn)(12910 __isl_take isl_ast_node *node,12911 __isl_keep isl_ast_build *build,12912 void *user), void *user);12913 12914The callback set by C<isl_ast_build_set_at_each_domain> will12915be called for each domain AST node.12916The callbacks set by C<isl_ast_build_set_before_each_for>12917and C<isl_ast_build_set_after_each_for> will be called12918for each for AST node. The first will be called in depth-first12919pre-order, while the second will be called in depth-first post-order.12920Since C<isl_ast_build_set_before_each_for> is called before the for12921node is actually constructed, it is only passed an C<isl_ast_build>.12922The returned C<isl_id> will be added as an annotation (using12923C<isl_ast_node_set_annotation>) to the constructed for node.12924In particular, if the user has also specified an C<after_each_for>12925callback, then the annotation can be retrieved from the node passed to12926that callback using C<isl_ast_node_get_annotation>.12927The callbacks set by C<isl_ast_build_set_before_each_mark>12928and C<isl_ast_build_set_after_each_mark> will be called for each12929mark AST node that is created, i.e., for each mark schedule node12930in the input schedule tree. The first will be called in depth-first12931pre-order, while the second will be called in depth-first post-order.12932Since the callback set by C<isl_ast_build_set_before_each_mark>12933is called before the mark AST node is actually constructed, it is passed12934the identifier of the mark node.12935All callbacks should C<NULL> (or C<isl_stat_error>) on failure.12936The given C<isl_ast_build> can be used to create new12937C<isl_ast_expr> objects using C<isl_ast_build_expr_from_pw_aff>12938or C<isl_ast_build_call_from_pw_multi_aff>.12939 12940=head3 Nested AST Generation12941 12942C<isl> allows the user to create an AST within the context12943of another AST. These nested ASTs are created using the12944same C<isl_ast_build_node_from_schedule_map> function that is used to create12945the outer AST. The C<build> argument should be an C<isl_ast_build>12946passed to a callback set by12947C<isl_ast_build_set_create_leaf>.12948The space of the range of the C<schedule> argument should refer12949to this build. In particular, the space should be a wrapped12950relation and the domain of this wrapped relation should be the12951same as that of the range of the schedule returned by12952C<isl_ast_build_get_schedule> below.12953In practice, the new schedule is typically12954created by calling C<isl_union_map_range_product> on the old schedule12955and some extra piece of the schedule.12956The space of the schedule domain is also available from12957the C<isl_ast_build>.12958 12959 #include <isl/ast_build.h>12960 __isl_give isl_union_map *isl_ast_build_get_schedule(12961 __isl_keep isl_ast_build *build);12962 __isl_give isl_space *isl_ast_build_get_schedule_space(12963 __isl_keep isl_ast_build *build);12964 __isl_give isl_ast_build *isl_ast_build_restrict(12965 __isl_take isl_ast_build *build,12966 __isl_take isl_set *set);12967 12968The C<isl_ast_build_get_schedule> function returns a (partial)12969schedule for the domains elements for which part of the AST still needs to12970be generated in the current build.12971In particular, the domain elements are mapped to those iterations of the loops12972enclosing the current point of the AST generation inside which12973the domain elements are executed.12974No direct correspondence between12975the input schedule and this schedule should be assumed.12976The space obtained from C<isl_ast_build_get_schedule_space> can be used12977to create a set for C<isl_ast_build_restrict> to intersect12978with the current build. In particular, the set passed to12979C<isl_ast_build_restrict> can have additional parameters.12980The ids of the set dimensions in the space returned by12981C<isl_ast_build_get_schedule_space> correspond to the12982iterators of the already generated loops.12983The user should not rely on the ids of the output dimensions12984of the relations in the union relation returned by12985C<isl_ast_build_get_schedule> having any particular value.12986 12987=head1 Applications12988 12989Although C<isl> is mainly meant to be used as a library,12990it also contains some basic applications that use some12991of the functionality of C<isl>.12992For applications that take one or more polytopes or polyhedra12993as input, this input may be specified in either the L<isl format>12994or the L<PolyLib format>.12995 12996=head2 C<isl_polyhedron_sample>12997 12998C<isl_polyhedron_sample> takes a polyhedron as input and prints12999an integer element of the polyhedron, if there is any.13000The first column in the output is the denominator and is always13001equal to 1. If the polyhedron contains no integer points,13002then a vector of length zero is printed.13003 13004=head2 C<isl_pip>13005 13006C<isl_pip> takes the same input as the C<example> program13007from the C<piplib> distribution, i.e., a set of constraints13008on the parameters, a line containing only -1 and finally a set13009of constraints on a parametric polyhedron.13010The coefficients of the parameters appear in the last columns13011(but before the final constant column).13012The output is the lexicographic minimum of the parametric polyhedron.13013As C<isl> currently does not have its own output format, the output13014is just a dump of the internal state.13015 13016=head2 C<isl_polyhedron_minimize>13017 13018C<isl_polyhedron_minimize> computes the minimum of some linear13019or affine objective function over the integer points in a polyhedron.13020If an affine objective function13021is given, then the constant should appear in the last column.13022 13023=head2 C<isl_polytope_scan>13024 13025Given a polytope, C<isl_polytope_scan> prints13026all integer points in the polytope.13027 13028=head2 C<isl_flow>13029 13030Given an C<isl_union_access_info> object as input,13031C<isl_flow> prints out the corresponding dependences,13032as computed by C<isl_union_access_info_compute_flow>.13033 13034=head2 C<isl_codegen>13035 13036Given either a schedule tree or a sequence consisting of13037a schedule map, a context set and an options relation,13038C<isl_codegen> prints out an AST that scans the domain elements13039of the schedule in the order of their image(s) taking into account13040the constraints in the context set.13041 13042=head2 C<isl_schedule>13043 13044Given an C<isl_schedule_constraints> object as input,13045C<isl_schedule> prints out a schedule that satisfies the given13046constraints.13047