isl is a thread-safe C library for manipulating sets and relations of integer points bounded by affine constraints. The descriptions of the sets and relations may involve both parameters and existentially quantified variables. All computations are performed in exact integer arithmetic using GMP or imath. The isl library offers functionality that is similar to that offered by the Omega and Omega+ libraries, but the underlying algorithms are in most cases completely different.
The library is by no means complete and some fairly basic functionality is still missing. Still, even in its current form, the library has been successfully used as a backend polyhedral library for the polyhedral scanner CLooG and as part of an equivalence checker of static affine programs. For bug reports, feature requests and questions, visit the discussion group at http://groups.google.com/group/isl-development.
The old printing functions have been deprecated and replaced by isl_printer functions, see "Input and Output".
Most functions related to dependence analysis have acquired an extra must argument. To obtain the old behavior, this argument should be given the value 1. See "Dependence Analysis".
The function isl_pw_qpolynomial_fold_add has been renamed to isl_pw_qpolynomial_fold_fold. Similarly, isl_union_pw_qpolynomial_fold_add has been renamed to isl_union_pw_qpolynomial_fold_fold.
All header files have been renamed from isl_header.h to isl/header.h.
The functions isl_printer_print_basic_set and isl_printer_print_basic_map no longer print a newline.
The functions isl_flow_get_no_source and isl_union_map_compute_flow now return the accesses for which no source could be found instead of the iterations where those accesses occur.
The functions isl_basic_map_identity and isl_map_identity now take a map space as input. An old call isl_map_identity(space) can be rewritten to isl_map_identity(isl_space_map_from_set(space)).
The function isl_map_power no longer takes a parameter position as input. Instead, the exponent is now expressed as the domain of the resulting relation.
The format of isl_printer_print_qpolynomial's ISL_FORMAT_ISL output has changed. Use ISL_FORMAT_C to obtain the old output.
The *_fast_* functions have been renamed to *_plain_*. Some of the old names have been kept for backward compatibility, but they will be removed in the future.
The function isl_pw_aff_max has been renamed to isl_pw_aff_union_max. Similarly, the function isl_pw_aff_add has been renamed to isl_pw_aff_union_add.
The isl_dim type has been renamed to isl_space along with the associated functions. Some of the old names have been kept for backward compatibility, but they will be removed in the future.
Spaces of maps, sets and parameter domains are now treated differently. The distinction between map spaces and set spaces has always been made on a conceptual level, but proper use of such spaces was never checked. Furthermore, up until isl-0.07 there was no way of explicitly creating a parameter space. These can now be created directly using isl_space_params_alloc or from other spaces using isl_space_params.
The space in which isl_aff, isl_pw_aff, isl_qpolynomial, isl_pw_qpolynomial, isl_qpolynomial_fold and isl_pw_qpolynomial_fold objects live is now a map space instead of a set space. This means, for example, that the dimensions of the domain of an isl_aff are now considered to be of type isl_dim_in instead of isl_dim_set. Extra functions have been added to obtain the domain space. Some of the constructors still take a domain space and have therefore been renamed.
The functions isl_equality_alloc and isl_inequality_alloc now take an isl_local_space instead of an isl_space. An isl_local_space can be created from an isl_space using isl_local_space_from_space.
The isl_div type has been removed. Functions that used to return an isl_div now return an isl_aff. Note that the space of an isl_aff is that of relation. When replacing a call to isl_div_get_coefficient by a call to isl_aff_get_coefficient any isl_dim_set argument needs to be replaced by isl_dim_in. A call to isl_aff_from_div can be replaced by a call to isl_aff_floor. A call to isl_qpolynomial_div(div) call be replaced by the nested call
isl_qpolynomial_from_aff(isl_aff_floor(div))The function isl_constraint_div has also been renamed to isl_constraint_get_div.
The nparam argument has been removed from isl_map_read_from_str and similar functions. When reading input in the original PolyLib format, the result will have no parameters. If parameters are expected, the caller may want to perform dimension manipulation on the result.
The schedule_split_parallel option has been replaced by the schedule_split_scaled option.
The first argument of isl_pw_aff_cond is now an isl_pw_aff instead of an isl_set. A call isl_pw_aff_cond(a, b, c) can be replaced by
isl_pw_aff_cond(isl_set_indicator_function(a), b, c)The functions isl_set_dim_has_lower_bound and isl_set_dim_has_upper_bound have been renamed to isl_set_dim_has_any_lower_bound and isl_set_dim_has_any_upper_bound. The new isl_set_dim_has_lower_bound and isl_set_dim_has_upper_bound have slightly different meanings.
isl_int has been replaced by isl_val. Some of the old functions are still available in isl/deprecated/*.h but they will be removed in the future.
The functions isl_pw_qpolynomial_eval, isl_union_pw_qpolynomial_eval, isl_pw_qpolynomial_fold_eval and isl_union_pw_qpolynomial_fold_eval have been changed to return an isl_val instead of an isl_qpolynomial.
The function isl_band_member_is_zero_distance has been removed. Essentially the same functionality is available through isl_band_member_is_coincident, except that it requires setting up coincidence constraints. The option schedule_outer_zero_distance has accordingly been replaced by the option schedule_outer_coincidence.
The function isl_vertex_get_expr has been changed to return an isl_multi_aff instead of a rational isl_basic_set. The function isl_vertex_get_domain has been changed to return a regular basic set, rather than a rational basic set.
The function isl_union_pw_multi_aff_add now consistently computes the sum on the shared definition domain. The function isl_union_pw_multi_aff_union_add has been added to compute the sum on the union of definition domains. The original behavior of isl_union_pw_multi_aff_add was confused and is no longer available.
Band forests have been replaced by schedule trees.
The function isl_union_map_compute_flow has been replaced by the function isl_union_access_info_compute_flow. Note that the may dependence relation returned by isl_union_flow_get_may_dependence is the union of the two dependence relations returned by isl_union_map_compute_flow. Similarly for the no source relations. The function isl_union_map_compute_flow is still available for backward compatibility, but it will be removed in the future.
The function isl_basic_set_drop_constraint has been deprecated.
The function isl_ast_build_ast_from_schedule has been renamed to isl_ast_build_node_from_schedule_map. The original name is still available for backward compatibility, but it will be removed in the future.
The separation_class AST generation option has been deprecated.
The functions isl_equality_alloc and isl_inequality_alloc have been renamed to isl_constraint_alloc_equality and isl_constraint_alloc_inequality. The original names have been kept for backward compatibility, but they will be removed in the future.
The schedule_fuse option has been replaced by the schedule_serialize_sccs option. The effect of setting the schedule_fuse option to ISL_SCHEDULE_FUSE_MIN is now obtained by turning on the schedule_serialize_sccs option.
The function isl_printer_print_ast_expr no longer prints in C format by default. To print in C format, the output format of the printer needs to have been explicitly set to ISL_FORMAT_C. As a result, the function isl_ast_expr_to_str no longer prints the expression in C format. Use isl_ast_expr_to_C_str instead.
The functions isl_set_align_divs and isl_map_align_divs have been deprecated. The function isl_set_lift has an effect that is similar to isl_set_align_divs and could in some cases be used as an alternative.
Zero-dimensional objects of type isl_multi_pw_aff or isl_multi_union_pw_aff can now keep track of an explicit domain. This explicit domain, if present, is taken into account by various operations that take such objects as input.
Several functions that used to return unsigned now return isl_size. This means that these functions may now return a negative value in case an error occurred. The same holds for functions that used to return int, although some of those were already returning a negative value in case of error.
The isl_ast_op_type enumeration type has been renamed to isl_ast_expr_op_type. The corresponding enumeration constants have been similarly renamed. The old names are defined to the new names for backward compatibility.
Several functions returning an extra boolean value through an int * argument now do so through an isl_bool * argument. The returned values are the same, only the type of the pointer has been changed.
isl is released under the MIT license.
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Note that by default isl requires GMP, which is released under the GNU Lesser General Public License (LGPL). This means that code linked against isl is also linked against LGPL code.
When configuring with --with-int=imath or --with-int=imath-32, isl will link against imath, a library for exact integer arithmetic released under the MIT license.
The source of isl can be obtained either as a tarball or from the git repository. Both are available from https://libisl.sourceforge.io/. The installation process depends on how you obtained the source.
The first time the source is obtained, you need to clone the repository.
git clone git://repo.or.cz/isl.gitTo obtain updates, you need to pull in the latest changes
git pullimath submoduleTo build isl with imath, you need to obtain the imath submodule by running in the git source tree of isl
git submodule init
git submodule updateThis will fetch the required version of imath in a subdirectory of isl.
configure./autogen.shAfter performing the above steps, continue with the "Common installation instructions".
GMPBy default, building isl requires GMP, including its headers files. Your distribution may not provide these header files by default and you may need to install a package called gmp-devel or something similar. Alternatively, GMP can be built from source, available from http://gmplib.org/. GMP is not needed if you build isl with imath.
isl uses the standard autoconf configure script. To run it, just type
./configureoptionally followed by some configure options. A complete list of options can be obtained by running
./configure --helpBelow we discuss some of the more common options.
--prefixInstallation prefix for isl
--with-int=[gmp|imath|imath-32]Select the integer library to be used by isl, the default is gmp. With imath-32, isl will use 32 bit integers, but fall back to imath for values out of the 32 bit range. In most applications, isl will run fastest with the imath-32 option, followed by gmp and imath, the slowest.
--with-gmp-prefix=pathInstallation prefix for GMP (architecture-independent files).
--with-gmp-exec-prefix=pathInstallation prefix for GMP (architecture-dependent files).
makemake checkmake installThe tarball already contains the generated foreign language bindings, but they are not included in the git repository. Building the C++ and Python bindings relies on the LLVM/clang libraries, see http://clang.llvm.org/get_started.html. The configure script will not assume that these are available on the system. To enable building the foreign language bindings, one of the following options needs to be specified.
--with-clang=systemUse the system clang libraries (installed in a default location).
--with-clang-prefix=pathUse the system clang libraries installed in path.
It is best to use the latest release of the clang libraries (16.0), although any release since 3.5 should work as well. Note that if you build the clang libraries from source, then you need to make sure they are also installed (using make install). If the compiler that was used to compile the clang libraries is different from the default C++ compiler, then use CXX_FOR_BUILD to specify this non-default C++ compiler when running isl's ./configure.
Since a high-level operation on isl objects usually involves several substeps and since the user is usually not interested in the intermediate results, most functions that return a new object will also release all the objects passed as arguments. If the user still wants to use one or more of these arguments after the function call, she should pass along a copy of the object rather than the object itself. The user is then responsible for making sure that the original object gets used somewhere else or is explicitly freed.
The arguments and return values of all documented functions are annotated to make clear which arguments are released and which arguments are preserved. In particular, the following annotations are used
__isl_give__isl_give means that a new object is returned. The user should make sure that the returned pointer is used exactly once as a value for an __isl_take argument. In between, it can be used as a value for as many __isl_keep arguments as the user likes. There is one exception, and that is the case where the pointer returned is NULL. In this case, the user is free to use it as an __isl_take argument or not. When applied to a char *, the returned pointer needs to be freed using free.
__isl_null__isl_null means that a NULL value is returned.
__isl_take__isl_take means that the object the argument points to is taken over by the function and may no longer be used by the user as an argument to any other function. The pointer value must be one returned by a function returning an __isl_give pointer. If the user passes in a NULL value, then this will be treated as an error in the sense that the function will not perform its usual operation. However, it will still make sure that all the other __isl_take arguments are released.
__isl_keep__isl_keep means that the function will only use the object temporarily. After the function has finished, the user can still use it as an argument to other functions. A NULL value will be treated in the same way as a NULL value for an __isl_take argument. This annotation may also be used on return values of type const char *, in which case the returned pointer should not be freed by the user and is only valid until the object from which it was derived is updated or freed.
All manipulations of integer sets and relations occur within the context of an isl_ctx. A given isl_ctx can only be used within a single thread. All arguments of a function are required to have been allocated within the same context. There are currently no functions available for moving an object from one isl_ctx to another isl_ctx. This means that there is currently no way of safely moving an object from one thread to another, unless the whole isl_ctx is moved.
An isl_ctx can be allocated using isl_ctx_alloc and freed using isl_ctx_free. All objects allocated within an isl_ctx should be freed before the isl_ctx itself is freed.
isl_ctx *isl_ctx_alloc();
void isl_ctx_free(isl_ctx *ctx);The user can impose a bound on the number of low-level operations that can be performed by an isl_ctx. This bound can be set and retrieved using the following functions. A bound of zero means that no bound is imposed. The number of operations performed can be reset using isl_ctx_reset_operations. Note that the number of low-level operations needed to perform a high-level computation may differ significantly across different versions of isl, but it should be the same across different platforms for the same version of isl.
Warning: This feature is experimental. isl has good support to abort and bail out during the computation, but this feature may exercise error code paths that are normally not used that much. Consequently, it is not unlikely that hidden bugs will be exposed.
void isl_ctx_set_max_operations(isl_ctx *ctx,
unsigned long max_operations);
unsigned long isl_ctx_get_max_operations(isl_ctx *ctx);
void isl_ctx_reset_operations(isl_ctx *ctx);In order to be able to create an object in the same context as another object, most object types (described later in this document) provide a function to obtain the context in which the object was created.
#include <isl/val.h>
isl_ctx *isl_val_get_ctx(__isl_keep isl_val *val);
isl_ctx *isl_multi_val_get_ctx(
__isl_keep isl_multi_val *mv);
#include <isl/id.h>
isl_ctx *isl_id_get_ctx(__isl_keep isl_id *id);
isl_ctx *isl_multi_id_get_ctx(
__isl_keep isl_multi_id *mi);
#include <isl/local_space.h>
isl_ctx *isl_local_space_get_ctx(
__isl_keep isl_local_space *ls);
#include <isl/set.h>
isl_ctx *isl_set_list_get_ctx(
__isl_keep isl_set_list *list);
#include <isl/aff.h>
isl_ctx *isl_aff_get_ctx(__isl_keep isl_aff *aff);
isl_ctx *isl_multi_aff_get_ctx(
__isl_keep isl_multi_aff *maff);
isl_ctx *isl_pw_aff_get_ctx(__isl_keep isl_pw_aff *pa);
isl_ctx *isl_pw_multi_aff_get_ctx(
__isl_keep isl_pw_multi_aff *pma);
isl_ctx *isl_multi_pw_aff_get_ctx(
__isl_keep isl_multi_pw_aff *mpa);
isl_ctx *isl_union_pw_aff_get_ctx(
__isl_keep isl_union_pw_aff *upa);
isl_ctx *isl_union_pw_multi_aff_get_ctx(
__isl_keep isl_union_pw_multi_aff *upma);
isl_ctx *isl_multi_union_pw_aff_get_ctx(
__isl_keep isl_multi_union_pw_aff *mupa);
#include <isl/id_to_ast_expr.h>
isl_ctx *isl_id_to_ast_expr_get_ctx(
__isl_keep isl_id_to_ast_expr *id2expr);
#include <isl/point.h>
isl_ctx *isl_point_get_ctx(__isl_keep isl_point *pnt);
#include <isl/vec.h>
isl_ctx *isl_vec_get_ctx(__isl_keep isl_vec *vec);
#include <isl/mat.h>
isl_ctx *isl_mat_get_ctx(__isl_keep isl_mat *mat);
#include <isl/vertices.h>
isl_ctx *isl_vertices_get_ctx(
__isl_keep isl_vertices *vertices);
isl_ctx *isl_vertex_get_ctx(__isl_keep isl_vertex *vertex);
isl_ctx *isl_cell_get_ctx(__isl_keep isl_cell *cell);
#include <isl/flow.h>
isl_ctx *isl_restriction_get_ctx(
__isl_keep isl_restriction *restr);
isl_ctx *isl_union_access_info_get_ctx(
__isl_keep isl_union_access_info *access);
isl_ctx *isl_union_flow_get_ctx(
__isl_keep isl_union_flow *flow);
#include <isl/schedule.h>
isl_ctx *isl_schedule_get_ctx(
__isl_keep isl_schedule *sched);
isl_ctx *isl_schedule_constraints_get_ctx(
__isl_keep isl_schedule_constraints *sc);
#include <isl/schedule_node.h>
isl_ctx *isl_schedule_node_get_ctx(
__isl_keep isl_schedule_node *node);
#include <isl/ast_build.h>
isl_ctx *isl_ast_build_get_ctx(
__isl_keep isl_ast_build *build);
#include <isl/ast.h>
isl_ctx *isl_ast_expr_get_ctx(
__isl_keep isl_ast_expr *expr);
isl_ctx *isl_ast_node_get_ctx(
__isl_keep isl_ast_node *node);
#include <isl/stride_info.h>
isl_ctx *isl_stride_info_get_ctx(
__isl_keep isl_stride_info *si);
#include <isl/fixed_box.h>
isl_ctx *isl_fixed_box_get_ctx(
__isl_keep isl_fixed_box *box);isl uses the special return type isl_size for functions that return a non-negative value, typically a number or a position. Besides the regular non-negative return values, a special (negative) value isl_size_error may be returned, indicating that something went wrong.
isl also uses two special return types for functions that either return a boolean or that in principle do not return anything. In particular, the isl_bool type has three possible values: isl_bool_true (a positive integer value), indicating true or yes; isl_bool_false (the integer value zero), indicating false or no; and isl_bool_error (a negative integer value), indicating that something went wrong. The following operations are defined on isl_bool. The function isl_bool_not can be used to negate an isl_bool, where the negation of isl_bool_error is isl_bool_error again. The function isl_bool_ok converts an integer to an isl_bool. Any non-zero values yields isl_bool_true and zero yields isl_bool_false.
#include <isl/ctx.h>
isl_bool isl_bool_not(isl_bool b);
isl_bool isl_bool_ok(int b);The isl_stat type has two possible values: isl_stat_ok (the integer value zero), indicating a successful operation; and isl_stat_error (a negative integer value), indicating that something went wrong. The function isl_stat_non_null converts an isl object pointer to an isl_stat, returning isl_stat_ok if the object pointer is valid and isl_stat_error if it is NULL. Similarly, the function isl_stat_non_error_bool converts an isl_bool to an isl_stat, returning isl_stat_ok if the isl_bool represents a valid result and isl_stat_error if it is isl_bool_error.
#include <isl/ctx.h>
isl_stat isl_stat_non_null(void *obj);
isl_stat isl_stat_non_error_bool(isl_bool b);See "Error Handling" for more information on isl_size_error, isl_bool_error and isl_stat_error.
An isl_val represents an integer value, a rational value or one of three special values, infinity, negative infinity and NaN. Some predefined values can be created using the following functions.
#include <isl/val.h>
__isl_give isl_val *isl_val_zero(isl_ctx *ctx);
__isl_give isl_val *isl_val_one(isl_ctx *ctx);
__isl_give isl_val *isl_val_negone(isl_ctx *ctx);
__isl_give isl_val *isl_val_nan(isl_ctx *ctx);
__isl_give isl_val *isl_val_infty(isl_ctx *ctx);
__isl_give isl_val *isl_val_neginfty(isl_ctx *ctx);Specific integer values can be created using the following functions.
#include <isl/val.h>
__isl_give isl_val *isl_val_int_from_si(isl_ctx *ctx,
long i);
__isl_give isl_val *isl_val_int_from_ui(isl_ctx *ctx,
unsigned long u);
__isl_give isl_val *isl_val_int_from_chunks(isl_ctx *ctx,
size_t n, size_t size, const void *chunks);The function isl_val_int_from_chunks constructs an isl_val from the n digits, each consisting of size bytes, stored at chunks. The least significant digit is assumed to be stored first.
Value objects can be copied and freed using the following functions.
#include <isl/val.h>
__isl_give isl_val *isl_val_copy(__isl_keep isl_val *v);
__isl_null isl_val *isl_val_free(__isl_take isl_val *v);They can be inspected using the following functions.
#include <isl/val.h>
long isl_val_get_num_si(__isl_keep isl_val *v);
long isl_val_get_den_si(__isl_keep isl_val *v);
__isl_give isl_val *isl_val_get_den_val(
__isl_keep isl_val *v);
double isl_val_get_d(__isl_keep isl_val *v);
isl_size isl_val_n_abs_num_chunks(__isl_keep isl_val *v,
size_t size);
isl_stat isl_val_get_abs_num_chunks(__isl_keep isl_val *v,
size_t size, void *chunks);isl_val_n_abs_num_chunks returns the number of digits of size bytes needed to store the absolute value of the numerator of v. isl_val_get_abs_num_chunks stores these digits at chunks, which is assumed to have been preallocated by the caller. The least significant digit is stored first. Note that isl_val_get_num_si, isl_val_get_den_si, isl_val_get_d, isl_val_n_abs_num_chunks and isl_val_get_abs_num_chunks can only be applied to rational values.
An isl_val can be modified using the following function.
#include <isl/val.h>
__isl_give isl_val *isl_val_set_si(__isl_take isl_val *v,
long i);The following unary properties are defined on isl_vals.
#include <isl/val.h>
int isl_val_sgn(__isl_keep isl_val *v);
isl_bool isl_val_is_zero(__isl_keep isl_val *v);
isl_bool isl_val_is_one(__isl_keep isl_val *v);
isl_bool isl_val_is_negone(__isl_keep isl_val *v);
isl_bool isl_val_is_nonneg(__isl_keep isl_val *v);
isl_bool isl_val_is_nonpos(__isl_keep isl_val *v);
isl_bool isl_val_is_pos(__isl_keep isl_val *v);
isl_bool isl_val_is_neg(__isl_keep isl_val *v);
isl_bool isl_val_is_int(__isl_keep isl_val *v);
isl_bool isl_val_is_rat(__isl_keep isl_val *v);
isl_bool isl_val_is_nan(__isl_keep isl_val *v);
isl_bool isl_val_is_infty(__isl_keep isl_val *v);
isl_bool isl_val_is_neginfty(__isl_keep isl_val *v);Note that the sign of NaN is undefined.
The following binary properties are defined on pairs of isl_vals.
#include <isl/val.h>
isl_bool isl_val_lt(__isl_keep isl_val *v1,
__isl_keep isl_val *v2);
isl_bool isl_val_le(__isl_keep isl_val *v1,
__isl_keep isl_val *v2);
isl_bool isl_val_gt(__isl_keep isl_val *v1,
__isl_keep isl_val *v2);
isl_bool isl_val_ge(__isl_keep isl_val *v1,
__isl_keep isl_val *v2);
isl_bool isl_val_eq(__isl_keep isl_val *v1,
__isl_keep isl_val *v2);
isl_bool isl_val_ne(__isl_keep isl_val *v1,
__isl_keep isl_val *v2);
isl_bool isl_val_abs_eq(__isl_keep isl_val *v1,
__isl_keep isl_val *v2);Comparisons to NaN always return false. That is, a NaN is not considered to hold any relative position with respect to any value. In particular, a NaN is neither considered to be equal to nor to be different from any value (including another NaN). The function isl_val_abs_eq checks whether its two arguments are equal in absolute value.
For integer isl_vals we additionally have the following binary property.
#include <isl/val.h>
isl_bool isl_val_is_divisible_by(__isl_keep isl_val *v1,
__isl_keep isl_val *v2);An isl_val can also be compared to an integer using the following functions. The result of isl_val_cmp_si is undefined for NaN.
#include <isl/val.h>
isl_bool isl_val_gt_si(__isl_keep isl_val *v, long i);
isl_bool isl_val_eq_si(__isl_keep isl_val *v, long i);
int isl_val_cmp_si(__isl_keep isl_val *v, long i);The following unary operations are available on isl_vals.
#include <isl/val.h>
__isl_give isl_val *isl_val_abs(__isl_take isl_val *v);
__isl_give isl_val *isl_val_neg(__isl_take isl_val *v);
__isl_give isl_val *isl_val_floor(__isl_take isl_val *v);
__isl_give isl_val *isl_val_ceil(__isl_take isl_val *v);
__isl_give isl_val *isl_val_trunc(__isl_take isl_val *v);
__isl_give isl_val *isl_val_inv(__isl_take isl_val *v);The following binary operations are available on isl_vals.
#include <isl/val.h>
__isl_give isl_val *isl_val_min(__isl_take isl_val *v1,
__isl_take isl_val *v2);
__isl_give isl_val *isl_val_max(__isl_take isl_val *v1,
__isl_take isl_val *v2);
__isl_give isl_val *isl_val_add(__isl_take isl_val *v1,
__isl_take isl_val *v2);
__isl_give isl_val *isl_val_add_ui(__isl_take isl_val *v1,
unsigned long v2);
__isl_give isl_val *isl_val_sub(__isl_take isl_val *v1,
__isl_take isl_val *v2);
__isl_give isl_val *isl_val_sub_ui(__isl_take isl_val *v1,
unsigned long v2);
__isl_give isl_val *isl_val_mul(__isl_take isl_val *v1,
__isl_take isl_val *v2);
__isl_give isl_val *isl_val_mul_ui(__isl_take isl_val *v1,
unsigned long v2);
__isl_give isl_val *isl_val_div(__isl_take isl_val *v1,
__isl_take isl_val *v2);
__isl_give isl_val *isl_val_div_ui(__isl_take isl_val *v1,
unsigned long v2);On integer values, we additionally have the following operations.
#include <isl/val.h>
__isl_give isl_val *isl_val_pow2(__isl_take isl_val *v);
__isl_give isl_val *isl_val_2exp(__isl_take isl_val *v);
__isl_give isl_val *isl_val_mod(__isl_take isl_val *v1,
__isl_take isl_val *v2);
__isl_give isl_val *isl_val_gcd(__isl_take isl_val *v1,
__isl_take isl_val *v2);
__isl_give isl_val *isl_val_gcdext(__isl_take isl_val *v1,
__isl_take isl_val *v2, __isl_give isl_val **x,
__isl_give isl_val **y);isl_val_2exp is an alternative name for isl_val_pow2. The function isl_val_gcdext returns the greatest common divisor g of v1 and v2 as well as two integers *x and *y such that *x * v1 + *y * v2 = g.
These functions are only available if isl has been compiled with GMP support.
Specific integer and rational values can be created from GMP values using the following functions.
#include <isl/val_gmp.h>
__isl_give isl_val *isl_val_int_from_gmp(isl_ctx *ctx,
mpz_t z);
__isl_give isl_val *isl_val_from_gmp(isl_ctx *ctx,
const mpz_t n, const mpz_t d);The numerator and denominator of a rational value can be extracted as GMP values using the following functions.
#include <isl/val_gmp.h>
int isl_val_get_num_gmp(__isl_keep isl_val *v, mpz_t z);
int isl_val_get_den_gmp(__isl_keep isl_val *v, mpz_t z);isl uses six types of objects for representing sets and relations, isl_basic_set, isl_basic_map, isl_set, isl_map, isl_union_set and isl_union_map. isl_basic_set and isl_basic_map represent sets and relations that can be described as a conjunction of affine constraints, while isl_set and isl_map represent unions of isl_basic_sets and isl_basic_maps, respectively. However, all isl_basic_sets or isl_basic_maps in the union need to live in the same space. isl_union_sets and isl_union_maps represent unions of isl_sets or isl_maps in different spaces, where spaces are considered different if they have a different number of dimensions and/or different names (see "Spaces"). The difference between sets and relations (maps) is that sets have one set of variables, while relations have two sets of variables, input variables and output variables.
isl supports different ways to react in case a runtime error is triggered. Runtime errors arise, e.g., if a function such as isl_map_intersect is called with two maps that have incompatible spaces. There are three possible ways to react on error: to warn, to continue or to abort.
The default behavior is to warn. In this mode, isl prints a warning, stores the last error in the corresponding isl_ctx and the function in which the error was triggered returns a value indicating that some error has occurred. In case of functions returning a pointer, this value is NULL. In case of functions returning an isl_size, isl_bool or an isl_stat, this value is isl_size_error, isl_bool_error or isl_stat_error. An error does not corrupt internal state, such that isl can continue to be used. isl also provides functions to read the last error, including the specific error message, the isl source file where the error occurred and the line number, and to reset all information about the last error. The last error is only stored for information purposes. Its presence does not change the behavior of isl. Hence, resetting an error is not required to continue to use isl, but only to observe new errors.
#include <isl/ctx.h>
enum isl_error isl_ctx_last_error(isl_ctx *ctx);
const char *isl_ctx_last_error_msg(isl_ctx *ctx);
const char *isl_ctx_last_error_file(isl_ctx *ctx);
int isl_ctx_last_error_line(isl_ctx *ctx);
void isl_ctx_reset_error(isl_ctx *ctx);If no error has occurred since the last call to isl_ctx_reset_error, then the functions isl_ctx_last_error_msg and isl_ctx_last_error_file return NULL.
Another option is to continue on error. This is similar to warn on error mode, except that isl does not print any warning. This allows a program to implement its own error reporting.
The last option is to directly abort the execution of the program from within the isl library. This makes it obviously impossible to recover from an error, but it allows to directly spot the error location. By aborting on error, debuggers break at the location the error occurred and can provide a stack trace. Other tools that automatically provide stack traces on abort or that do not want to continue execution after an error was triggered may also prefer to abort on error.
The on error behavior of isl can be specified by calling isl_options_set_on_error or by setting the command line option --isl-on-error. Valid arguments for the function call are ISL_ON_ERROR_WARN, ISL_ON_ERROR_CONTINUE and ISL_ON_ERROR_ABORT. The choices for the command line option are warn, continue and abort. It is also possible to query the current error mode.
#include <isl/options.h>
isl_stat isl_options_set_on_error(isl_ctx *ctx, int val);
int isl_options_get_on_error(isl_ctx *ctx);Identifiers are used to identify both individual dimensions and tuples of dimensions. They consist of an optional name and an optional user pointer. The name and the user pointer cannot both be NULL, however. Identifiers with the same name but different pointer values are considered to be distinct. Similarly, identifiers with different names but the same pointer value are also considered to be distinct. Equal identifiers are represented using the same object. Pairs of identifiers can therefore be tested for equality using the == operator. Identifiers can be constructed, copied, freed, inspected and printed using the following functions.
#include <isl/id.h>
__isl_give isl_id *isl_id_alloc(isl_ctx *ctx,
__isl_keep const char *name, void *user);
__isl_give isl_id *isl_id_set_free_user(
__isl_take isl_id *id,
void (*free_user)(void *user));
void (*isl_id_get_free_user(__isl_keep isl_id *id))
(void *user);
__isl_give isl_id *isl_id_copy(isl_id *id);
__isl_null isl_id *isl_id_free(__isl_take isl_id *id);
void *isl_id_get_user(__isl_keep isl_id *id);
__isl_keep const char *isl_id_get_name(__isl_keep isl_id *id);
__isl_give isl_printer *isl_printer_print_id(
__isl_take isl_printer *p, __isl_keep isl_id *id);The callback set by isl_id_set_free_user is called on the user pointer when the last reference to the isl_id is freed. This callback can be retrieved using isl_id_get_free_user. Note that isl_id_get_name returns a pointer to some internal data structure, so the result can only be used while the corresponding isl_id is alive.
Whenever a new set, relation or similar object is created from scratch, the space in which it lives needs to be specified using an isl_space. Each space involves zero or more parameters and zero, one or two tuples of set or input/output dimensions. The parameters and dimensions are identified by an isl_dim_type and a position. The type isl_dim_param refers to parameters, the type isl_dim_set refers to set dimensions (for spaces with a single tuple of dimensions) and the types isl_dim_in and isl_dim_out refer to input and output dimensions (for spaces with two tuples of dimensions). Local spaces (see "Local Spaces") also contain dimensions of type isl_dim_div. Note that parameters are only identified by their position within a given object. Across different objects, parameters are (usually) identified by their names or identifiers. Only unnamed parameters are identified by their positions across objects. The use of unnamed parameters is discouraged.
#include <isl/space.h>
__isl_give isl_space *isl_space_unit(isl_ctx *ctx);
__isl_give isl_space *isl_space_alloc(isl_ctx *ctx,
unsigned nparam, unsigned n_in, unsigned n_out);
__isl_give isl_space *isl_space_params_alloc(isl_ctx *ctx,
unsigned nparam);
__isl_give isl_space *isl_space_set_alloc(isl_ctx *ctx,
unsigned nparam, unsigned dim);
__isl_give isl_space *isl_space_copy(__isl_keep isl_space *space);
__isl_null isl_space *isl_space_free(__isl_take isl_space *space);The space used for creating a parameter domain needs to be created using isl_space_unit or isl_space_params_alloc. For other sets, the space needs to be created using isl_space_set_alloc, while for a relation, the space needs to be created using isl_space_alloc. The use of isl_space_params_alloc, isl_space_set_alloc and isl_space_alloc is discouraged as they allow for the introduction of unnamed parameters.
To check whether a given space is that of a set or a map or whether it is a parameter space, use these functions:
#include <isl/space.h>
isl_bool isl_space_is_params(__isl_keep isl_space *space);
isl_bool isl_space_is_set(__isl_keep isl_space *space);
isl_bool isl_space_is_map(__isl_keep isl_space *space);Spaces can be compared using the following functions:
#include <isl/space.h>
isl_bool isl_space_is_equal(__isl_keep isl_space *space1,
__isl_keep isl_space *space2);
isl_bool isl_space_has_equal_params(
__isl_keep isl_space *space1,
__isl_keep isl_space *space2);
isl_bool isl_space_has_equal_tuples(
__isl_keep isl_space *space1,
__isl_keep isl_space *space2);
isl_bool isl_space_is_domain(__isl_keep isl_space *space1,
__isl_keep isl_space *space2);
isl_bool isl_space_is_range(__isl_keep isl_space *space1,
__isl_keep isl_space *space2);
isl_bool isl_space_tuple_is_equal(
__isl_keep isl_space *space1,
enum isl_dim_type type1,
__isl_keep isl_space *space2,
enum isl_dim_type type2);isl_space_is_domain checks whether the first argument is equal to the domain of the second argument. This requires in particular that the first argument is a set space and that the second argument is a map space. isl_space_tuple_is_equal checks whether the given tuples (isl_dim_in, isl_dim_out or isl_dim_set) of the given spaces are the same. That is, it checks if they have the same identifier (if any), the same dimension and the same internal structure (if any). The function isl_space_has_equal_params checks whether two spaces have the same parameters in the same order. isl_space_has_equal_tuples check whether two spaces have the same tuples. In contrast to isl_space_is_equal below, it does not check the parameters. This is useful because many isl functions align the parameters before they perform their operations, such that equivalence is not necessary. isl_space_is_equal checks whether two spaces are identical, meaning that they have the same parameters and the same tuples. That is, it checks whether both isl_space_has_equal_params and isl_space_has_equal_tuples hold.
It is often useful to create objects that live in the same space as some other object. This can be accomplished by creating the new objects (see "Creating New Sets and Relations" or "Functions") based on the space of the original object.
#include <isl/set.h>
__isl_give isl_space *isl_basic_set_get_space(
__isl_keep isl_basic_set *bset);
__isl_give isl_space *isl_set_get_space(__isl_keep isl_set *set);
#include <isl/union_set.h>
__isl_give isl_space *isl_union_set_get_space(
__isl_keep isl_union_set *uset);
#include <isl/map.h>
__isl_give isl_space *isl_basic_map_get_space(
__isl_keep isl_basic_map *bmap);
__isl_give isl_space *isl_map_get_space(__isl_keep isl_map *map);
#include <isl/union_map.h>
__isl_give isl_space *isl_union_map_get_space(
__isl_keep isl_union_map *umap);
#include <isl/constraint.h>
__isl_give isl_space *isl_constraint_get_space(
__isl_keep isl_constraint *constraint);
#include <isl/polynomial.h>
__isl_give isl_space *isl_qpolynomial_get_domain_space(
__isl_keep isl_qpolynomial *qp);
__isl_give isl_space *isl_qpolynomial_get_space(
__isl_keep isl_qpolynomial *qp);
__isl_give isl_space *
isl_qpolynomial_fold_get_domain_space(
__isl_keep isl_qpolynomial_fold *fold);
__isl_give isl_space *isl_qpolynomial_fold_get_space(
__isl_keep isl_qpolynomial_fold *fold);
__isl_give isl_space *isl_pw_qpolynomial_get_domain_space(
__isl_keep isl_pw_qpolynomial *pwqp);
__isl_give isl_space *isl_pw_qpolynomial_get_space(
__isl_keep isl_pw_qpolynomial *pwqp);
__isl_give isl_space *isl_pw_qpolynomial_fold_get_domain_space(
__isl_keep isl_pw_qpolynomial_fold *pwf);
__isl_give isl_space *isl_pw_qpolynomial_fold_get_space(
__isl_keep isl_pw_qpolynomial_fold *pwf);
__isl_give isl_space *isl_union_pw_qpolynomial_get_space(
__isl_keep isl_union_pw_qpolynomial *upwqp);
__isl_give isl_space *isl_union_pw_qpolynomial_fold_get_space(
__isl_keep isl_union_pw_qpolynomial_fold *upwf);
#include <isl/id.h>
__isl_give isl_space *isl_multi_id_get_space(
__isl_keep isl_multi_id *mi);
#include <isl/val.h>
__isl_give isl_space *isl_multi_val_get_space(
__isl_keep isl_multi_val *mv);
#include <isl/aff.h>
__isl_give isl_space *isl_aff_get_domain_space(
__isl_keep isl_aff *aff);
__isl_give isl_space *isl_aff_get_space(
__isl_keep isl_aff *aff);
__isl_give isl_space *isl_pw_aff_get_domain_space(
__isl_keep isl_pw_aff *pwaff);
__isl_give isl_space *isl_pw_aff_get_space(
__isl_keep isl_pw_aff *pwaff);
__isl_give isl_space *isl_multi_aff_get_domain_space(
__isl_keep isl_multi_aff *maff);
__isl_give isl_space *isl_multi_aff_get_space(
__isl_keep isl_multi_aff *maff);
__isl_give isl_space *isl_pw_multi_aff_get_domain_space(
__isl_keep isl_pw_multi_aff *pma);
__isl_give isl_space *isl_pw_multi_aff_get_space(
__isl_keep isl_pw_multi_aff *pma);
__isl_give isl_space *isl_union_pw_aff_get_space(
__isl_keep isl_union_pw_aff *upa);
__isl_give isl_space *isl_union_pw_multi_aff_get_space(
__isl_keep isl_union_pw_multi_aff *upma);
__isl_give isl_space *isl_multi_pw_aff_get_domain_space(
__isl_keep isl_multi_pw_aff *mpa);
__isl_give isl_space *isl_multi_pw_aff_get_space(
__isl_keep isl_multi_pw_aff *mpa);
__isl_give isl_space *
isl_multi_union_pw_aff_get_domain_space(
__isl_keep isl_multi_union_pw_aff *mupa);
__isl_give isl_space *
isl_multi_union_pw_aff_get_space(
__isl_keep isl_multi_union_pw_aff *mupa);
#include <isl/point.h>
__isl_give isl_space *isl_point_get_space(
__isl_keep isl_point *pnt);
#include <isl/fixed_box.h>
__isl_give isl_space *isl_fixed_box_get_space(
__isl_keep isl_fixed_box *box);The number of dimensions of a given type of space may be read off from a space or an object that lives in a space using the following functions. In case of isl_space_dim, type may be isl_dim_param, isl_dim_in (only for relations), isl_dim_out (only for relations), isl_dim_set (only for sets) or isl_dim_all.
#include <isl/space.h>
isl_size isl_space_dim(__isl_keep isl_space *space,
enum isl_dim_type type);
#include <isl/local_space.h>
isl_size isl_local_space_dim(__isl_keep isl_local_space *ls,
enum isl_dim_type type);
#include <isl/set.h>
isl_size isl_basic_set_dim(__isl_keep isl_basic_set *bset,
enum isl_dim_type type);
isl_size isl_set_tuple_dim(__isl_keep isl_set *set);
isl_size isl_set_dim(__isl_keep isl_set *set,
enum isl_dim_type type);
#include <isl/union_set.h>
isl_size isl_union_set_dim(__isl_keep isl_union_set *uset,
enum isl_dim_type type);
#include <isl/map.h>
isl_size isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
enum isl_dim_type type);
isl_size isl_map_domain_tuple_dim(
__isl_keep isl_map *map);
isl_size isl_map_range_tuple_dim(
__isl_keep isl_map *map);
isl_size isl_map_dim(__isl_keep isl_map *map,
enum isl_dim_type type);
#include <isl/union_map.h>
isl_size isl_union_map_dim(__isl_keep isl_union_map *umap,
enum isl_dim_type type);
#include <isl/val.h>
isl_size isl_multi_val_dim(__isl_keep isl_multi_val *mv,
enum isl_dim_type type);
#include <isl/aff.h>
isl_size isl_aff_dim(__isl_keep isl_aff *aff,
enum isl_dim_type type);
isl_size isl_multi_aff_dim(__isl_keep isl_multi_aff *maff,
enum isl_dim_type type);
isl_size isl_pw_aff_dim(__isl_keep isl_pw_aff *pwaff,
enum isl_dim_type type);
isl_size isl_pw_multi_aff_dim(
__isl_keep isl_pw_multi_aff *pma,
enum isl_dim_type type);
isl_size isl_multi_pw_aff_dim(
__isl_keep isl_multi_pw_aff *mpa,
enum isl_dim_type type);
isl_size isl_union_pw_aff_dim(
__isl_keep isl_union_pw_aff *upa,
enum isl_dim_type type);
isl_size isl_union_pw_multi_aff_dim(
__isl_keep isl_union_pw_multi_aff *upma,
enum isl_dim_type type);
isl_size isl_multi_union_pw_aff_dim(
__isl_keep isl_multi_union_pw_aff *mupa,
enum isl_dim_type type);
#include <isl/polynomial.h>
isl_size isl_union_pw_qpolynomial_dim(
__isl_keep isl_union_pw_qpolynomial *upwqp,
enum isl_dim_type type);
isl_size isl_union_pw_qpolynomial_fold_dim(
__isl_keep isl_union_pw_qpolynomial_fold *upwf,
enum isl_dim_type type);Note that an isl_union_set, an isl_union_map, an isl_union_pw_multi_aff, an isl_union_pw_qpolynomial and an isl_union_pw_qpolynomial_fold only have parameters.
Additional parameters can be added to a space using the following function.
#include <isl/space.h>
__isl_give isl_space *isl_space_add_param_id(
__isl_take isl_space *space,
__isl_take isl_id *id);If a parameter with the given identifier already appears in the space, then it is not added again.
Conversely, all parameters can be removed from a space using the following function.
#include <isl/space.h>
__isl_give isl_space *isl_space_drop_all_params(
__isl_take isl_space *space);The identifiers or names of the individual dimensions of spaces may be set or read off using the following functions on spaces or objects that live in spaces. These functions are mostly useful to obtain the identifiers, positions or names of the parameters. Identifiers of individual dimensions are essentially only useful for printing. They are ignored by all other operations and may not be preserved across those operations. To keep track of a space along with names/identifiers of the set dimensions, use an isl_multi_id as described in "Functions".
#include <isl/space.h>
__isl_give isl_space *isl_space_set_dim_id(
__isl_take isl_space *space,
enum isl_dim_type type, unsigned pos,
__isl_take isl_id *id);
isl_bool isl_space_has_dim_id(__isl_keep isl_space *space,
enum isl_dim_type type, unsigned pos);
__isl_give isl_id *isl_space_get_dim_id(
__isl_keep isl_space *space,
enum isl_dim_type type, unsigned pos);
__isl_give isl_space *isl_space_set_dim_name(
__isl_take isl_space *space,
enum isl_dim_type type, unsigned pos,
__isl_keep const char *name);
isl_bool isl_space_has_dim_name(__isl_keep isl_space *space,
enum isl_dim_type type, unsigned pos);
__isl_keep const char *isl_space_get_dim_name(
__isl_keep isl_space *space,
enum isl_dim_type type, unsigned pos);
#include <isl/local_space.h>
__isl_give isl_local_space *isl_local_space_set_dim_id(
__isl_take isl_local_space *ls,
enum isl_dim_type type, unsigned pos,
__isl_take isl_id *id);
isl_bool isl_local_space_has_dim_id(
__isl_keep isl_local_space *ls,
enum isl_dim_type type, unsigned pos);
__isl_give isl_id *isl_local_space_get_dim_id(
__isl_keep isl_local_space *ls,
enum isl_dim_type type, unsigned pos);
__isl_give isl_local_space *isl_local_space_set_dim_name(
__isl_take isl_local_space *ls,
enum isl_dim_type type, unsigned pos, const char *s);
isl_bool isl_local_space_has_dim_name(
__isl_keep isl_local_space *ls,
enum isl_dim_type type, unsigned pos)
const char *isl_local_space_get_dim_name(
__isl_keep isl_local_space *ls,
enum isl_dim_type type, unsigned pos);
#include <isl/constraint.h>
const char *isl_constraint_get_dim_name(
__isl_keep isl_constraint *constraint,
enum isl_dim_type type, unsigned pos);
#include <isl/set.h>
__isl_give isl_id *isl_basic_set_get_dim_id(
__isl_keep isl_basic_set *bset,
enum isl_dim_type type, unsigned pos);
__isl_give isl_set *isl_set_set_dim_id(
__isl_take isl_set *set, enum isl_dim_type type,
unsigned pos, __isl_take isl_id *id);
isl_bool isl_set_has_dim_id(__isl_keep isl_set *set,
enum isl_dim_type type, unsigned pos);
__isl_give isl_id *isl_set_get_dim_id(
__isl_keep isl_set *set, enum isl_dim_type type,
unsigned pos);
const char *isl_basic_set_get_dim_name(
__isl_keep isl_basic_set *bset,
enum isl_dim_type type, unsigned pos);
isl_bool isl_set_has_dim_name(__isl_keep isl_set *set,
enum isl_dim_type type, unsigned pos);
const char *isl_set_get_dim_name(
__isl_keep isl_set *set,
enum isl_dim_type type, unsigned pos);
#include <isl/map.h>
__isl_give isl_map *isl_map_set_dim_id(
__isl_take isl_map *map, enum isl_dim_type type,
unsigned pos, __isl_take isl_id *id);
isl_bool isl_basic_map_has_dim_id(
__isl_keep isl_basic_map *bmap,
enum isl_dim_type type, unsigned pos);
isl_bool isl_map_has_dim_id(__isl_keep isl_map *map,
enum isl_dim_type type, unsigned pos);
__isl_give isl_id *isl_map_get_dim_id(
__isl_keep isl_map *map, enum isl_dim_type type,
unsigned pos);
__isl_give isl_id *isl_union_map_get_dim_id(
__isl_keep isl_union_map *umap,
enum isl_dim_type type, unsigned pos);
const char *isl_basic_map_get_dim_name(
__isl_keep isl_basic_map *bmap,
enum isl_dim_type type, unsigned pos);
isl_bool isl_map_has_dim_name(__isl_keep isl_map *map,
enum isl_dim_type type, unsigned pos);
const char *isl_map_get_dim_name(
__isl_keep isl_map *map,
enum isl_dim_type type, unsigned pos);
#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_set_dim_id(
__isl_take isl_multi_val *mv,
enum isl_dim_type type, unsigned pos,
__isl_take isl_id *id);
__isl_give isl_id *isl_multi_val_get_dim_id(
__isl_keep isl_multi_val *mv,
enum isl_dim_type type, unsigned pos);
__isl_give isl_multi_val *isl_multi_val_set_dim_name(
__isl_take isl_multi_val *mv,
enum isl_dim_type type, unsigned pos, const char *s);
#include <isl/aff.h>
__isl_give isl_aff *isl_aff_set_dim_id(
__isl_take isl_aff *aff, enum isl_dim_type type,
unsigned pos, __isl_take isl_id *id);
__isl_give isl_multi_aff *isl_multi_aff_set_dim_id(
__isl_take isl_multi_aff *maff,
enum isl_dim_type type, unsigned pos,
__isl_take isl_id *id);
__isl_give isl_pw_aff *isl_pw_aff_set_dim_id(
__isl_take isl_pw_aff *pma,
enum isl_dim_type type, unsigned pos,
__isl_take isl_id *id);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_set_dim_id(
__isl_take isl_multi_pw_aff *mpa,
enum isl_dim_type type, unsigned pos,
__isl_take isl_id *id);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_set_dim_id(
__isl_take isl_multi_union_pw_aff *mupa,
enum isl_dim_type type, unsigned pos,
__isl_take isl_id *id);
__isl_give isl_id *isl_multi_aff_get_dim_id(
__isl_keep isl_multi_aff *ma,
enum isl_dim_type type, unsigned pos);
isl_bool isl_pw_aff_has_dim_id(__isl_keep isl_pw_aff *pa,
enum isl_dim_type type, unsigned pos);
__isl_give isl_id *isl_pw_aff_get_dim_id(
__isl_keep isl_pw_aff *pa,
enum isl_dim_type type, unsigned pos);
__isl_give isl_id *isl_pw_multi_aff_get_dim_id(
__isl_keep isl_pw_multi_aff *pma,
enum isl_dim_type type, unsigned pos);
__isl_give isl_id *isl_multi_pw_aff_get_dim_id(
__isl_keep isl_multi_pw_aff *mpa,
enum isl_dim_type type, unsigned pos);
__isl_give isl_id *isl_multi_union_pw_aff_get_dim_id(
__isl_keep isl_multi_union_pw_aff *mupa,
enum isl_dim_type type, unsigned pos);
__isl_give isl_aff *isl_aff_set_dim_name(
__isl_take isl_aff *aff, enum isl_dim_type type,
unsigned pos, const char *s);
__isl_give isl_multi_aff *isl_multi_aff_set_dim_name(
__isl_take isl_multi_aff *maff,
enum isl_dim_type type, unsigned pos, const char *s);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_set_dim_name(
__isl_take isl_multi_pw_aff *mpa,
enum isl_dim_type type, unsigned pos, const char *s);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_set_dim_name(
__isl_take isl_union_pw_aff *upa,
enum isl_dim_type type, unsigned pos,
const char *s);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_set_dim_name(
__isl_take isl_union_pw_multi_aff *upma,
enum isl_dim_type type, unsigned pos,
const char *s);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_set_dim_name(
__isl_take isl_multi_union_pw_aff *mupa,
enum isl_dim_type type, unsigned pos,
const char *s);
const char *isl_aff_get_dim_name(__isl_keep isl_aff *aff,
enum isl_dim_type type, unsigned pos);
const char *isl_pw_aff_get_dim_name(
__isl_keep isl_pw_aff *pa,
enum isl_dim_type type, unsigned pos);
const char *isl_pw_multi_aff_get_dim_name(
__isl_keep isl_pw_multi_aff *pma,
enum isl_dim_type type, unsigned pos);
#include <isl/polynomial.h>
__isl_give isl_qpolynomial *isl_qpolynomial_set_dim_name(
__isl_take isl_qpolynomial *qp,
enum isl_dim_type type, unsigned pos,
const char *s);
__isl_give isl_pw_qpolynomial *
isl_pw_qpolynomial_set_dim_name(
__isl_take isl_pw_qpolynomial *pwqp,
enum isl_dim_type type, unsigned pos,
const char *s);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_set_dim_name(
__isl_take isl_pw_qpolynomial_fold *pwf,
enum isl_dim_type type, unsigned pos,
const char *s);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_set_dim_name(
__isl_take isl_union_pw_qpolynomial *upwqp,
enum isl_dim_type type, unsigned pos,
const char *s);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_set_dim_name(
__isl_take isl_union_pw_qpolynomial_fold *upwf,
enum isl_dim_type type, unsigned pos,
const char *s);Note that isl_space_get_name returns a pointer to some internal data structure, so the result can only be used while the corresponding isl_space is alive. Also note that every function that operates on two sets or relations requires that both arguments have the same parameters. This also means that if one of the arguments has named parameters, then the other needs to have named parameters too and the names need to match. Pairs of isl_set, isl_map, isl_union_set and/or isl_union_map arguments may have different parameters (as long as they are named), in which case the result will have as parameters the union of the parameters of the arguments.
Given the identifier or name of a dimension (typically a parameter), its position can be obtained from the following functions.
#include <isl/space.h>
int isl_space_find_dim_by_id(__isl_keep isl_space *space,
enum isl_dim_type type, __isl_keep isl_id *id);
int isl_space_find_dim_by_name(__isl_keep isl_space *space,
enum isl_dim_type type, const char *name);
#include <isl/local_space.h>
int isl_local_space_find_dim_by_name(
__isl_keep isl_local_space *ls,
enum isl_dim_type type, const char *name);
#include <isl/val.h>
int isl_multi_val_find_dim_by_id(
__isl_keep isl_multi_val *mv,
enum isl_dim_type type, __isl_keep isl_id *id);
int isl_multi_val_find_dim_by_name(
__isl_keep isl_multi_val *mv,
enum isl_dim_type type, const char *name);
#include <isl/set.h>
int isl_set_find_dim_by_id(__isl_keep isl_set *set,
enum isl_dim_type type, __isl_keep isl_id *id);
int isl_set_find_dim_by_name(__isl_keep isl_set *set,
enum isl_dim_type type, const char *name);
#include <isl/map.h>
int isl_map_find_dim_by_id(__isl_keep isl_map *map,
enum isl_dim_type type, __isl_keep isl_id *id);
int isl_basic_map_find_dim_by_name(
__isl_keep isl_basic_map *bmap,
enum isl_dim_type type, const char *name);
int isl_map_find_dim_by_name(__isl_keep isl_map *map,
enum isl_dim_type type, const char *name);
int isl_union_map_find_dim_by_name(
__isl_keep isl_union_map *umap,
enum isl_dim_type type, const char *name);
#include <isl/aff.h>
int isl_multi_aff_find_dim_by_id(
__isl_keep isl_multi_aff *ma,
enum isl_dim_type type, __isl_keep isl_id *id);
int isl_multi_pw_aff_find_dim_by_id(
__isl_keep isl_multi_pw_aff *mpa,
enum isl_dim_type type, __isl_keep isl_id *id);
int isl_multi_union_pw_aff_find_dim_by_id(
__isl_keep isl_multi_union_pw_aff *mupa,
enum isl_dim_type type, __isl_keep isl_id *id);
int isl_aff_find_dim_by_name(__isl_keep isl_aff *aff,
enum isl_dim_type type, const char *name);
int isl_multi_aff_find_dim_by_name(
__isl_keep isl_multi_aff *ma,
enum isl_dim_type type, const char *name);
int isl_pw_aff_find_dim_by_name(__isl_keep isl_pw_aff *pa,
enum isl_dim_type type, const char *name);
int isl_multi_pw_aff_find_dim_by_name(
__isl_keep isl_multi_pw_aff *mpa,
enum isl_dim_type type, const char *name);
int isl_pw_multi_aff_find_dim_by_name(
__isl_keep isl_pw_multi_aff *pma,
enum isl_dim_type type, const char *name);
int isl_union_pw_aff_find_dim_by_name(
__isl_keep isl_union_pw_aff *upa,
enum isl_dim_type type, const char *name);
int isl_union_pw_multi_aff_find_dim_by_name(
__isl_keep isl_union_pw_multi_aff *upma,
enum isl_dim_type type, const char *name);
int isl_multi_union_pw_aff_find_dim_by_name(
__isl_keep isl_multi_union_pw_aff *mupa,
enum isl_dim_type type, const char *name);
#include <isl/polynomial.h>
int isl_pw_qpolynomial_find_dim_by_name(
__isl_keep isl_pw_qpolynomial *pwqp,
enum isl_dim_type type, const char *name);
int isl_pw_qpolynomial_fold_find_dim_by_name(
__isl_keep isl_pw_qpolynomial_fold *pwf,
enum isl_dim_type type, const char *name);
int isl_union_pw_qpolynomial_find_dim_by_name(
__isl_keep isl_union_pw_qpolynomial *upwqp,
enum isl_dim_type type, const char *name);
int isl_union_pw_qpolynomial_fold_find_dim_by_name(
__isl_keep isl_union_pw_qpolynomial_fold *upwf,
enum isl_dim_type type, const char *name);The identifiers or names of entire spaces may be set or read off using the following functions.
#include <isl/space.h>
__isl_give isl_space *isl_space_set_domain_tuple_id(
__isl_take isl_space *space,
__isl_take isl_id *id);
__isl_give isl_space *isl_space_set_range_tuple_id(
__isl_take isl_space *space,
__isl_take isl_id *id);
__isl_give isl_space *isl_space_set_tuple_id(
__isl_take isl_space *space,
enum isl_dim_type type, __isl_take isl_id *id);
__isl_give isl_space *isl_space_reset_tuple_id(
__isl_take isl_space *space, enum isl_dim_type type);
isl_bool isl_space_has_domain_tuple_id(
__isl_keep isl_space *space);
isl_bool isl_space_has_range_tuple_id(
__isl_keep isl_space *space);
isl_bool isl_space_has_tuple_id(
__isl_keep isl_space *space,
enum isl_dim_type type);
__isl_give isl_id *isl_space_get_domain_tuple_id(
__isl_keep isl_space *space);
__isl_give isl_id *isl_space_get_range_tuple_id(
__isl_keep isl_space *space);
__isl_give isl_id *isl_space_get_tuple_id(
__isl_keep isl_space *space, enum isl_dim_type type);
__isl_give isl_space *isl_space_set_tuple_name(
__isl_take isl_space *space,
enum isl_dim_type type, const char *s);
isl_bool isl_space_has_tuple_name(
__isl_keep isl_space *space,
enum isl_dim_type type);
__isl_keep const char *isl_space_get_tuple_name(
__isl_keep isl_space *space,
enum isl_dim_type type);
#include <isl/local_space.h>
__isl_give isl_local_space *isl_local_space_set_tuple_id(
__isl_take isl_local_space *ls,
enum isl_dim_type type, __isl_take isl_id *id);
#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_set_tuple_id(
__isl_take isl_basic_set *bset,
__isl_take isl_id *id);
__isl_give isl_set *isl_set_set_tuple_id(
__isl_take isl_set *set, __isl_take isl_id *id);
__isl_give isl_set *isl_set_reset_tuple_id(
__isl_take isl_set *set);
isl_bool isl_set_has_tuple_id(__isl_keep isl_set *set);
__isl_give isl_id *isl_set_get_tuple_id(
__isl_keep isl_set *set);
__isl_give isl_basic_set *isl_basic_set_set_tuple_name(
__isl_take isl_basic_set *set, const char *s);
__isl_give isl_set *isl_set_set_tuple_name(
__isl_take isl_set *set, const char *s);
const char *isl_basic_set_get_tuple_name(
__isl_keep isl_basic_set *bset);
isl_bool isl_set_has_tuple_name(__isl_keep isl_set *set);
const char *isl_set_get_tuple_name(
__isl_keep isl_set *set);
#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_set_tuple_id(
__isl_take isl_basic_map *bmap,
enum isl_dim_type type, __isl_take isl_id *id);
__isl_give isl_map *isl_map_set_domain_tuple_id(
__isl_take isl_map *map, __isl_take isl_id *id);
__isl_give isl_map *isl_map_set_range_tuple_id(
__isl_take isl_map *map, __isl_take isl_id *id);
__isl_give isl_map *isl_map_set_tuple_id(
__isl_take isl_map *map, enum isl_dim_type type,
__isl_take isl_id *id);
__isl_give isl_map *isl_map_reset_tuple_id(
__isl_take isl_map *map, enum isl_dim_type type);
isl_bool isl_map_has_domain_tuple_id(
__isl_keep isl_map *map);
isl_bool isl_map_has_range_tuple_id(
__isl_keep isl_map *map);
isl_bool isl_map_has_tuple_id(__isl_keep isl_map *map,
enum isl_dim_type type);
__isl_give isl_id *isl_map_get_domain_tuple_id(
__isl_keep isl_map *map);
__isl_give isl_id *isl_map_get_range_tuple_id(
__isl_keep isl_map *map);
__isl_give isl_id *isl_map_get_tuple_id(
__isl_keep isl_map *map, enum isl_dim_type type);
__isl_give isl_map *isl_map_set_tuple_name(
__isl_take isl_map *map,
enum isl_dim_type type, const char *s);
const char *isl_basic_map_get_tuple_name(
__isl_keep isl_basic_map *bmap,
enum isl_dim_type type);
__isl_give isl_basic_map *isl_basic_map_set_tuple_name(
__isl_take isl_basic_map *bmap,
enum isl_dim_type type, const char *s);
isl_bool isl_map_has_tuple_name(__isl_keep isl_map *map,
enum isl_dim_type type);
const char *isl_map_get_tuple_name(
__isl_keep isl_map *map,
enum isl_dim_type type);
#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_set_range_tuple_id(
__isl_take isl_multi_val *mv,
__isl_take isl_id *id);
__isl_give isl_multi_val *isl_multi_val_set_tuple_id(
__isl_take isl_multi_val *mv,
enum isl_dim_type type, __isl_take isl_id *id);
__isl_give isl_multi_val *
isl_multi_val_reset_range_tuple_id(
__isl_take isl_multi_val *mv);
__isl_give isl_multi_val *isl_multi_val_reset_tuple_id(
__isl_take isl_multi_val *mv,
enum isl_dim_type type);
isl_bool isl_multi_val_has_range_tuple_id(
__isl_keep isl_multi_val *mv);
__isl_give isl_id *isl_multi_val_get_range_tuple_id(
__isl_keep isl_multi_val *mv);
isl_bool isl_multi_val_has_tuple_id(
__isl_keep isl_multi_val *mv,
enum isl_dim_type type);
__isl_give isl_id *isl_multi_val_get_tuple_id(
__isl_keep isl_multi_val *mv,
enum isl_dim_type type);
__isl_give isl_multi_val *isl_multi_val_set_tuple_name(
__isl_take isl_multi_val *mv,
enum isl_dim_type type, const char *s);
const char *isl_multi_val_get_tuple_name(
__isl_keep isl_multi_val *mv,
enum isl_dim_type type);
#include <isl/aff.h>
__isl_give isl_aff *isl_aff_set_tuple_id(
__isl_take isl_aff *aff,
enum isl_dim_type type, __isl_take isl_id *id);
__isl_give isl_multi_aff *isl_multi_aff_set_range_tuple_id(
__isl_take isl_multi_aff *ma,
__isl_take isl_id *id);
__isl_give isl_multi_aff *isl_multi_aff_set_tuple_id(
__isl_take isl_multi_aff *maff,
enum isl_dim_type type, __isl_take isl_id *id);
__isl_give isl_pw_aff *isl_pw_aff_set_tuple_id(
__isl_take isl_pw_aff *pwaff,
enum isl_dim_type type, __isl_take isl_id *id);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_set_range_tuple_id(
__isl_take isl_pw_multi_aff *pma,
__isl_take isl_id *id);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_tuple_id(
__isl_take isl_pw_multi_aff *pma,
enum isl_dim_type type, __isl_take isl_id *id);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_set_range_tuple_id(
__isl_take isl_multi_pw_aff *mpa,
__isl_take isl_id *id);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_set_range_tuple_id(
__isl_take isl_multi_union_pw_aff *mupa,
__isl_take isl_id *id);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_set_tuple_id(
__isl_take isl_multi_union_pw_aff *mupa,
enum isl_dim_type type, __isl_take isl_id *id);
__isl_give isl_multi_aff *
isl_multi_aff_reset_range_tuple_id(
__isl_take isl_multi_aff *ma);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_reset_range_tuple_id(
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_reset_range_tuple_id(
__isl_take isl_multi_union_pw_aff *mupa);
__isl_give isl_multi_aff *isl_multi_aff_reset_tuple_id(
__isl_take isl_multi_aff *ma,
enum isl_dim_type type);
__isl_give isl_pw_aff *isl_pw_aff_reset_tuple_id(
__isl_take isl_pw_aff *pa,
enum isl_dim_type type);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_reset_tuple_id(
__isl_take isl_multi_pw_aff *mpa,
enum isl_dim_type type);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_reset_tuple_id(
__isl_take isl_pw_multi_aff *pma,
enum isl_dim_type type);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_reset_tuple_id(
__isl_take isl_multi_union_pw_aff *mupa,
enum isl_dim_type type);
isl_bool isl_multi_aff_has_range_tuple_id(
__isl_keep isl_multi_aff *ma);
__isl_give isl_id *isl_multi_aff_get_range_tuple_id(
__isl_keep isl_multi_aff *ma);
isl_bool isl_multi_aff_has_tuple_id(
__isl_keep isl_multi_aff *ma,
enum isl_dim_type type);
__isl_give isl_id *isl_multi_aff_get_tuple_id(
__isl_keep isl_multi_aff *ma,
enum isl_dim_type type);
isl_bool isl_pw_aff_has_tuple_id(__isl_keep isl_pw_aff *pa,
enum isl_dim_type type);
__isl_give isl_id *isl_pw_aff_get_tuple_id(
__isl_keep isl_pw_aff *pa,
enum isl_dim_type type);
isl_bool isl_pw_multi_aff_has_range_tuple_id(
__isl_keep isl_pw_multi_aff *pma);
isl_bool isl_pw_multi_aff_has_tuple_id(
__isl_keep isl_pw_multi_aff *pma,
enum isl_dim_type type);
__isl_give isl_id *isl_pw_multi_aff_get_range_tuple_id(
__isl_keep isl_pw_multi_aff *pma);
__isl_give isl_id *isl_pw_multi_aff_get_tuple_id(
__isl_keep isl_pw_multi_aff *pma,
enum isl_dim_type type);
isl_bool isl_multi_pw_aff_has_range_tuple_id(
__isl_keep isl_multi_pw_aff *mpa);
__isl_give isl_id *isl_multi_pw_aff_get_range_tuple_id(
__isl_keep isl_multi_pw_aff *mpa);
isl_bool isl_multi_pw_aff_has_tuple_id(
__isl_keep isl_multi_pw_aff *mpa,
enum isl_dim_type type);
__isl_give isl_id *isl_multi_pw_aff_get_tuple_id(
__isl_keep isl_multi_pw_aff *mpa,
enum isl_dim_type type);
isl_bool isl_multi_union_pw_aff_has_range_tuple_id(
__isl_keep isl_multi_union_pw_aff *mupa);
__isl_give isl_id *
isl_multi_union_pw_aff_get_range_tuple_id(
__isl_keep isl_multi_union_pw_aff *mupa);
isl_bool isl_multi_union_pw_aff_has_tuple_id(
__isl_keep isl_multi_union_pw_aff *mupa,
enum isl_dim_type type);
__isl_give isl_id *isl_multi_union_pw_aff_get_tuple_id(
__isl_keep isl_multi_union_pw_aff *mupa,
enum isl_dim_type type);
__isl_give isl_multi_aff *isl_multi_aff_set_tuple_name(
__isl_take isl_multi_aff *maff,
enum isl_dim_type type, const char *s);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_set_tuple_name(
__isl_take isl_multi_pw_aff *mpa,
enum isl_dim_type type, const char *s);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_set_tuple_name(
__isl_take isl_multi_union_pw_aff *mupa,
enum isl_dim_type type, const char *s);
const char *isl_multi_aff_get_tuple_name(
__isl_keep isl_multi_aff *multi,
enum isl_dim_type type);
isl_bool isl_pw_multi_aff_has_tuple_name(
__isl_keep isl_pw_multi_aff *pma,
enum isl_dim_type type);
const char *isl_pw_multi_aff_get_tuple_name(
__isl_keep isl_pw_multi_aff *pma,
enum isl_dim_type type);
const char *isl_multi_union_pw_aff_get_tuple_name(
__isl_keep isl_multi_union_pw_aff *mupa,
enum isl_dim_type type);The type argument needs to be one of isl_dim_in, isl_dim_out or isl_dim_set. As with isl_space_get_name, the isl_space_get_tuple_name function returns a pointer to some internal data structure. Binary operations require the corresponding spaces of their arguments to have the same name.
To keep the names of all parameters and tuples, but reset the user pointers of all the corresponding identifiers, use the following function.
#include <isl/space.h>
__isl_give isl_space *isl_space_reset_user(
__isl_take isl_space *space);
#include <isl/set.h>
__isl_give isl_set *isl_set_reset_user(
__isl_take isl_set *set);
#include <isl/map.h>
__isl_give isl_map *isl_map_reset_user(
__isl_take isl_map *map);
#include <isl/union_set.h>
__isl_give isl_union_set *isl_union_set_reset_user(
__isl_take isl_union_set *uset);
#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_reset_user(
__isl_take isl_union_map *umap);
#include <isl/id.h>
__isl_give isl_multi_id *isl_multi_id_reset_user(
__isl_take isl_multi_id *mi);
#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_reset_user(
__isl_take isl_multi_val *mv);
#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_reset_user(
__isl_take isl_multi_aff *ma);
__isl_give isl_pw_aff *isl_pw_aff_reset_user(
__isl_take isl_pw_aff *pa);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_reset_user(
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_reset_user(
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_union_pw_aff *isl_union_pw_aff_reset_user(
__isl_take isl_union_pw_aff *upa);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_reset_user(
__isl_take isl_multi_union_pw_aff *mupa);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_reset_user(
__isl_take isl_union_pw_multi_aff *upma);
#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial *
isl_pw_qpolynomial_reset_user(
__isl_take isl_pw_qpolynomial *pwqp);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_reset_user(
__isl_take isl_union_pw_qpolynomial *upwqp);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_reset_user(
__isl_take isl_pw_qpolynomial_fold *pwf);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_reset_user(
__isl_take isl_union_pw_qpolynomial_fold *upwf);Spaces can be nested. In particular, the domain of a set or the domain or range of a relation can be a nested relation. This process is also called wrapping. The functions for detecting, constructing and deconstructing such nested spaces can be found in the wrapping properties of "Unary Properties", the wrapping operations of "Unary Operations" and the Cartesian product operations of "Basic Operations".
Spaces can be created from other spaces using the functions described in "Unary Operations" and "Binary Operations".
A local space is essentially a space with zero or more existentially quantified variables. The local space of various objects can be obtained using the following functions.
#include <isl/constraint.h>
__isl_give isl_local_space *isl_constraint_get_local_space(
__isl_keep isl_constraint *constraint);
#include <isl/set.h>
__isl_give isl_local_space *isl_basic_set_get_local_space(
__isl_keep isl_basic_set *bset);
#include <isl/map.h>
__isl_give isl_local_space *isl_basic_map_get_local_space(
__isl_keep isl_basic_map *bmap);
#include <isl/aff.h>
__isl_give isl_local_space *isl_aff_get_domain_local_space(
__isl_keep isl_aff *aff);
__isl_give isl_local_space *isl_aff_get_local_space(
__isl_keep isl_aff *aff);A new local space can be created from a space using
#include <isl/local_space.h>
__isl_give isl_local_space *isl_local_space_from_space(
__isl_take isl_space *space);They can be inspected, modified, copied and freed using the following functions.
#include <isl/local_space.h>
isl_bool isl_local_space_is_params(
__isl_keep isl_local_space *ls);
isl_bool isl_local_space_is_set(
__isl_keep isl_local_space *ls);
__isl_give isl_space *isl_local_space_get_space(
__isl_keep isl_local_space *ls);
__isl_give isl_aff *isl_local_space_get_div(
__isl_keep isl_local_space *ls, int pos);
__isl_give isl_local_space *isl_local_space_copy(
__isl_keep isl_local_space *ls);
__isl_null isl_local_space *isl_local_space_free(
__isl_take isl_local_space *ls);Note that isl_local_space_get_div can only be used on local spaces of sets.
Two local spaces can be compared using
isl_bool isl_local_space_is_equal(
__isl_keep isl_local_space *ls1,
__isl_keep isl_local_space *ls2);Local spaces can be created from other local spaces using the functions described in "Unary Operations" and "Binary Operations".
isl has functions for creating some standard sets and relations.
Empty sets and relations
__isl_give isl_basic_set *isl_basic_set_empty(
__isl_take isl_space *space);
__isl_give isl_basic_map *isl_basic_map_empty(
__isl_take isl_space *space);
__isl_give isl_set *isl_set_empty(
__isl_take isl_space *space);
__isl_give isl_map *isl_map_empty(
__isl_take isl_space *space);
__isl_give isl_union_set *isl_union_set_empty_ctx(
isl_ctx *ctx);
__isl_give isl_union_set *isl_union_set_empty_space(
__isl_take isl_space *space);
__isl_give isl_union_set *isl_union_set_empty(
__isl_take isl_space *space);
__isl_give isl_union_map *isl_union_map_empty_ctx(
isl_ctx *ctx);
__isl_give isl_union_map *isl_union_map_empty_space(
__isl_take isl_space *space);
__isl_give isl_union_map *isl_union_map_empty(
__isl_take isl_space *space);For isl_union_sets and isl_union_maps, the space is only used to specify the parameters. isl_union_set_empty is an alternative name for isl_union_set_empty_space. Similarly for the other pair of functions.
Universe sets and relations
#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_universe(
__isl_take isl_space *space);
__isl_give isl_set *isl_set_universe(
__isl_take isl_space *space);
__isl_give isl_set *isl_space_universe_set(
__isl_take isl_space *space);
#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_universe(
__isl_take isl_space *space);
__isl_give isl_map *isl_map_universe(
__isl_take isl_space *space);
__isl_give isl_map *isl_space_universe_map(
__isl_take isl_space *space);
#include <isl/union_set.h>
__isl_give isl_union_set *isl_union_set_universe(
__isl_take isl_union_set *uset);
#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_universe(
__isl_take isl_union_map *umap);isl_set_universe and isl_space_universe_set perform the same operation. Similarly for the pair isl_map_universe and isl_space_universe_map.
The sets and relations constructed by the functions above contain all integer values, while those constructed by the functions below only contain non-negative values.
__isl_give isl_basic_set *isl_basic_set_nat_universe(
__isl_take isl_space *space);
__isl_give isl_basic_map *isl_basic_map_nat_universe(
__isl_take isl_space *space);
__isl_give isl_set *isl_set_nat_universe(
__isl_take isl_space *space);
__isl_give isl_map *isl_map_nat_universe(
__isl_take isl_space *space);Identity relations
__isl_give isl_basic_map *isl_basic_map_identity(
__isl_take isl_space *space);
__isl_give isl_map *isl_map_identity(
__isl_take isl_space *space);The number of input and output dimensions in space needs to be the same.
Lexicographic order
__isl_give isl_map *isl_map_lex_lt(
__isl_take isl_space *set_space);
__isl_give isl_map *isl_map_lex_le(
__isl_take isl_space *set_space);
__isl_give isl_map *isl_map_lex_gt(
__isl_take isl_space *set_space);
__isl_give isl_map *isl_map_lex_ge(
__isl_take isl_space *set_space);
__isl_give isl_map *isl_map_lex_lt_first(
__isl_take isl_space *space, unsigned n);
__isl_give isl_map *isl_map_lex_le_first(
__isl_take isl_space *space, unsigned n);
__isl_give isl_map *isl_map_lex_gt_first(
__isl_take isl_space *space, unsigned n);
__isl_give isl_map *isl_map_lex_ge_first(
__isl_take isl_space *space, unsigned n);The first four functions take a space for a set and return relations that express that the elements in the domain are lexicographically less (isl_map_lex_lt), less or equal (isl_map_lex_le), greater (isl_map_lex_gt) or greater or equal (isl_map_lex_ge) than the elements in the range. The last four functions take a space for a map and return relations that express that the first n dimensions in the domain are lexicographically less (isl_map_lex_lt_first), less or equal (isl_map_lex_le_first), greater (isl_map_lex_gt_first) or greater or equal (isl_map_lex_ge_first) than the first n dimensions in the range.
A basic set or relation can be converted to a set or relation using the following functions.
__isl_give isl_set *isl_basic_set_to_set(
__isl_take isl_basic_set *bset);
__isl_give isl_set *isl_set_from_basic_set(
__isl_take isl_basic_set *bset);
__isl_give isl_map *isl_map_from_basic_map(
__isl_take isl_basic_map *bmap);isl_basic_set_to_set and isl_set_from_basic_set perform the same operation.
Sets and relations can be converted to union sets and relations using the following functions.
__isl_give isl_union_set *isl_union_set_from_basic_set(
__isl_take isl_basic_set *bset);
__isl_give isl_union_map *isl_union_map_from_basic_map(
__isl_take isl_basic_map *bmap);
__isl_give isl_union_set *isl_set_to_union_set(
__isl_take isl_set *set);
__isl_give isl_union_set *isl_union_set_from_set(
__isl_take isl_set *set);
__isl_give isl_union_map *isl_map_to_union_map(
__isl_take isl_map *map);
__isl_give isl_union_map *isl_union_map_from_map(
__isl_take isl_map *map);isl_map_to_union_map and isl_union_map_from_map perform the same operation. Similarly for isl_set_to_union_set and isl_union_set_from_set.
The inverse conversions below can only be used if the input union set or relation is known to contain elements in exactly one space.
#include <isl/union_set.h>
isl_bool isl_union_set_isa_set(
__isl_keep isl_union_set *uset);
__isl_give isl_set *isl_union_set_as_set(
__isl_take isl_union_set *uset);
__isl_give isl_set *isl_set_from_union_set(
__isl_take isl_union_set *uset);
#include <isl/union_map.h>
isl_bool isl_union_map_isa_map(
__isl_keep isl_union_map *umap);
__isl_give isl_map *isl_union_map_as_map(
__isl_take isl_union_map *umap);
__isl_give isl_map *isl_map_from_union_map(
__isl_take isl_union_map *umap);isl_union_map_as_map and isl_map_from_union_map perform the same operation. Similarly for isl_union_set_as_set and isl_set_from_union_set.
Sets and relations can be copied and freed again using the following functions.
__isl_give isl_basic_set *isl_basic_set_copy(
__isl_keep isl_basic_set *bset);
__isl_give isl_set *isl_set_copy(__isl_keep isl_set *set);
__isl_give isl_union_set *isl_union_set_copy(
__isl_keep isl_union_set *uset);
__isl_give isl_basic_map *isl_basic_map_copy(
__isl_keep isl_basic_map *bmap);
__isl_give isl_map *isl_map_copy(__isl_keep isl_map *map);
__isl_give isl_union_map *isl_union_map_copy(
__isl_keep isl_union_map *umap);
__isl_null isl_basic_set *isl_basic_set_free(
__isl_take isl_basic_set *bset);
__isl_null isl_set *isl_set_free(__isl_take isl_set *set);
__isl_null isl_union_set *isl_union_set_free(
__isl_take isl_union_set *uset);
__isl_null isl_basic_map *isl_basic_map_free(
__isl_take isl_basic_map *bmap);
__isl_null isl_map *isl_map_free(__isl_take isl_map *map);
__isl_null isl_union_map *isl_union_map_free(
__isl_take isl_union_map *umap);Other sets and relations can be constructed by starting from a universe set or relation, adding equality and/or inequality constraints and then projecting out the existentially quantified variables, if any. Constraints can be constructed, manipulated and added to (or removed from) (basic) sets and relations using the following functions.
#include <isl/constraint.h>
__isl_give isl_constraint *isl_constraint_alloc_equality(
__isl_take isl_local_space *ls);
__isl_give isl_constraint *isl_constraint_alloc_inequality(
__isl_take isl_local_space *ls);
__isl_give isl_constraint *isl_constraint_set_constant_si(
__isl_take isl_constraint *constraint, int v);
__isl_give isl_constraint *isl_constraint_set_constant_val(
__isl_take isl_constraint *constraint,
__isl_take isl_val *v);
__isl_give isl_constraint *isl_constraint_set_coefficient_si(
__isl_take isl_constraint *constraint,
enum isl_dim_type type, int pos, int v);
__isl_give isl_constraint *
isl_constraint_set_coefficient_val(
__isl_take isl_constraint *constraint,
enum isl_dim_type type, int pos,
__isl_take isl_val *v);
__isl_give isl_basic_map *isl_basic_map_add_constraint(
__isl_take isl_basic_map *bmap,
__isl_take isl_constraint *constraint);
__isl_give isl_basic_set *isl_basic_set_add_constraint(
__isl_take isl_basic_set *bset,
__isl_take isl_constraint *constraint);
__isl_give isl_map *isl_map_add_constraint(
__isl_take isl_map *map,
__isl_take isl_constraint *constraint);
__isl_give isl_set *isl_set_add_constraint(
__isl_take isl_set *set,
__isl_take isl_constraint *constraint);For example, to create a set containing the even integers between 10 and 42, you could use the following code.
isl_space *space;
isl_local_space *ls;
isl_constraint *c;
isl_basic_set *bset;
space = isl_space_set_alloc(ctx, 0, 2);
bset = isl_basic_set_universe(isl_space_copy(space));
ls = isl_local_space_from_space(space);
c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 2);
bset = isl_basic_set_add_constraint(bset, c);
c = isl_constraint_alloc_inequality(isl_local_space_copy(ls));
c = isl_constraint_set_constant_si(c, -10);
c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
bset = isl_basic_set_add_constraint(bset, c);
c = isl_constraint_alloc_inequality(ls);
c = isl_constraint_set_constant_si(c, 42);
c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
bset = isl_basic_set_add_constraint(bset, c);
bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 1);However, this is considered to be a fairly low-level approach. It is more appropriate to construct a (basic) set by means of affine expressions (defined below in "Functions"). For example, the same set could be constructed as follows.
isl_val *v, *two;
isl_space *space;
isl_multi_aff *ma;
isl_aff *var, *cst;
isl_basic_set *bset;
space = isl_space_unit(ctx);
space = isl_space_add_unnamed_tuple_ui(space, 1);
ma = isl_multi_aff_identity_on_domain_space(
isl_space_copy(space));
var = isl_multi_aff_get_at(ma, 0);
v = isl_val_int_from_si(ctx, 10);
cst = isl_aff_val_on_domain_space(isl_space_copy(space), v);
bset = isl_aff_ge_basic_set(isl_aff_copy(var), cst);
v = isl_val_int_from_si(ctx, 42);
cst = isl_aff_val_on_domain_space(space, v);
bset = isl_basic_set_intersect(bset,
isl_aff_le_basic_set(var, cst));
two = isl_val_int_from_si(ctx, 2);
ma = isl_multi_aff_scale_val(ma, isl_val_copy(two));
bset = isl_basic_set_preimage_multi_aff(bset,
isl_multi_aff_copy(ma));
ma = isl_multi_aff_scale_down_val(ma, isl_val_copy(two));
ma = isl_multi_aff_scale_down_val(ma, two);
bset = isl_basic_set_preimage_multi_aff(bset, ma);Alternatively, the set can be parsed from a string representation.
isl_basic_set *bset;
bset = isl_basic_set_read_from_str(ctx,
"{[i] : exists (a : i = 2a and i >= 10 and i <= 42)}");A basic set or relation can also be constructed from two matrices describing the equalities and the inequalities.
__isl_give isl_basic_set *isl_basic_set_from_constraint_matrices(
__isl_take isl_space *space,
__isl_take isl_mat *eq, __isl_take isl_mat *ineq,
enum isl_dim_type c1,
enum isl_dim_type c2, enum isl_dim_type c3,
enum isl_dim_type c4);
__isl_give isl_basic_map *isl_basic_map_from_constraint_matrices(
__isl_take isl_space *space,
__isl_take isl_mat *eq, __isl_take isl_mat *ineq,
enum isl_dim_type c1,
enum isl_dim_type c2, enum isl_dim_type c3,
enum isl_dim_type c4, enum isl_dim_type c5);The isl_dim_type arguments indicate the order in which different kinds of variables appear in the input matrices and should be a permutation of isl_dim_cst (the constant term), isl_dim_param, isl_dim_set and isl_dim_div for sets and of isl_dim_cst, isl_dim_param, isl_dim_in, isl_dim_out and isl_dim_div for relations.
A (basic or union) set or relation can also be constructed from a (union) (piecewise) (multiple) affine expression or a list of affine expressions (See "Functions"), provided these affine expressions do not involve any NaN.
#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_from_multi_aff(
__isl_take isl_multi_aff *ma);
__isl_give isl_set *isl_multi_aff_as_set(
__isl_take isl_multi_aff *ma);
__isl_give isl_set *isl_set_from_multi_aff(
__isl_take isl_multi_aff *ma);
#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_from_aff(
__isl_take isl_aff *aff);
__isl_give isl_map *isl_map_from_aff(
__isl_take isl_aff *aff);
__isl_give isl_basic_map *isl_basic_map_from_aff_list(
__isl_take isl_space *domain_space,
__isl_take isl_aff_list *list);
__isl_give isl_basic_map *isl_basic_map_from_multi_aff(
__isl_take isl_multi_aff *maff)
__isl_give isl_map *isl_multi_aff_as_map(
__isl_take isl_multi_aff *ma);
__isl_give isl_map *isl_map_from_multi_aff(
__isl_take isl_multi_aff *maff)
#include <isl/aff.h>
__isl_give isl_set *isl_set_from_pw_aff(
__isl_take isl_pw_aff *pwaff);
__isl_give isl_map *isl_pw_aff_as_map(
__isl_take isl_pw_aff *pa);
__isl_give isl_map *isl_map_from_pw_aff(
__isl_take isl_pw_aff *pwaff);
__isl_give isl_set *isl_pw_multi_aff_as_set(
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_set *isl_set_from_pw_multi_aff(
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_map *isl_pw_multi_aff_as_map(
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_map *isl_map_from_pw_multi_aff(
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_set *isl_multi_pw_aff_as_set(
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_set *isl_set_from_multi_pw_aff(
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_map *isl_multi_pw_aff_as_map(
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_map *isl_map_from_multi_pw_aff(
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_union_map *isl_union_map_from_union_pw_aff(
__isl_take isl_union_pw_aff *upa);
__isl_give isl_union_map *
isl_union_pw_multi_aff_as_union_map(
__isl_take isl_union_pw_multi_aff *upma);
__isl_give isl_union_map *
isl_union_map_from_union_pw_multi_aff(
__isl_take isl_union_pw_multi_aff *upma);
__isl_give isl_union_map *
isl_union_map_from_multi_union_pw_aff(
__isl_take isl_multi_union_pw_aff *mupa);The domain_space argument describes the domain of the resulting basic relation. It is required because the list may consist of zero affine expressions. The mupa passed to isl_union_map_from_multi_union_pw_aff is not allowed to be zero-dimensional. The domain of the result is the shared domain of the union piecewise affine elements. isl_multi_aff_as_set and isl_set_from_multi_aff perform the same operation. Similarly for the pair isl_multi_aff_as_map and isl_map_from_multi_aff, for the pair isl_pw_aff_as_map and isl_map_from_pw_aff, for the pair isl_pw_multi_aff_as_set and isl_set_from_pw_multi_aff, for the pair isl_pw_multi_aff_as_map and isl_map_from_pw_multi_aff, the pair isl_multi_pw_aff_as_set and isl_set_from_multi_pw_aff, the pair isl_multi_pw_aff_as_map and isl_map_from_multi_pw_aff, and isl_union_pw_multi_aff_as_union_map and isl_union_map_from_union_pw_multi_aff.
Usually, the user should not have to care about the actual constraints of the sets and maps, but should instead apply the abstract operations explained in the following sections. Occasionally, however, it may be required to inspect the individual coefficients of the constraints. This section explains how to do so. In these cases, it may also be useful to have isl compute an explicit representation of the existentially quantified variables.
__isl_give isl_set *isl_set_compute_divs(
__isl_take isl_set *set);
__isl_give isl_map *isl_map_compute_divs(
__isl_take isl_map *map);
__isl_give isl_union_set *isl_union_set_compute_divs(
__isl_take isl_union_set *uset);
__isl_give isl_union_map *isl_union_map_compute_divs(
__isl_take isl_union_map *umap);This explicit representation defines the existentially quantified variables as integer divisions of the other variables, possibly including earlier existentially quantified variables. An explicitly represented existentially quantified variable therefore has a unique value when the values of the other variables are known.
Alternatively, the existentially quantified variables can be removed using the following functions, which compute an overapproximation.
#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_remove_divs(
__isl_take isl_basic_set *bset);
__isl_give isl_set *isl_set_remove_divs(
__isl_take isl_set *set);
#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_remove_divs(
__isl_take isl_basic_map *bmap);
__isl_give isl_map *isl_map_remove_divs(
__isl_take isl_map *map);
#include <isl/union_set.h>
__isl_give isl_union_set *isl_union_set_remove_divs(
__isl_take isl_union_set *bset);
#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_remove_divs(
__isl_take isl_union_map *bmap);It is also possible to only remove those divs that are defined in terms of a given range of dimensions or only those for which no explicit representation is known.
__isl_give isl_basic_set *
isl_basic_set_remove_divs_involving_dims(
__isl_take isl_basic_set *bset,
enum isl_dim_type type,
unsigned first, unsigned n);
__isl_give isl_basic_map *
isl_basic_map_remove_divs_involving_dims(
__isl_take isl_basic_map *bmap,
enum isl_dim_type type,
unsigned first, unsigned n);
__isl_give isl_set *isl_set_remove_divs_involving_dims(
__isl_take isl_set *set, enum isl_dim_type type,
unsigned first, unsigned n);
__isl_give isl_map *isl_map_remove_divs_involving_dims(
__isl_take isl_map *map, enum isl_dim_type type,
unsigned first, unsigned n);
__isl_give isl_basic_set *
isl_basic_set_remove_unknown_divs(
__isl_take isl_basic_set *bset);
__isl_give isl_set *isl_set_remove_unknown_divs(
__isl_take isl_set *set);
__isl_give isl_map *isl_map_remove_unknown_divs(
__isl_take isl_map *map);To iterate over all the sets or maps in a union set or map, use
#include <isl/union_set.h>
isl_stat isl_union_set_foreach_set(
__isl_keep isl_union_set *uset,
isl_stat (*fn)(__isl_take isl_set *set, void *user),
void *user);
isl_bool isl_union_set_every_set(
__isl_keep isl_union_set *uset,
isl_bool (*test)(__isl_keep isl_set *set,
void *user),
void *user);
#include <isl/union_map.h>
isl_stat isl_union_map_foreach_map(
__isl_keep isl_union_map *umap,
isl_stat (*fn)(__isl_take isl_map *map, void *user),
void *user);
isl_bool isl_union_map_every_map(
__isl_keep isl_union_map *umap,
isl_bool (*test)(__isl_keep isl_map *map,
void *user),
void *user);These functions call the callback function once for each (pair of) space(s) for which there are elements in the input. The argument to the callback contains all elements in the input with that (pair of) space(s). The isl_union_set_every_set and isl_union_map_every_map variants check whether each call to the callback returns true and stops checking as soon as one of these calls returns false.
The number of sets or maps in a union set or map can be obtained from
isl_size isl_union_set_n_set(__isl_keep isl_union_set *uset);
isl_size isl_union_map_n_map(__isl_keep isl_union_map *umap);To extract the set or map in a given space from a union, use
__isl_give isl_set *isl_union_set_extract_set(
__isl_keep isl_union_set *uset,
__isl_take isl_space *space);
__isl_give isl_map *isl_union_map_extract_map(
__isl_keep isl_union_map *umap,
__isl_take isl_space *space);To iterate over all the basic sets or maps in a set or map, use
isl_stat isl_set_foreach_basic_set(__isl_keep isl_set *set,
isl_stat (*fn)(__isl_take isl_basic_set *bset,
void *user),
void *user);
isl_stat isl_map_foreach_basic_map(__isl_keep isl_map *map,
isl_stat (*fn)(__isl_take isl_basic_map *bmap,
void *user),
void *user);The callback function fn should return isl_stat_ok if successful and isl_stat_error if an error occurs. In the latter case, or if any other error occurs, the above functions will return isl_stat_error.
It should be noted that isl does not guarantee that the basic sets or maps passed to fn are disjoint. If this is required, then the user should call one of the following functions first.
__isl_give isl_set *isl_set_make_disjoint(
__isl_take isl_set *set);
__isl_give isl_map *isl_map_make_disjoint(
__isl_take isl_map *map);The number of basic sets in a set can be obtained or the number of basic maps in a map can be obtained from
#include <isl/set.h>
isl_size isl_set_n_basic_set(__isl_keep isl_set *set);
#include <isl/map.h>
isl_size isl_map_n_basic_map(__isl_keep isl_map *map);It is also possible to obtain a list of (basic) sets from a set or union set, a list of basic maps from a map and a list of maps from a union map.
#include <isl/set.h>
__isl_give isl_basic_set_list *isl_set_get_basic_set_list(
__isl_keep isl_set *set);
#include <isl/union_set.h>
__isl_give isl_basic_set_list *
isl_union_set_get_basic_set_list(
__isl_keep isl_union_set *uset);
__isl_give isl_set_list *isl_union_set_get_set_list(
__isl_keep isl_union_set *uset);
#include <isl/map.h>
__isl_give isl_basic_map_list *isl_map_get_basic_map_list(
__isl_keep isl_map *map);
#include <isl/union_map.h>
__isl_give isl_map_list *isl_union_map_get_map_list(
__isl_keep isl_union_map *umap);The returned list can be manipulated using the functions in "Lists".
To iterate over the constraints of a basic set or map, use
#include <isl/constraint.h>
isl_size isl_basic_set_n_constraint(
__isl_keep isl_basic_set *bset);
isl_stat isl_basic_set_foreach_constraint(
__isl_keep isl_basic_set *bset,
isl_stat (*fn)(__isl_take isl_constraint *c,
void *user),
void *user);
isl_size isl_basic_map_n_constraint(
__isl_keep isl_basic_map *bmap);
isl_stat isl_basic_map_foreach_constraint(
__isl_keep isl_basic_map *bmap,
isl_stat (*fn)(__isl_take isl_constraint *c,
void *user),
void *user);
__isl_null isl_constraint *isl_constraint_free(
__isl_take isl_constraint *c);Again, the callback function fn should return isl_stat_ok if successful and isl_stat_error if an error occurs. In the latter case, or if any other error occurs, the above functions will return isl_stat_error. The constraint c represents either an equality or an inequality. Use the following function to find out whether a constraint represents an equality. If not, it represents an inequality.
isl_bool isl_constraint_is_equality(
__isl_keep isl_constraint *constraint);It is also possible to obtain a list of constraints from a basic map or set
#include <isl/constraint.h>
__isl_give isl_constraint_list *
isl_basic_map_get_constraint_list(
__isl_keep isl_basic_map *bmap);
__isl_give isl_constraint_list *
isl_basic_set_get_constraint_list(
__isl_keep isl_basic_set *bset);These functions require that all existentially quantified variables have an explicit representation. The returned list can be manipulated using the functions in "Lists".
The coefficients of the constraints can be inspected using the following functions.
isl_bool isl_constraint_is_lower_bound(
__isl_keep isl_constraint *constraint,
enum isl_dim_type type, unsigned pos);
isl_bool isl_constraint_is_upper_bound(
__isl_keep isl_constraint *constraint,
enum isl_dim_type type, unsigned pos);
__isl_give isl_val *isl_constraint_get_constant_val(
__isl_keep isl_constraint *constraint);
__isl_give isl_val *isl_constraint_get_coefficient_val(
__isl_keep isl_constraint *constraint,
enum isl_dim_type type, int pos);The explicit representations of the existentially quantified variables can be inspected using the following function. Note that the user is only allowed to use this function if the inspected set or map is the result of a call to isl_set_compute_divs or isl_map_compute_divs. The existentially quantified variable is equal to the floor of the returned affine expression. The affine expression itself can be inspected using the functions in "Functions".
__isl_give isl_aff *isl_constraint_get_div(
__isl_keep isl_constraint *constraint, int pos);To obtain the constraints of a basic set or map in matrix form, use the following functions.
__isl_give isl_mat *isl_basic_set_equalities_matrix(
__isl_keep isl_basic_set *bset,
enum isl_dim_type c1, enum isl_dim_type c2,
enum isl_dim_type c3, enum isl_dim_type c4);
__isl_give isl_mat *isl_basic_set_inequalities_matrix(
__isl_keep isl_basic_set *bset,
enum isl_dim_type c1, enum isl_dim_type c2,
enum isl_dim_type c3, enum isl_dim_type c4);
__isl_give isl_mat *isl_basic_map_equalities_matrix(
__isl_keep isl_basic_map *bmap,
enum isl_dim_type c1,
enum isl_dim_type c2, enum isl_dim_type c3,
enum isl_dim_type c4, enum isl_dim_type c5);
__isl_give isl_mat *isl_basic_map_inequalities_matrix(
__isl_keep isl_basic_map *bmap,
enum isl_dim_type c1,
enum isl_dim_type c2, enum isl_dim_type c3,
enum isl_dim_type c4, enum isl_dim_type c5);The isl_dim_type arguments dictate the order in which different kinds of variables appear in the resulting matrix. For set inputs, they should be a permutation of isl_dim_cst (the constant term), isl_dim_param, isl_dim_set and isl_dim_div. For map inputs, they should be a permutation of isl_dim_cst, isl_dim_param, isl_dim_in, isl_dim_out and isl_dim_div.
Points are elements of a set. They can be used to construct simple sets (boxes) or they can be used to represent the individual elements of a set. The zero point (the origin) can be created using
__isl_give isl_point *isl_point_zero(__isl_take isl_space *space);The coordinates of a point can be inspected, set and changed using
#include <isl/point.h>
__isl_give isl_multi_val *isl_point_get_multi_val(
__isl_keep isl_point *pnt);
__isl_give isl_val *isl_point_get_coordinate_val(
__isl_keep isl_point *pnt,
enum isl_dim_type type, int pos);
__isl_give isl_point *isl_point_set_coordinate_val(
__isl_take isl_point *pnt,
enum isl_dim_type type, int pos,
__isl_take isl_val *v);
__isl_give isl_point *isl_point_add_ui(
__isl_take isl_point *pnt,
enum isl_dim_type type, int pos, unsigned val);
__isl_give isl_point *isl_point_sub_ui(
__isl_take isl_point *pnt,
enum isl_dim_type type, int pos, unsigned val);Points can be copied or freed using
__isl_give isl_point *isl_point_copy(
__isl_keep isl_point *pnt);
__isl_null isl_point *isl_point_free(
__isl_take isl_point *pnt);A singleton set can be created from a point using the following functions.
__isl_give isl_basic_set *isl_basic_set_from_point(
__isl_take isl_point *pnt);
__isl_give isl_set *isl_point_to_set(
__isl_take isl_point *pnt);
__isl_give isl_set *isl_set_from_point(
__isl_take isl_point *pnt);
__isl_give isl_union_set *isl_union_set_from_point(
__isl_take isl_point *pnt);isl_point_to_set and isl_set_from_point perform the same operation.
A box can be created from two opposite extremal points using
__isl_give isl_basic_set *isl_basic_set_box_from_points(
__isl_take isl_point *pnt1,
__isl_take isl_point *pnt2);
__isl_give isl_set *isl_set_box_from_points(
__isl_take isl_point *pnt1,
__isl_take isl_point *pnt2);All elements of a bounded (union) set can be enumerated using the following functions.
isl_stat isl_set_foreach_point(__isl_keep isl_set *set,
isl_stat (*fn)(__isl_take isl_point *pnt,
void *user),
void *user);
isl_stat isl_union_set_foreach_point(
__isl_keep isl_union_set *uset,
isl_stat (*fn)(__isl_take isl_point *pnt,
void *user),
void *user);The function fn is called for each integer point in set with as second argument the last argument of the isl_set_foreach_point call. The function fn should return isl_stat_ok on success and isl_stat_error on failure. In the latter case, isl_set_foreach_point will stop enumerating and return isl_stat_error as well. If the enumeration is performed successfully and to completion, then isl_set_foreach_point returns isl_stat_ok.
To obtain a single point of a (basic or union) set, use
__isl_give isl_point *isl_basic_set_sample_point(
__isl_take isl_basic_set *bset);
__isl_give isl_point *isl_set_sample_point(
__isl_take isl_set *set);
__isl_give isl_point *isl_union_set_sample_point(
__isl_take isl_union_set *uset);If set does not contain any (integer) points, then the resulting point will be ``void'', a property that can be tested using
isl_bool isl_point_is_void(__isl_keep isl_point *pnt);Besides sets and relation, isl also supports various types of functions. Each of these types is derived from the value type (see "Values") or from one of two primitive function types through the application of zero or more type constructors. As a special case, a multiple expression can also be derived from an identifier (see "Identifiers") although the result is not really a function. We first describe the primitive type and then we describe the types derived from these primitive types.
isl support two primitive function types, quasi-affine expressions and quasipolynomials. A quasi-affine expression is defined either over a parameter space or over a set and is composed of integer constants, parameters and set variables, addition, subtraction and integer division by an integer constant. For example, the quasi-affine expression
[n] -> { [x] -> [2*floor((4 n + x)/9)] }maps x to 2*floor((4 n + x)/9. A quasipolynomial is a polynomial expression in quasi-affine expression. That is, it additionally allows for multiplication. Note, though, that it is not allowed to construct an integer division of an expression involving multiplications. Here is an example of a quasipolynomial that is not quasi-affine expression
[n] -> { [x] -> (n*floor((4 n + x)/9)) }Note that the external representations of quasi-affine expressions and quasipolynomials are different. Quasi-affine expressions use a notation with square brackets just like binary relations, while quasipolynomials do not. This might change at some point.
If a primitive function is defined over a parameter space, then the space of the function itself is that of a set. If it is defined over a set, then the space of the function is that of a relation. In both cases, the set space (or the output space) is single-dimensional, anonymous and unstructured. To create functions with multiple dimensions or with other kinds of set or output spaces, use multiple expressions (see "Multiple Expressions").
Quasi-affine Expressions
Besides the expressions described above, a quasi-affine expression can also be set to NaN. Such expressions typically represent a failure to represent a result as a quasi-affine expression.
The zero quasi affine expression or the quasi affine expression that is equal to a given value, parameter or a specified dimension on a given domain can be created using
#include <isl/aff.h>
__isl_give isl_aff *isl_aff_zero_on_domain_space(
__isl_take isl_space *space);
__isl_give isl_aff *isl_space_zero_aff_on_domain(
__isl_take isl_space *space);
__isl_give isl_aff *isl_aff_zero_on_domain(
__isl_take isl_local_space *ls);
__isl_give isl_aff *isl_aff_val_on_domain_space(
__isl_take isl_space *space,
__isl_take isl_val *val);
__isl_give isl_aff *isl_aff_val_on_domain(
__isl_take isl_local_space *ls,
__isl_take isl_val *val);
__isl_give isl_aff *isl_aff_param_on_domain_space_id(
__isl_take isl_space *space,
__isl_take isl_id *id);
__isl_give isl_aff *isl_space_param_aff_on_domain_id(
__isl_take isl_space *space,
__isl_take isl_id *id);
__isl_give isl_aff *isl_aff_var_on_domain(
__isl_take isl_local_space *ls,
enum isl_dim_type type, unsigned pos);
__isl_give isl_aff *isl_aff_nan_on_domain_space(
__isl_take isl_space *space);
__isl_give isl_aff *isl_aff_nan_on_domain(
__isl_take isl_local_space *ls);The space passed to isl_aff_param_on_domain_space_id is required to have a parameter with the given identifier. isl_aff_param_on_domain_space_id and isl_space_param_aff_on_domain_id perform the same operation.
isl_aff_zero_on_domain_space and isl_space_zero_aff_on_domain perform the same operation.
Quasi affine expressions can be copied and freed using
#include <isl/aff.h>
__isl_give isl_aff *isl_aff_copy(
__isl_keep isl_aff *aff);
__isl_null isl_aff *isl_aff_free(
__isl_take isl_aff *aff);A (rational) bound on a dimension can be extracted from an isl_constraint using the following function. The constraint is required to have a non-zero coefficient for the specified dimension.
#include <isl/constraint.h>
__isl_give isl_aff *isl_constraint_get_bound(
__isl_keep isl_constraint *constraint,
enum isl_dim_type type, int pos);The entire affine expression of the constraint can also be extracted using the following function.
#include <isl/constraint.h>
__isl_give isl_aff *isl_constraint_get_aff(
__isl_keep isl_constraint *constraint);Conversely, an equality constraint equating the affine expression to zero or an inequality constraint enforcing the affine expression to be non-negative, can be constructed using
__isl_give isl_constraint *isl_equality_from_aff(
__isl_take isl_aff *aff);
__isl_give isl_constraint *isl_inequality_from_aff(
__isl_take isl_aff *aff);The coefficients and the integer divisions of an affine expression can be inspected using the following functions.
#include <isl/aff.h>
__isl_give isl_val *isl_aff_get_constant_val(
__isl_keep isl_aff *aff);
__isl_give isl_val *isl_aff_get_coefficient_val(
__isl_keep isl_aff *aff,
enum isl_dim_type type, int pos);
int isl_aff_coefficient_sgn(__isl_keep isl_aff *aff,
enum isl_dim_type type, int pos);
__isl_give isl_val *isl_aff_get_denominator_val(
__isl_keep isl_aff *aff);
__isl_give isl_aff *isl_aff_get_div(
__isl_keep isl_aff *aff, int pos);They can be modified using the following functions.
#include <isl/aff.h>
__isl_give isl_aff *isl_aff_set_constant_si(
__isl_take isl_aff *aff, int v);
__isl_give isl_aff *isl_aff_set_constant_val(
__isl_take isl_aff *aff, __isl_take isl_val *v);
__isl_give isl_aff *isl_aff_set_coefficient_si(
__isl_take isl_aff *aff,
enum isl_dim_type type, int pos, int v);
__isl_give isl_aff *isl_aff_set_coefficient_val(
__isl_take isl_aff *aff,
enum isl_dim_type type, int pos,
__isl_take isl_val *v);
__isl_give isl_aff *isl_aff_add_constant_si(
__isl_take isl_aff *aff, int v);
__isl_give isl_aff *isl_aff_add_constant_val(
__isl_take isl_aff *aff, __isl_take isl_val *v);
__isl_give isl_aff *isl_aff_add_constant_num_si(
__isl_take isl_aff *aff, int v);
__isl_give isl_aff *isl_aff_add_coefficient_si(
__isl_take isl_aff *aff,
enum isl_dim_type type, int pos, int v);
__isl_give isl_aff *isl_aff_add_coefficient_val(
__isl_take isl_aff *aff,
enum isl_dim_type type, int pos,
__isl_take isl_val *v);Note that isl_aff_set_constant_si and isl_aff_set_coefficient_si set the numerator of the constant or coefficient, while isl_aff_set_constant_val and isl_aff_set_coefficient_val set the constant or coefficient as a whole. The add_constant and add_coefficient functions add an integer or rational value to the possibly rational constant or coefficient. The add_constant_num functions add an integer value to the numerator.
Quasipolynomials
Some simple quasipolynomials can be created using the following functions.
#include <isl/polynomial.h>
__isl_give isl_qpolynomial *isl_qpolynomial_zero_on_domain(
__isl_take isl_space *domain);
__isl_give isl_qpolynomial *isl_qpolynomial_one_on_domain(
__isl_take isl_space *domain);
__isl_give isl_qpolynomial *isl_qpolynomial_infty_on_domain(
__isl_take isl_space *domain);
__isl_give isl_qpolynomial *isl_qpolynomial_neginfty_on_domain(
__isl_take isl_space *domain);
__isl_give isl_qpolynomial *isl_qpolynomial_nan_on_domain(
__isl_take isl_space *domain);
__isl_give isl_qpolynomial *isl_qpolynomial_val_on_domain(
__isl_take isl_space *domain,
__isl_take isl_val *val);
__isl_give isl_qpolynomial *isl_qpolynomial_var_on_domain(
__isl_take isl_space *domain,
enum isl_dim_type type, unsigned pos);
__isl_give isl_qpolynomial *isl_qpolynomial_from_aff(
__isl_take isl_aff *aff);Recall that the space in which a quasipolynomial lives is a map space with a one-dimensional range. The domain argument in some of the functions above corresponds to the domain of this map space.
A quasi-polynomial that can also be represented as a quasi-affine expression can be converted using the function below.
#include <isl/polynomial.h>
isl_bool isl_qpolynomial_isa_aff(
__isl_keep isl_qpolynomial *qp);
__isl_give isl_aff *isl_qpolynomial_as_aff(
__isl_take isl_qpolynomial *qp);Quasipolynomials can be copied and freed again using the following functions.
#include <isl/polynomial.h>
__isl_give isl_qpolynomial *isl_qpolynomial_copy(
__isl_keep isl_qpolynomial *qp);
__isl_null isl_qpolynomial *isl_qpolynomial_free(
__isl_take isl_qpolynomial *qp);The constant term of a quasipolynomial can be extracted using
__isl_give isl_val *isl_qpolynomial_get_constant_val(
__isl_keep isl_qpolynomial *qp);To iterate over all terms in a quasipolynomial, use
isl_stat isl_qpolynomial_foreach_term(
__isl_keep isl_qpolynomial *qp,
isl_stat (*fn)(__isl_take isl_term *term,
void *user), void *user);The terms themselves can be inspected and freed using these functions
isl_size isl_term_dim(__isl_keep isl_term *term,
enum isl_dim_type type);
__isl_give isl_val *isl_term_get_coefficient_val(
__isl_keep isl_term *term);
isl_size isl_term_get_exp(__isl_keep isl_term *term,
enum isl_dim_type type, unsigned pos);
__isl_give isl_aff *isl_term_get_div(
__isl_keep isl_term *term, unsigned pos);
__isl_null isl_term *isl_term_free(
__isl_take isl_term *term);Each term is a product of parameters, set variables and integer divisions. The function isl_term_get_exp returns the exponent of a given dimensions in the given term.
A reduction represents a maximum or a minimum of its base expressions. The only reduction type defined by isl is isl_qpolynomial_fold.
There are currently no functions to directly create such objects, but they do appear in the piecewise quasipolynomial reductions returned by the isl_pw_qpolynomial_bound function. See "Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions".
Reductions can be copied and freed using the following functions.
#include <isl/polynomial.h>
__isl_give isl_qpolynomial_fold *
isl_qpolynomial_fold_copy(
__isl_keep isl_qpolynomial_fold *fold);
__isl_null isl_qpolynomial_fold *
isl_qpolynomial_fold_free(
__isl_take isl_qpolynomial_fold *fold);The type of a (union piecewise) reduction can be obtained using the following functions.
#include <isl/polynomial.h>
enum isl_fold isl_qpolynomial_fold_get_type(
__isl_keep isl_qpolynomial_fold *fold);
enum isl_fold isl_pw_qpolynomial_fold_get_type(
__isl_keep isl_pw_qpolynomial_fold *pwf);
enum isl_fold isl_union_pw_qpolynomial_fold_get_type(
__isl_keep isl_union_pw_qpolynomial_fold *upwf);The type may be either isl_fold_min or isl_fold_max (or isl_fold_error in case of error).
To iterate over all quasipolynomials in a reduction, use
isl_stat isl_qpolynomial_fold_foreach_qpolynomial(
__isl_keep isl_qpolynomial_fold *fold,
isl_stat (*fn)(__isl_take isl_qpolynomial *qp,
void *user), void *user);A multiple expression represents a sequence of zero or more base expressions, all defined on the same domain space. The domain space of the multiple expression is the same as that of the base expressions, but the range space can be any space. In case the base expressions have a set space, the corresponding multiple expression also has a set space. Objects of the value or identifier type do not have an associated space. The space of a multiple value or multiple identifier is therefore always a set space. Similarly, the space of a multiple union piecewise affine expression is always a set space. If the base expressions are not total, then a corresponding zero-dimensional multiple expression may have an explicit domain that keeps track of the domain outside of any base expressions.
The multiple expression types defined by isl are isl_multi_val, isl_multi_id, isl_multi_aff, isl_multi_pw_aff, isl_multi_union_pw_aff.
A multiple expression with the value zero for each output (or set) dimension can be created using the following functions.
#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_zero(
__isl_take isl_space *space);
__isl_give isl_multi_val *isl_space_zero_multi_val(
__isl_take isl_space *space);
#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_zero(
__isl_take isl_space *space);
__isl_give isl_multi_aff *isl_space_zero_multi_aff(
__isl_take isl_space *space);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_zero(
__isl_take isl_space *space);
__isl_give isl_multi_pw_aff *isl_space_zero_multi_pw_aff(
__isl_take isl_space *space);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_zero(
__isl_take isl_space *space);
__isl_give isl_multi_union_pw_aff *
isl_space_zero_multi_union_pw_aff(
__isl_take isl_space *space);Since there is no canonical way of representing a zero value of type isl_union_pw_aff, the space passed to isl_multi_union_pw_aff_zero needs to be zero-dimensional. isl_multi_val_zero and isl_space_zero_multi_val perform the same operation. Similarly for the pair isl_multi_aff_zero and isl_space_zero_multi_aff, for the pair isl_multi_pw_aff_zero and isl_space_zero_multi_pw_aff and for the pair isl_multi_union_pw_aff_zero and isl_space_zero_multi_union_pw_aff.
An identity function can be created using the following functions. For the first group of functions, the space needs to be that of a set. For the second group, the space needs to be that of a relation with the same number of input and output dimensions. For the third group, the input function needs to live in a space with the same number of input and output dimensions and the identity function is created in that space.
#include <isl/aff.h>
__isl_give isl_multi_aff *
isl_multi_aff_identity_on_domain_space(
__isl_take isl_space *space);
__isl_give isl_multi_aff *
isl_space_identity_multi_aff_on_domain(
__isl_take isl_space *space);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_identity_on_domain_space(
__isl_take isl_space *space);
__isl_give isl_multi_pw_aff *
isl_space_identity_multi_pw_aff_on_domain(
__isl_take isl_space *space);
__isl_give isl_multi_aff *isl_multi_aff_identity(
__isl_take isl_space *space);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_identity(
__isl_take isl_space *space);
__isl_give isl_multi_aff *
isl_multi_aff_identity_multi_aff(
__isl_take isl_multi_aff *ma);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_identity_multi_pw_aff(
__isl_take isl_multi_pw_aff *mpa);isl_multi_aff_identity_on_domain_space and isl_space_identity_multi_aff_on_domain perform the same operation. Similarly for the pair isl_multi_pw_aff_identity_on_domain_space and isl_space_identity_multi_pw_aff_on_domain.
A function that performs a projection on a universe relation or set can be created using the following functions. See also the corresponding projection operations in "Unary Operations".
#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_domain_map(
__isl_take isl_space *space);
__isl_give isl_multi_aff *isl_space_domain_map_multi_aff(
__isl_take isl_space *space);
__isl_give isl_multi_aff *isl_multi_aff_range_map(
__isl_take isl_space *space);
__isl_give isl_multi_aff *isl_space_range_map_multi_aff(
__isl_take isl_space *space);
__isl_give isl_multi_aff *isl_multi_aff_project_out_map(
__isl_take isl_space *space,
enum isl_dim_type type,
unsigned first, unsigned n);isl_multi_aff_domain_map and isl_space_domain_map_multi_aff perform the same operation. Similarly for the pair isl_multi_aff_range_map and isl_space_range_map_multi_aff.
A multiple expression can be created from a single base expression using the following functions. The space of the created multiple expression is the same as that of the base expression, except for isl_multi_union_pw_aff_from_union_pw_aff where the input lives in a parameter space and the output lives in a single-dimensional set space.
#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_from_aff(
__isl_take isl_aff *aff);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_pw_aff(
__isl_take isl_pw_aff *pa);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_from_union_pw_aff(
__isl_take isl_union_pw_aff *upa);A multiple expression can be created from a list of base expression in a specified space. The domain of this space needs to be the same as the domains of the base expressions in the list. If the base expressions have a set space (or no associated space), then this space also needs to be a set space.
#include <isl/id.h>
__isl_give isl_multi_id *isl_multi_id_from_id_list(
__isl_take isl_space *space,
__isl_take isl_id_list *list);
__isl_give isl_multi_id *isl_space_multi_id(
__isl_take isl_space *space,
__isl_take isl_id_list *list);
#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_from_val_list(
__isl_take isl_space *space,
__isl_take isl_val_list *list);
__isl_give isl_multi_val *isl_space_multi_val(
__isl_take isl_space *space,
__isl_take isl_val_list *list);
#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_from_aff_list(
__isl_take isl_space *space,
__isl_take isl_aff_list *list);
__isl_give isl_multi_aff *isl_space_multi_aff(
__isl_take isl_space *space,
__isl_take isl_aff_list *list);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_from_pw_aff_list(
__isl_take isl_space *space,
__isl_take isl_pw_aff_list *list);
__isl_give isl_multi_pw_aff *
isl_space_multi_pw_aff(
__isl_take isl_space *space,
__isl_take isl_pw_aff_list *list);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_from_union_pw_aff_list(
__isl_take isl_space *space,
__isl_take isl_union_pw_aff_list *list);
__isl_give isl_multi_union_pw_aff *
isl_space_multi_union_pw_aff(
__isl_take isl_space *space,
__isl_take isl_union_pw_aff_list *list);isl_multi_id_from_id_list and isl_space_multi_id perform the same operation. Similarly for the pair isl_multi_val_from_val_list and isl_space_multi_val, for the pair isl_multi_aff_from_aff_list and isl_space_multi_aff, for the pair isl_multi_pw_aff_from_pw_aff_list and isl_space_multi_pw_aff and for the pair isl_multi_union_pw_aff_from_union_pw_aff_list and isl_space_multi_union_pw_aff.
As a convenience, a multiple piecewise expression can also be created from a multiple expression, or even directly from a single base expression. Each piecewise expression in the result has a single universe cell.
#include <isl/aff.h>
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_aff(
__isl_take isl_aff *aff);
__isl_give isl_multi_pw_aff *
isl_multi_aff_to_multi_pw_aff(
__isl_take isl_multi_aff *ma);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_from_multi_aff(
__isl_take isl_multi_aff *ma);isl_multi_aff_to_multi_pw_aff and isl_multi_pw_aff_from_multi_aff perform the same operation.
Similarly, a multiple union expression can be created from a multiple expression.
#include <isl/aff.h>
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_from_multi_aff(
__isl_take isl_multi_aff *ma);
__isl_give isl_multi_union_pw_aff *
isl_multi_aff_to_multi_union_pw_aff(
__isl_take isl_multi_aff *ma);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_from_multi_pw_aff(
__isl_take isl_multi_pw_aff *mpa);isl_multi_aff_to_multi_union_pw_aff and isl_multi_union_pw_aff_from_multi_aff perform the same operation.
A multiple quasi-affine expression can be created from a multiple value with a given domain space using the following function.
#include <isl/aff.h>
__isl_give isl_multi_aff *
isl_multi_aff_multi_val_on_domain_space(
__isl_take isl_space *space,
__isl_take isl_multi_val *mv);
__isl_give isl_multi_aff *
isl_space_multi_aff_on_domain_multi_val(
__isl_take isl_space *space,
__isl_take isl_multi_val *mv);
__isl_give isl_multi_aff *
isl_multi_aff_multi_val_on_space(
__isl_take isl_space *space,
__isl_take isl_multi_val *mv);isl_space_multi_aff_on_domain_multi_val and isl_multi_aff_multi_val_on_space are alternative names for isl_multi_aff_multi_val_on_domain_space.
Similarly, a multiple union piecewise affine expression can be created from a multiple value with a given domain or a (piecewise) multiple affine expression with a given domain using the following functions.
#include <isl/aff.h>
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_multi_val_on_domain(
__isl_take isl_union_set *domain,
__isl_take isl_multi_val *mv);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_multi_aff_on_domain(
__isl_take isl_union_set *domain,
__isl_take isl_multi_aff *ma);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_pw_multi_aff_on_domain(
__isl_take isl_union_set *domain,
__isl_take isl_pw_multi_aff *pma);Multiple expressions can be copied and freed using the following functions.
#include <isl/id.h>
__isl_give isl_multi_id *isl_multi_id_copy(
__isl_keep isl_multi_id *mi);
__isl_null isl_multi_id *isl_multi_id_free(
__isl_take isl_multi_id *mi);
#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_copy(
__isl_keep isl_multi_val *mv);
__isl_null isl_multi_val *isl_multi_val_free(
__isl_take isl_multi_val *mv);
#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_copy(
__isl_keep isl_multi_aff *maff);
__isl_null isl_multi_aff *isl_multi_aff_free(
__isl_take isl_multi_aff *maff);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_copy(
__isl_keep isl_multi_pw_aff *mpa);
__isl_null isl_multi_pw_aff *isl_multi_pw_aff_free(
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_copy(
__isl_keep isl_multi_union_pw_aff *mupa);
__isl_null isl_multi_union_pw_aff *
isl_multi_union_pw_aff_free(
__isl_take isl_multi_union_pw_aff *mupa);The number of base expressions in a multiple expression can be obtained using the following functions.
#include <isl/id.h>
int isl_multi_id_size(__isl_keep isl_multi_id *mi);
#include <isl/val.h>
isl_size isl_multi_val_size(__isl_keep isl_multi_val *mv);
#include <isl/aff.h>
isl_size isl_multi_aff_size(
__isl_keep isl_multi_aff *multi);
isl_size isl_multi_pw_aff_size(
__isl_keep isl_multi_pw_aff *mpa);
isl_size isl_multi_union_pw_aff_size(
__isl_keep isl_multi_union_pw_aff *mupa);The base expression at a given position of a multiple expression can be extracted using the following functions.
#include <isl/id.h>
__isl_give isl_id *isl_multi_id_get_at(
__isl_keep isl_multi_id *mi, int pos);
__isl_give isl_id *isl_multi_id_get_id(
__isl_keep isl_multi_id *mi, int pos);
#include <isl/val.h>
__isl_give isl_val *isl_multi_val_get_at(
__isl_keep isl_multi_val *mv, int pos);
__isl_give isl_val *isl_multi_val_get_val(
__isl_keep isl_multi_val *mv, int pos);
#include <isl/aff.h>
__isl_give isl_aff *isl_multi_aff_get_at(
__isl_keep isl_multi_aff *ma, int pos);
__isl_give isl_aff *isl_multi_aff_get_aff(
__isl_keep isl_multi_aff *multi, int pos);
__isl_give isl_pw_aff *isl_multi_pw_aff_get_at(
__isl_keep isl_multi_pw_aff *mpa, int pos);
__isl_give isl_pw_aff *isl_multi_pw_aff_get_pw_aff(
__isl_keep isl_multi_pw_aff *mpa, int pos);
__isl_give isl_union_pw_aff *
isl_multi_union_pw_aff_get_at(
__isl_keep isl_multi_union_pw_aff *mupa, int pos);
__isl_give isl_union_pw_aff *
isl_multi_union_pw_aff_get_union_pw_aff(
__isl_keep isl_multi_union_pw_aff *mupa, int pos);isl_multi_id_get_id is an alternative name for isl_multi_id_get_at. Similarly for the other pairs of functions.
The base expression can be replaced using the following functions.
#include <isl/id.h>
__isl_give isl_multi_id *isl_multi_id_set_at(
__isl_take isl_multi_id *mi, int pos,
__isl_take isl_id *id);
__isl_give isl_multi_id *isl_multi_id_set_id(
__isl_take isl_multi_id *mi, int pos,
__isl_take isl_id *id);
#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_set_at(
__isl_take isl_multi_val *mv, int pos,
__isl_take isl_val *val);
__isl_give isl_multi_val *isl_multi_val_set_val(
__isl_take isl_multi_val *mv, int pos,
__isl_take isl_val *val);
#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_set_at(
__isl_take isl_multi_aff *ma, int pos,
__isl_take isl_aff *aff);
__isl_give isl_multi_aff *isl_multi_aff_set_aff(
__isl_take isl_multi_aff *multi, int pos,
__isl_take isl_aff *aff);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_set_at(
__isl_take isl_multi_pw_aff *mpa, int pos,
__isl_take isl_pw_aff *pa);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_set_pw_aff(
__isl_take isl_multi_pw_aff *mpa, int pos,
__isl_take isl_pw_aff *pa);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_set_at(
__isl_take isl_multi_union_pw_aff *mupa, int pos,
__isl_take isl_union_pw_aff *upa);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_set_union_pw_aff(
__isl_take isl_multi_union_pw_aff *mupa, int pos,
__isl_take isl_union_pw_aff *upa);isl_multi_id_set_id is an alternative name for isl_multi_id_set_at. Similarly for the other pairs of functions.
A list of all base expressions of a multiple expression can be extracted using the following functions.
#include <isl/id.h>
__isl_give isl_id_list *isl_multi_id_get_list(
__isl_keep isl_multi_id *mi);
#include <isl/val.h>
__isl_give isl_val_list *isl_multi_val_get_list(
__isl_keep isl_multi_val *mv);
#include <isl/aff.h>
__isl_give isl_aff_list *isl_multi_aff_get_list(
__isl_keep isl_multi_aff *multi);
__isl_give isl_pw_aff_list *isl_multi_pw_aff_get_list(
__isl_keep isl_multi_pw_aff *mpa);
__isl_give isl_union_pw_aff_list *
isl_multi_union_pw_aff_list(
__isl_keep isl_multi_union_pw_aff *mupa);The constant terms of the base expressions can be obtained using the following function.
#include <isl/aff.h>
__isl_give isl_multi_val *
isl_multi_aff_get_constant_multi_val(
__isl_keep isl_multi_aff *ma);As a convenience, a sequence of base expressions that have their domains in a given space can be extracted from a sequence of union expressions using the following function.
#include <isl/aff.h>
__isl_give isl_multi_pw_aff *
isl_multi_union_pw_aff_extract_multi_pw_aff(
__isl_keep isl_multi_union_pw_aff *mupa,
__isl_take isl_space *space);Note that there is a difference between isl_multi_union_pw_aff and isl_union_pw_multi_aff objects. The first is a sequence of unions of piecewise expressions, while the second is a union of piecewise sequences. In particular, multiple affine expressions in an isl_union_pw_multi_aff may live in different spaces, while there is only a single multiple expression in an isl_multi_union_pw_aff, which can therefore only live in a single space. This means that not every isl_union_pw_multi_aff can be converted to an isl_multi_union_pw_aff. Conversely, the elements of an isl_multi_union_pw_aff may be defined over different domains, while each multiple expression inside an isl_union_pw_multi_aff has a single domain. The conversion of an isl_union_pw_multi_aff of dimension greater than one may therefore not be exact. The following functions can be used to perform these conversions when they are possible.
#include <isl/aff.h>
__isl_give isl_multi_union_pw_aff *
isl_union_pw_multi_aff_as_multi_union_pw_aff(
__isl_take isl_union_pw_multi_aff *upma);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_from_union_pw_multi_aff(
__isl_take isl_union_pw_multi_aff *upma);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_from_multi_union_pw_aff(
__isl_take isl_multi_union_pw_aff *mupa);isl_union_pw_multi_aff_as_multi_union_pw_aff and isl_multi_union_pw_aff_from_union_pw_multi_aff perform the same operation.
A piecewise expression is an expression that is described using zero or more base expression defined over the same number of cells in the domain space of the base expressions. All base expressions are defined over the same domain space and the cells are disjoint. The space of a piecewise expression is the same as that of the base expressions. If the union of the cells is a strict subset of the domain space, then the value of the piecewise expression outside this union is different for types derived from quasi-affine expressions and those derived from quasipolynomials. Piecewise expressions derived from quasi-affine expressions are considered to be undefined outside the union of their cells. Piecewise expressions derived from quasipolynomials are considered to be zero outside the union of their cells.
Piecewise quasipolynomials are mainly used by the barvinok library for representing the number of elements in a parametric set or map. For example, the piecewise quasipolynomial
[n] -> { [x] -> ((1 + n) - x) : x <= n and x >= 0 }represents the number of points in the map
[n] -> { [x] -> [y] : x,y >= 0 and 0 <= x + y <= n }The piecewise expression types defined by isl are isl_pw_aff, isl_pw_multi_aff, isl_pw_qpolynomial and isl_pw_qpolynomial_fold.
A piecewise expression with no cells can be created using the following functions.
#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_empty(
__isl_take isl_space *space);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_empty(
__isl_take isl_space *space);A piecewise expression with a single universe cell can be created using the following functions.
#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_from_aff(
__isl_take isl_aff *aff);
__isl_give isl_pw_multi_aff *
isl_multi_aff_to_pw_multi_aff(
__isl_take isl_multi_aff *ma);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_from_multi_aff(
__isl_take isl_multi_aff *ma);
#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial *
isl_pw_qpolynomial_from_qpolynomial(
__isl_take isl_qpolynomial *qp);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_from_qpolynomial_fold(
__isl_take isl_qpolynomial_fold *fold);isl_multi_aff_to_pw_multi_aff and isl_pw_multi_aff_from_multi_aff perform the same operation.
The inverse conversions below can only be used if the input expression is known to be defined over a single universe domain.
#include <isl/aff.h>
isl_bool isl_pw_aff_isa_aff(__isl_keep isl_pw_aff *pa);
__isl_give isl_aff *isl_pw_aff_as_aff(
__isl_take isl_pw_aff *pa);
isl_bool isl_multi_pw_aff_isa_multi_aff(
__isl_keep isl_multi_pw_aff *mpa);
__isl_give isl_multi_aff *isl_multi_pw_aff_as_multi_aff(
__isl_take isl_multi_pw_aff *mpa);
isl_bool isl_pw_multi_aff_isa_multi_aff(
__isl_keep isl_pw_multi_aff *pma);
__isl_give isl_multi_aff *isl_pw_multi_aff_as_multi_aff(
__isl_take isl_pw_multi_aff *pma);
#include <isl/polynomial.h>
isl_bool isl_pw_qpolynomial_isa_qpolynomial(
__isl_keep isl_pw_qpolynomial *pwqp);
__isl_give isl_qpolynomial *
isl_pw_qpolynomial_as_qpolynomial(
__isl_take isl_pw_qpolynomial *pwqp);
isl_bool isl_pw_qpolynomial_fold_isa_qpolynomial_fold(
__isl_keep isl_pw_qpolynomial_fold *pwf);
__isl_give isl_qpolynomial_fold *
isl_pw_qpolynomial_fold_as_qpolynomial_fold(
__isl_take isl_pw_qpolynomial_fold *pwf);A piecewise expression with a single specified cell can be created using the following functions.
#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_alloc(
__isl_take isl_set *set, __isl_take isl_aff *aff);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_alloc(
__isl_take isl_set *set,
__isl_take isl_multi_aff *maff);
#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_alloc(
__isl_take isl_set *set,
__isl_take isl_qpolynomial *qp);The following convenience functions first create a base expression and then create a piecewise expression over a universe domain.
#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_zero_on_domain(
__isl_take isl_local_space *ls);
__isl_give isl_pw_aff *isl_pw_aff_var_on_domain(
__isl_take isl_local_space *ls,
enum isl_dim_type type, unsigned pos);
__isl_give isl_pw_aff *isl_pw_aff_nan_on_domain_space(
__isl_take isl_space *space);
__isl_give isl_pw_aff *isl_pw_aff_nan_on_domain(
__isl_take isl_local_space *ls);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_zero(
__isl_take isl_space *space);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_identity_on_domain_space(
__isl_take isl_space *space)
__isl_give isl_pw_multi_aff *
isl_space_identity_pw_multi_aff_on_domain(
__isl_take isl_space *space)
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_identity(
__isl_take isl_space *space);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_domain_map(
__isl_take isl_space *space);
__isl_give isl_pw_multi_aff *
isl_space_domain_map_pw_multi_aff(
__isl_take isl_space *space);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_map(
__isl_take isl_space *space);
__isl_give isl_pw_multi_aff *
isl_space_range_map_pw_multi_aff(
__isl_take isl_space *space);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_project_out_map(
__isl_take isl_space *space,
enum isl_dim_type type,
unsigned first, unsigned n);
#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_zero(
__isl_take isl_space *space);isl_pw_multi_aff_identity_on_domain_space and isl_space_identity_pw_multi_aff_on_domain perform the same operation. Similarly for the pair isl_pw_multi_aff_domain_map and isl_space_domain_map_pw_multi_aff and for the pair isl_pw_multi_aff_range_map and isl_space_range_map_pw_multi_aff.
The following convenience functions first create a base expression and then create a piecewise expression over a given domain.
#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_val_on_domain(
__isl_take isl_set *domain,
__isl_take isl_val *v);
__isl_give isl_pw_aff *isl_set_pw_aff_on_domain_val(
__isl_take isl_set *domain,
__isl_take isl_val *v);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_multi_val_on_domain(
__isl_take isl_set *domain,
__isl_take isl_multi_val *mv);
__isl_give isl_pw_multi_aff *
isl_set_pw_multi_aff_on_domain_multi_val(
__isl_take isl_set *domain,
__isl_take isl_multi_val *mv);
__isl_give isl_pw_aff *isl_pw_aff_param_on_domain_id(
__isl_take isl_set *domain,
__isl_take isl_id *id);
__isl_give isl_pw_aff *isl_set_param_pw_aff_on_domain_id(
__isl_take isl_set *domain,
__isl_take isl_id *id);isl_set_pw_aff_on_domain_val is an alternative name for isl_pw_aff_val_on_domain. Similarly for the pair isl_set_pw_multi_aff_on_domain_multi_val and isl_pw_multi_aff_multi_val_on_domain and for the pair isl_set_param_pw_aff_on_domain_id and isl_pw_aff_param_on_domain_id.
As a convenience, a piecewise multiple expression can also be created from a piecewise expression. Each multiple expression in the result is derived from the corresponding base expression.
#include <isl/aff.h>
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_pw_aff(
__isl_take isl_pw_aff *pa);Similarly, a piecewise quasipolynomial can be created from a piecewise quasi-affine expression using the following function.
#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial *
isl_pw_qpolynomial_from_pw_aff(
__isl_take isl_pw_aff *pwaff);Piecewise expressions can be copied and freed using the following functions.
#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_copy(
__isl_keep isl_pw_aff *pwaff);
__isl_null isl_pw_aff *isl_pw_aff_free(
__isl_take isl_pw_aff *pwaff);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_copy(
__isl_keep isl_pw_multi_aff *pma);
__isl_null isl_pw_multi_aff *isl_pw_multi_aff_free(
__isl_take isl_pw_multi_aff *pma);
#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_copy(
__isl_keep isl_pw_qpolynomial *pwqp);
__isl_null isl_pw_qpolynomial *isl_pw_qpolynomial_free(
__isl_take isl_pw_qpolynomial *pwqp);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_copy(
__isl_keep isl_pw_qpolynomial_fold *pwf);
__isl_null isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_free(
__isl_take isl_pw_qpolynomial_fold *pwf);To iterate over the different cells of a piecewise expression, use the following functions.
#include <isl/aff.h>
isl_bool isl_pw_aff_is_empty(__isl_keep isl_pw_aff *pwaff);
isl_size isl_pw_aff_n_piece(__isl_keep isl_pw_aff *pwaff);
isl_stat isl_pw_aff_foreach_piece(
__isl_keep isl_pw_aff *pwaff,
isl_stat (*fn)(__isl_take isl_set *set,
__isl_take isl_aff *aff,
void *user), void *user);
isl_bool isl_pw_aff_every_piece(__isl_keep isl_pw_aff *pa,
isl_bool (*test)(__isl_keep isl_set *set,
__isl_keep isl_aff *aff, void *user),
void *user);
isl_size isl_pw_multi_aff_n_piece(
__isl_keep isl_pw_multi_aff *pma);
isl_stat isl_pw_multi_aff_foreach_piece(
__isl_keep isl_pw_multi_aff *pma,
isl_stat (*fn)(__isl_take isl_set *set,
__isl_take isl_multi_aff *maff,
void *user), void *user);
isl_bool isl_pw_multi_aff_every_piece(
__isl_keep isl_pw_multi_aff *pma,
isl_bool (*test)(__isl_keep isl_set *set,
__isl_keep isl_multi_aff *ma, void *user),
void *user);
#include <isl/polynomial.h>
isl_size isl_pw_qpolynomial_n_piece(
__isl_keep isl_pw_qpolynomial *pwqp);
isl_stat isl_pw_qpolynomial_foreach_piece(
__isl_keep isl_pw_qpolynomial *pwqp,
isl_stat (*fn)(__isl_take isl_set *set,
__isl_take isl_qpolynomial *qp,
void *user), void *user);
isl_bool isl_pw_qpolynomial_every_piece(
__isl_keep isl_pw_qpolynomial *pwqp,
isl_bool (*test)(__isl_keep isl_set *set,
__isl_keep isl_qpolynomial *qp,
void *user), void *user);
isl_stat isl_pw_qpolynomial_foreach_lifted_piece(
__isl_keep isl_pw_qpolynomial *pwqp,
isl_stat (*fn)(__isl_take isl_set *set,
__isl_take isl_qpolynomial *qp,
void *user), void *user);
isl_size isl_pw_qpolynomial_fold_n_piece(
__isl_keep isl_pw_qpolynomial_fold *pwf);
isl_stat isl_pw_qpolynomial_fold_foreach_piece(
__isl_keep isl_pw_qpolynomial_fold *pwf,
isl_stat (*fn)(__isl_take isl_set *set,
__isl_take isl_qpolynomial_fold *fold,
void *user), void *user);
isl_bool isl_pw_qpolynomial_fold_every_piece(
__isl_keep isl_pw_qpolynomial_fold *pwf,
isl_bool (*test)(__isl_keep isl_set *set,
__isl_keep isl_qpolynomial_fold *fold,
void *user), void *user);
isl_stat isl_pw_qpolynomial_fold_foreach_lifted_piece(
__isl_keep isl_pw_qpolynomial_fold *pwf,
isl_stat (*fn)(__isl_take isl_set *set,
__isl_take isl_qpolynomial_fold *fold,
void *user), void *user);As usual, the function fn should return isl_stat_ok on success and isl_stat_error on failure. The difference between isl_pw_qpolynomial_foreach_piece and isl_pw_qpolynomial_foreach_lifted_piece is that isl_pw_qpolynomial_foreach_lifted_piece will first compute unique representations for all existentially quantified variables and then turn these existentially quantified variables into extra set variables, adapting the associated quasipolynomial accordingly. This means that the set passed to fn will not have any existentially quantified variables, but that the dimensions of the sets may be different for different invocations of fn. Similarly for isl_pw_qpolynomial_fold_foreach_piece and isl_pw_qpolynomial_fold_foreach_lifted_piece. The function isl_pw_aff_every_piece and its variants check whether each call to the callback returns true and stop checking as soon as one of these calls returns false (or error).
A piecewise expression consisting of the expressions at a given position of a piecewise multiple expression can be extracted using the following function.
#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_multi_aff_get_at(
__isl_keep isl_pw_multi_aff *pma, int pos);
__isl_give isl_pw_aff *isl_pw_multi_aff_get_pw_aff(
__isl_keep isl_pw_multi_aff *pma, int pos);isl_pw_multi_aff_get_pw_aff is an alternative name for isl_pw_multi_aff_get_at.
These expressions can be replaced using the following function.
#include <isl/aff.h>
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_pw_aff(
__isl_take isl_pw_multi_aff *pma, unsigned pos,
__isl_take isl_pw_aff *pa);Note that there is a difference between isl_multi_pw_aff and isl_pw_multi_aff objects. The first is a sequence of piecewise affine expressions, while the second is a piecewise sequence of affine expressions. In particular, each of the piecewise affine expressions in an isl_multi_pw_aff may have a different domain, while all multiple expressions associated to a cell in an isl_pw_multi_aff have the same domain. It is possible to convert between the two, but when converting an isl_multi_pw_aff to an isl_pw_multi_aff, the domain of the result is the intersection of the domains of the input. The reverse conversion is exact.
#include <isl/aff.h>
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_from_multi_pw_aff(
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_multi_pw_aff *
isl_pw_multi_aff_to_multi_pw_aff(
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_from_pw_multi_aff(
__isl_take isl_pw_multi_aff *pma);isl_pw_multi_aff_to_multi_pw_aff and isl_multi_pw_aff_from_pw_multi_aff perform the same operation.
A union expression collects base expressions defined over different domains. The space of a union expression is that of the shared parameter space.
The union expression types defined by isl are isl_union_pw_aff, isl_union_pw_multi_aff, isl_union_pw_qpolynomial and isl_union_pw_qpolynomial_fold. In case of isl_union_pw_aff, isl_union_pw_qpolynomial and isl_union_pw_qpolynomial_fold, there can be at most one base expression for a given domain space. In case of isl_union_pw_multi_aff, there can be multiple such expressions for a given domain space, but the domains of these expressions need to be disjoint.
An empty union expression can be created using the following functions.
#include <isl/aff.h>
__isl_give isl_union_pw_aff *
isl_union_pw_aff_empty_ctx(
isl_ctx *ctx);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_empty_space(
__isl_take isl_space *space);
__isl_give isl_union_pw_aff *isl_union_pw_aff_empty(
__isl_take isl_space *space);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_empty_ctx(
isl_ctx *ctx);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_empty_space(
__isl_take isl_space *space);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_empty(
__isl_take isl_space *space);
#include <isl/polynomial.h>
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_zero_ctx(
isl_ctx *ctx);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_zero_space(
__isl_take isl_space *space);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_zero(
__isl_take isl_space *space);isl_union_pw_aff_empty is an alternative name for isl_union_pw_aff_empty_space. Similarly for the other pairs of functions.
A union expression containing a single base expression can be created using the following functions.
#include <isl/aff.h>
__isl_give isl_union_pw_aff *
isl_pw_aff_to_union_pw_aff(
__isl_take isl_pw_aff *pa);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_from_pw_aff(
__isl_take isl_pw_aff *pa);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_from_aff(
__isl_take isl_aff *aff);
__isl_give isl_union_pw_multi_aff *
isl_pw_multi_aff_to_union_pw_multi_aff(
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_from_pw_multi_aff(
__isl_take isl_pw_multi_aff *pma);
#include <isl/polynomial.h>
__isl_give isl_union_pw_qpolynomial *
isl_pw_qpolynomial_to_union_pw_qpolynomial(
__isl_take isl_pw_qpolynomial *pwqp);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_from_pw_qpolynomial(
__isl_take isl_pw_qpolynomial *pwqp);
__isl_give isl_union_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_to_union_pw_qpolynomial_fold(
__isl_take isl_pw_qpolynomial_fold *pwf);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_from_pw_qpolynomial_fold(
__isl_take isl_pw_qpolynomial_fold *pwf);isl_pw_aff_to_union_pw_aff and isl_union_pw_aff_from_pw_aff perform the same operation. Similarly for isl_pw_multi_aff_to_union_pw_multi_aff and isl_union_pw_multi_aff_from_pw_multi_aff, for isl_pw_qpolynomial_to_union_pw_qpolynomial and isl_union_pw_qpolynomial_from_pw_qpolynomial, and for isl_pw_qpolynomial_fold_to_union_pw_qpolynomial_fold and isl_union_pw_qpolynomial_fold_from_pw_qpolynomial_fold.
The inverse conversions below can only be used if the input expression is known to live in exactly one space.
#include <isl/aff.h>
isl_bool isl_union_pw_multi_aff_isa_pw_multi_aff(
__isl_keep isl_union_pw_multi_aff *upma);
__isl_give isl_pw_multi_aff *
isl_union_pw_multi_aff_as_pw_multi_aff(
__isl_take isl_union_pw_multi_aff *upma);A union piecewise expression containing a single base expression on a universe domain can also be created directly from a base expression using the following functions.
#include <isl/aff.h>
__isl_give isl_union_pw_aff *isl_union_pw_aff_from_aff(
__isl_take isl_aff *aff);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_from_multi_aff(
__isl_take isl_multi_aff *ma);The following functions create a base expression on each of the sets in the union set and collect the results.
#include <isl/aff.h>
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_from_union_pw_aff(
__isl_take isl_union_pw_aff *upa);
__isl_give isl_union_pw_aff *
isl_union_pw_multi_aff_get_union_pw_aff(
__isl_keep isl_union_pw_multi_aff *upma, int pos);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_val_on_domain(
__isl_take isl_union_set *domain,
__isl_take isl_val *v);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_multi_val_on_domain(
__isl_take isl_union_set *domain,
__isl_take isl_multi_val *mv);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_param_on_domain_id(
__isl_take isl_union_set *domain,
__isl_take isl_id *id);The id argument of isl_union_pw_aff_param_on_domain_id is the identifier of a parameter that may or may not already be present in domain.
An isl_union_pw_aff that is equal to a (parametric) affine or piecewise affine expression on a given domain can be created using the following functions.
#include <isl/aff.h>
__isl_give isl_union_pw_aff *
isl_union_pw_aff_aff_on_domain(
__isl_take isl_union_set *domain,
__isl_take isl_aff *aff);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_pw_aff_on_domain(
__isl_take isl_union_set *domain,
__isl_take isl_pw_aff *pa);A base expression can be added to a union expression using the following functions.
#include <isl/aff.h>
__isl_give isl_union_pw_aff *
isl_union_pw_aff_add_pw_aff(
__isl_take isl_union_pw_aff *upa,
__isl_take isl_pw_aff *pa);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_add_pw_multi_aff(
__isl_take isl_union_pw_multi_aff *upma,
__isl_take isl_pw_multi_aff *pma);
#include <isl/polynomial.h>
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_add_pw_qpolynomial(
__isl_take isl_union_pw_qpolynomial *upwqp,
__isl_take isl_pw_qpolynomial *pwqp);Union expressions can be copied and freed using the following functions.
#include <isl/aff.h>
__isl_give isl_union_pw_aff *isl_union_pw_aff_copy(
__isl_keep isl_union_pw_aff *upa);
__isl_null isl_union_pw_aff *isl_union_pw_aff_free(
__isl_take isl_union_pw_aff *upa);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_copy(
__isl_keep isl_union_pw_multi_aff *upma);
__isl_null isl_union_pw_multi_aff *
isl_union_pw_multi_aff_free(
__isl_take isl_union_pw_multi_aff *upma);
#include <isl/polynomial.h>
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_copy(
__isl_keep isl_union_pw_qpolynomial *upwqp);
__isl_null isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_free(
__isl_take isl_union_pw_qpolynomial *upwqp);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_copy(
__isl_keep isl_union_pw_qpolynomial_fold *upwf);
__isl_null isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_free(
__isl_take isl_union_pw_qpolynomial_fold *upwf);To iterate over the base expressions in a union expression, use the following functions.
#include <isl/aff.h>
isl_size isl_union_pw_aff_n_pw_aff(
__isl_keep isl_union_pw_aff *upa);
isl_stat isl_union_pw_aff_foreach_pw_aff(
__isl_keep isl_union_pw_aff *upa,
isl_stat (*fn)(__isl_take isl_pw_aff *pa,
void *user), void *user);
isl_bool isl_union_pw_aff_every_pw_aff(
__isl_keep isl_union_pw_aff *upa,
isl_bool (*test)(__isl_keep isl_pw_aff *pa,
void *user), void *user);
isl_size isl_union_pw_multi_aff_n_pw_multi_aff(
__isl_keep isl_union_pw_multi_aff *upma);
isl_stat isl_union_pw_multi_aff_foreach_pw_multi_aff(
__isl_keep isl_union_pw_multi_aff *upma,
isl_stat (*fn)(__isl_take isl_pw_multi_aff *pma,
void *user), void *user);
isl_bool isl_union_pw_multi_aff_every_pw_multi_aff(
__isl_keep isl_union_pw_multi_aff *upma,
isl_bool (*test)(
__isl_keep isl_pw_multi_aff *pma,
void *user), void *user);
#include <isl/polynomial.h>
isl_size isl_union_pw_qpolynomial_n_pw_qpolynomial(
__isl_keep isl_union_pw_qpolynomial *upwqp);
isl_stat isl_union_pw_qpolynomial_foreach_pw_qpolynomial(
__isl_keep isl_union_pw_qpolynomial *upwqp,
isl_stat (*fn)(__isl_take isl_pw_qpolynomial *pwqp,
void *user), void *user);
isl_bool isl_union_pw_qpolynomial_every_pw_qpolynomial(
__isl_keep isl_union_pw_qpolynomial *upwqp,
isl_bool (*test)(
__isl_keep isl_pw_qpolynomial *pwqp,
void *user), void *user);
isl_size isl_union_pw_qpolynomial_fold_n_pw_qpolynomial_fold(
__isl_keep isl_union_pw_qpolynomial_fold *upwf);
isl_stat isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(
__isl_keep isl_union_pw_qpolynomial_fold *upwf,
isl_stat (*fn)(__isl_take isl_pw_qpolynomial_fold *pwf,
void *user), void *user);
isl_bool
isl_union_pw_qpolynomial_fold_every_pw_qpolynomial_fold(
__isl_keep isl_union_pw_qpolynomial_fold *upwf,
isl_bool (*test)(
__isl_keep isl_pw_qpolynomial_fold *pwf,
void *user), void *user);To extract the base expression in a given space from a union, use the following functions.
#include <isl/aff.h>
__isl_give isl_pw_aff *isl_union_pw_aff_extract_pw_aff(
__isl_keep isl_union_pw_aff *upa,
__isl_take isl_space *space);
__isl_give isl_pw_multi_aff *
isl_union_pw_multi_aff_extract_pw_multi_aff(
__isl_keep isl_union_pw_multi_aff *upma,
__isl_take isl_space *space);
#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial *
isl_union_pw_qpolynomial_extract_pw_qpolynomial(
__isl_keep isl_union_pw_qpolynomial *upwqp,
__isl_take isl_space *space);It is also possible to obtain a list of the base expressions using the following functions.
#include <isl/aff.h>
__isl_give isl_pw_aff_list *
isl_union_pw_aff_get_pw_aff_list(
__isl_keep isl_union_pw_aff *upa);
__isl_give isl_pw_multi_aff_list *
isl_union_pw_multi_aff_get_pw_multi_aff_list(
__isl_keep isl_union_pw_multi_aff *upma);
#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial_list *
isl_union_pw_qpolynomial_get_pw_qpolynomial_list(
__isl_keep isl_union_pw_qpolynomial *upwqp);
__isl_give isl_pw_qpolynomial_fold_list *
isl_union_pw_qpolynomial_fold_get_pw_qpolynomial_fold_list(
__isl_keep isl_union_pw_qpolynomial_fold *upwf);The returned list can be manipulated using the functions in "Lists".
For set and relation, isl supports its own input/output format, which is similar to the Omega format, but also supports the PolyLib format in some cases. For other object types, typically only an isl format is supported.
isl formatThe isl format is similar to that of Omega, but has a different syntax for describing the parameters and allows for the definition of an existentially quantified variable as the integer division of an affine expression. For example, the set of integers i between 0 and n such that i % 10 <= 6 can be described as
[n] -> { [i] : exists (a = [i/10] : 0 <= i and i <= n and
i - 10 a <= 6) }A set or relation can have several disjuncts, separated by the keyword or. Each disjunct is either a conjunction of constraints or a projection (exists) of a conjunction of constraints. The constraints are separated by the keyword and.
PolyLib formatIf the represented set is a union, then the first line contains a single number representing the number of disjuncts. Otherwise, a line containing the number 1 is optional.
Each disjunct is represented by a matrix of constraints. The first line contains two numbers representing the number of rows and columns, where the number of rows is equal to the number of constraints and the number of columns is equal to two plus the number of variables. The following lines contain the actual rows of the constraint matrix. In each row, the first column indicates whether the constraint is an equality (0) or inequality (1). The final column corresponds to the constant term.
If the set is parametric, then the coefficients of the parameters appear in the last columns before the constant column. The coefficients of any existentially quantified variables appear between those of the set variables and those of the parameters.
PolyLib formatThe extended PolyLib format is nearly identical to the PolyLib format. The only difference is that the line containing the number of rows and columns of a constraint matrix also contains four additional numbers: the number of output dimensions, the number of input dimensions, the number of local dimensions (i.e., the number of existentially quantified variables) and the number of parameters. For sets, the number of ``output'' dimensions is equal to the number of set dimensions, while the number of ``input'' dimensions is zero.
Objects can be read from input using the following functions.
#include <isl/id.h>
__isl_give isl_id *isl_id_read_from_str(isl_ctx *ctx,
const char *str);
__isl_give isl_multi_id *isl_multi_id_read_from_str(
isl_ctx *ctx, const char *str);
#include <isl/val.h>
__isl_give isl_val *isl_val_read_from_str(isl_ctx *ctx,
const char *str);
__isl_give isl_multi_val *isl_multi_val_read_from_str(
isl_ctx *ctx, const char *str);
#include <isl/space.h>
__isl_give isl_space *isl_space_read_from_str(
isl_ctx *ctx, const char *str);
#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_read_from_file(
isl_ctx *ctx, FILE *input);
__isl_give isl_basic_set *isl_basic_set_read_from_str(
isl_ctx *ctx, const char *str);
__isl_give isl_set *isl_set_read_from_file(isl_ctx *ctx,
FILE *input);
__isl_give isl_set *isl_set_read_from_str(isl_ctx *ctx,
const char *str);
#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_read_from_file(
isl_ctx *ctx, FILE *input);
__isl_give isl_basic_map *isl_basic_map_read_from_str(
isl_ctx *ctx, const char *str);
__isl_give isl_map *isl_map_read_from_file(
isl_ctx *ctx, FILE *input);
__isl_give isl_map *isl_map_read_from_str(isl_ctx *ctx,
const char *str);
#include <isl/union_set.h>
__isl_give isl_union_set *isl_union_set_read_from_file(
isl_ctx *ctx, FILE *input);
__isl_give isl_union_set *isl_union_set_read_from_str(
isl_ctx *ctx, const char *str);
#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_read_from_file(
isl_ctx *ctx, FILE *input);
__isl_give isl_union_map *isl_union_map_read_from_str(
isl_ctx *ctx, const char *str);
#include <isl/aff.h>
__isl_give isl_aff *isl_aff_read_from_str(
isl_ctx *ctx, const char *str);
__isl_give isl_multi_aff *isl_multi_aff_read_from_str(
isl_ctx *ctx, const char *str);
__isl_give isl_pw_aff *isl_pw_aff_read_from_str(
isl_ctx *ctx, const char *str);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_read_from_str(
isl_ctx *ctx, const char *str);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_read_from_str(
isl_ctx *ctx, const char *str);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_read_from_str(
isl_ctx *ctx, const char *str);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_read_from_str(
isl_ctx *ctx, const char *str);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_read_from_str(
isl_ctx *ctx, const char *str);
#include <isl/polynomial.h>
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_read_from_str(
isl_ctx *ctx, const char *str);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_read_from_str(
isl_ctx *ctx, const char *str);For sets and relations, the input format is autodetected and may be either the PolyLib format or the isl format.
Before anything can be printed, an isl_printer needs to be created.
__isl_give isl_printer *isl_printer_to_file(isl_ctx *ctx,
FILE *file);
__isl_give isl_printer *isl_printer_to_str(isl_ctx *ctx);
__isl_null isl_printer *isl_printer_free(
__isl_take isl_printer *printer);isl_printer_to_file prints to the given file, while isl_printer_to_str prints to a string that can be extracted using the following function.
#include <isl/printer.h>
__isl_give char *isl_printer_get_str(
__isl_keep isl_printer *printer);The printer can be inspected using the following functions.
FILE *isl_printer_get_file(
__isl_keep isl_printer *printer);
int isl_printer_get_output_format(
__isl_keep isl_printer *p);
int isl_printer_get_yaml_style(__isl_keep isl_printer *p);The behavior of the printer can be modified in various ways
__isl_give isl_printer *isl_printer_set_output_format(
__isl_take isl_printer *p, int output_format);
__isl_give isl_printer *isl_printer_set_indent(
__isl_take isl_printer *p, int indent);
__isl_give isl_printer *isl_printer_set_indent_prefix(
__isl_take isl_printer *p, const char *prefix);
__isl_give isl_printer *isl_printer_indent(
__isl_take isl_printer *p, int indent);
__isl_give isl_printer *isl_printer_set_prefix(
__isl_take isl_printer *p, const char *prefix);
__isl_give isl_printer *isl_printer_set_suffix(
__isl_take isl_printer *p, const char *suffix);
__isl_give isl_printer *isl_printer_set_yaml_style(
__isl_take isl_printer *p, int yaml_style);The output_format may be either ISL_FORMAT_ISL, ISL_FORMAT_OMEGA, ISL_FORMAT_POLYLIB, ISL_FORMAT_EXT_POLYLIB or ISL_FORMAT_LATEX and defaults to ISL_FORMAT_ISL. Each line in the output is prefixed by indent_prefix, indented by indent (set by isl_printer_set_indent) spaces (default: 0), prefixed by prefix and suffixed by suffix. In the PolyLib format output, the coefficients of the existentially quantified variables appear between those of the set variables and those of the parameters. The function isl_printer_indent increases the indentation by the specified amount (which may be negative). The YAML style may be either ISL_YAML_STYLE_BLOCK or ISL_YAML_STYLE_FLOW and when we are printing something in YAML format.
To actually print something, use
#include <isl/printer.h>
__isl_give isl_printer *isl_printer_print_double(
__isl_take isl_printer *p, double d);
#include <isl/val.h>
__isl_give isl_printer *isl_printer_print_val(
__isl_take isl_printer *p, __isl_keep isl_val *v);
__isl_give isl_printer *isl_printer_print_multi_val(
__isl_take isl_printer *p,
__isl_keep isl_multi_val *mv);
#include <isl/set.h>
__isl_give isl_printer *isl_printer_print_basic_set(
__isl_take isl_printer *printer,
__isl_keep isl_basic_set *bset);
__isl_give isl_printer *isl_printer_print_set(
__isl_take isl_printer *printer,
__isl_keep isl_set *set);
#include <isl/map.h>
__isl_give isl_printer *isl_printer_print_basic_map(
__isl_take isl_printer *printer,
__isl_keep isl_basic_map *bmap);
__isl_give isl_printer *isl_printer_print_map(
__isl_take isl_printer *printer,
__isl_keep isl_map *map);
#include <isl/union_set.h>
__isl_give isl_printer *isl_printer_print_union_set(
__isl_take isl_printer *p,
__isl_keep isl_union_set *uset);
#include <isl/union_map.h>
__isl_give isl_printer *isl_printer_print_union_map(
__isl_take isl_printer *p,
__isl_keep isl_union_map *umap);
#include <isl/id.h>
__isl_give isl_printer *isl_printer_print_multi_id(
__isl_take isl_printer *p,
__isl_keep isl_multi_id *mi);
#include <isl/aff.h>
__isl_give isl_printer *isl_printer_print_aff(
__isl_take isl_printer *p, __isl_keep isl_aff *aff);
__isl_give isl_printer *isl_printer_print_multi_aff(
__isl_take isl_printer *p,
__isl_keep isl_multi_aff *maff);
__isl_give isl_printer *isl_printer_print_pw_aff(
__isl_take isl_printer *p,
__isl_keep isl_pw_aff *pwaff);
__isl_give isl_printer *isl_printer_print_pw_multi_aff(
__isl_take isl_printer *p,
__isl_keep isl_pw_multi_aff *pma);
__isl_give isl_printer *isl_printer_print_multi_pw_aff(
__isl_take isl_printer *p,
__isl_keep isl_multi_pw_aff *mpa);
__isl_give isl_printer *isl_printer_print_union_pw_aff(
__isl_take isl_printer *p,
__isl_keep isl_union_pw_aff *upa);
__isl_give isl_printer *isl_printer_print_union_pw_multi_aff(
__isl_take isl_printer *p,
__isl_keep isl_union_pw_multi_aff *upma);
__isl_give isl_printer *
isl_printer_print_multi_union_pw_aff(
__isl_take isl_printer *p,
__isl_keep isl_multi_union_pw_aff *mupa);
#include <isl/polynomial.h>
__isl_give isl_printer *isl_printer_print_qpolynomial(
__isl_take isl_printer *p,
__isl_keep isl_qpolynomial *qp);
__isl_give isl_printer *isl_printer_print_pw_qpolynomial(
__isl_take isl_printer *p,
__isl_keep isl_pw_qpolynomial *pwqp);
__isl_give isl_printer *isl_printer_print_union_pw_qpolynomial(
__isl_take isl_printer *p,
__isl_keep isl_union_pw_qpolynomial *upwqp);
__isl_give isl_printer *
isl_printer_print_pw_qpolynomial_fold(
__isl_take isl_printer *p,
__isl_keep isl_pw_qpolynomial_fold *pwf);
__isl_give isl_printer *
isl_printer_print_union_pw_qpolynomial_fold(
__isl_take isl_printer *p,
__isl_keep isl_union_pw_qpolynomial_fold *upwf);For isl_printer_print_qpolynomial, isl_printer_print_pw_qpolynomial and isl_printer_print_pw_qpolynomial_fold, the output format of the printer needs to be set to either ISL_FORMAT_ISL or ISL_FORMAT_C. For isl_printer_print_union_pw_qpolynomial and isl_printer_print_union_pw_qpolynomial_fold, only ISL_FORMAT_ISL is supported. In case of printing in ISL_FORMAT_C, the user may want to set the names of all dimensions first.
isl also provides limited support for printing YAML documents, just enough for the internal use for printing such documents.
#include <isl/printer.h>
__isl_give isl_printer *isl_printer_yaml_start_mapping(
__isl_take isl_printer *p);
__isl_give isl_printer *isl_printer_yaml_end_mapping(
__isl_take isl_printer *p);
__isl_give isl_printer *isl_printer_yaml_start_sequence(
__isl_take isl_printer *p);
__isl_give isl_printer *isl_printer_yaml_end_sequence(
__isl_take isl_printer *p);
__isl_give isl_printer *isl_printer_yaml_next(
__isl_take isl_printer *p);A document is started by a call to either isl_printer_yaml_start_mapping or isl_printer_yaml_start_sequence. Anything printed to the printer after such a call belong to the first key of the mapping or the first element in the sequence. The function isl_printer_yaml_next moves to the value if we are currently printing a mapping key, the next key if we are printing a value or the next element if we are printing an element in a sequence. Nested mappings and sequences are initiated by the same isl_printer_yaml_start_mapping or isl_printer_yaml_start_sequence. Each call to these functions needs to have a corresponding call to isl_printer_yaml_end_mapping or isl_printer_yaml_end_sequence.
When called on a file printer, the following function flushes the file. When called on a string printer, the buffer is cleared.
__isl_give isl_printer *isl_printer_flush(
__isl_take isl_printer *p);The following functions allow the user to attach notes to a printer in order to keep track of additional state.
#include <isl/printer.h>
isl_bool isl_printer_has_note(__isl_keep isl_printer *p,
__isl_keep isl_id *id);
__isl_give isl_id *isl_printer_get_note(
__isl_keep isl_printer *p, __isl_take isl_id *id);
__isl_give isl_printer *isl_printer_set_note(
__isl_take isl_printer *p,
__isl_take isl_id *id, __isl_take isl_id *note);isl_printer_set_note associates the given note to the given identifier in the printer. isl_printer_get_note retrieves a note associated to an identifier, while isl_printer_has_note checks if there is such a note. isl_printer_get_note fails if the requested note does not exist.
Alternatively, a string representation can be obtained directly using the following functions, which always print in isl format.
#include <isl/id.h>
__isl_give char *isl_id_to_str(
__isl_keep isl_id *id);
__isl_give char *isl_multi_id_to_str(
__isl_keep isl_multi_id *mi);
#include <isl/space.h>
__isl_give char *isl_space_to_str(
__isl_keep isl_space *space);
#include <isl/val.h>
__isl_give char *isl_val_to_str(__isl_keep isl_val *v);
__isl_give char *isl_multi_val_to_str(
__isl_keep isl_multi_val *mv);
#include <isl/set.h>
__isl_give char *isl_basic_set_to_str(
__isl_keep isl_basic_set *bset);
__isl_give char *isl_set_to_str(
__isl_keep isl_set *set);
#include <isl/union_set.h>
__isl_give char *isl_union_set_to_str(
__isl_keep isl_union_set *uset);
#include <isl/map.h>
__isl_give char *isl_basic_map_to_str(
__isl_keep isl_basic_map *bmap);
__isl_give char *isl_map_to_str(
__isl_keep isl_map *map);
#include <isl/union_map.h>
__isl_give char *isl_union_map_to_str(
__isl_keep isl_union_map *umap);
#include <isl/aff.h>
__isl_give char *isl_aff_to_str(__isl_keep isl_aff *aff);
__isl_give char *isl_pw_aff_to_str(
__isl_keep isl_pw_aff *pa);
__isl_give char *isl_multi_aff_to_str(
__isl_keep isl_multi_aff *ma);
__isl_give char *isl_pw_multi_aff_to_str(
__isl_keep isl_pw_multi_aff *pma);
__isl_give char *isl_multi_pw_aff_to_str(
__isl_keep isl_multi_pw_aff *mpa);
__isl_give char *isl_union_pw_aff_to_str(
__isl_keep isl_union_pw_aff *upa);
__isl_give char *isl_union_pw_multi_aff_to_str(
__isl_keep isl_union_pw_multi_aff *upma);
__isl_give char *isl_multi_union_pw_aff_to_str(
__isl_keep isl_multi_union_pw_aff *mupa);
#include <isl/point.h>
__isl_give char *isl_point_to_str(
__isl_keep isl_point *pnt);
#include <isl/polynomial.h>
__isl_give char *isl_pw_qpolynomial_to_str(
__isl_keep isl_pw_qpolynomial *pwqp);
__isl_give char *isl_union_pw_qpolynomial_to_str(
__isl_keep isl_union_pw_qpolynomial *upwqp);Emptiness
The following functions test whether the given set or relation contains any integer points. The ``plain'' variants do not perform any computations, but simply check if the given set or relation is already known to be empty.
#include <isl/set.h>
isl_bool isl_basic_set_plain_is_empty(
__isl_keep isl_basic_set *bset);
isl_bool isl_basic_set_is_empty(
__isl_keep isl_basic_set *bset);
isl_bool isl_set_plain_is_empty(
__isl_keep isl_set *set);
isl_bool isl_set_is_empty(__isl_keep isl_set *set);
#include <isl/union_set.h>
isl_bool isl_union_set_is_empty(
__isl_keep isl_union_set *uset);
#include <isl/map.h>
isl_bool isl_basic_map_plain_is_empty(
__isl_keep isl_basic_map *bmap);
isl_bool isl_basic_map_is_empty(
__isl_keep isl_basic_map *bmap);
isl_bool isl_map_plain_is_empty(
__isl_keep isl_map *map);
isl_bool isl_map_is_empty(__isl_keep isl_map *map);
#include <isl/union_map.h>
isl_bool isl_union_map_plain_is_empty(
__isl_keep isl_union_map *umap);
isl_bool isl_union_map_is_empty(
__isl_keep isl_union_map *umap);
#include <isl/aff.h>
isl_bool isl_union_pw_multi_aff_plain_is_empty(
__isl_keep isl_union_pw_multi_aff *upma);Universality
isl_bool isl_basic_set_plain_is_universe(
__isl_keep isl_basic_set *bset);
isl_bool isl_basic_set_is_universe(
__isl_keep isl_basic_set *bset);
isl_bool isl_basic_map_plain_is_universe(
__isl_keep isl_basic_map *bmap);
isl_bool isl_basic_map_is_universe(
__isl_keep isl_basic_map *bmap);
isl_bool isl_set_plain_is_universe(
__isl_keep isl_set *set);
isl_bool isl_map_plain_is_universe(
__isl_keep isl_map *map);Single-valuedness
#include <isl/set.h>
isl_bool isl_set_is_singleton(__isl_keep isl_set *set);
#include <isl/map.h>
isl_bool isl_basic_map_is_single_valued(
__isl_keep isl_basic_map *bmap);
isl_bool isl_map_plain_is_single_valued(
__isl_keep isl_map *map);
isl_bool isl_map_is_single_valued(__isl_keep isl_map *map);
#include <isl/union_map.h>
isl_bool isl_union_map_is_single_valued(
__isl_keep isl_union_map *umap);Injectivity
isl_bool isl_map_plain_is_injective(
__isl_keep isl_map *map);
isl_bool isl_map_is_injective(
__isl_keep isl_map *map);
isl_bool isl_union_map_plain_is_injective(
__isl_keep isl_union_map *umap);
isl_bool isl_union_map_is_injective(
__isl_keep isl_union_map *umap);Bijectivity
isl_bool isl_map_is_bijective(
__isl_keep isl_map *map);
isl_bool isl_union_map_is_bijective(
__isl_keep isl_union_map *umap);Identity
The following functions test whether the given relation only maps elements to themselves.
#include <isl/map.h>
isl_bool isl_map_is_identity(
__isl_keep isl_map *map);
#include <isl/union_map.h>
isl_bool isl_union_map_is_identity(
__isl_keep isl_union_map *umap);Position
__isl_give isl_val *
isl_basic_map_plain_get_val_if_fixed(
__isl_keep isl_basic_map *bmap,
enum isl_dim_type type, unsigned pos);
__isl_give isl_val *isl_set_plain_get_val_if_fixed(
__isl_keep isl_set *set,
enum isl_dim_type type, unsigned pos);
__isl_give isl_multi_val *
isl_set_get_plain_multi_val_if_fixed(
__isl_keep isl_set *set);
__isl_give isl_val *isl_map_plain_get_val_if_fixed(
__isl_keep isl_map *map,
enum isl_dim_type type, unsigned pos);If the set or relation obviously lies on a hyperplane where the given dimension has a fixed value, then return that value. Otherwise return NaN. isl_set_get_plain_multi_val_if_fixed collects the results over all set dimensions.
Stride
Stride detection is based on heuristics. The strides returned by the functions below are always valid, but there may be larger valid strides that are not detected.
isl_stat isl_set_dim_residue_class_val(
__isl_keep isl_set *set,
int pos, __isl_give isl_val **modulo,
__isl_give isl_val **residue);Check if the values of the given set dimension are equal to a fixed value modulo some integer value. If so, assign the modulo to *modulo and the fixed value to *residue. If the given dimension attains only a single value, then assign 0 to *modulo and the fixed value to *residue. If the dimension does not attain only a single value and if no modulo can be found then assign 1 to *modulo and 1 to *residue.
#include <isl/set.h>
__isl_give isl_stride_info *isl_set_get_stride_info(
__isl_keep isl_set *set, int pos);
__isl_give isl_val *isl_set_get_stride(
__isl_keep isl_set *set, int pos);
__isl_give isl_fixed_box *isl_set_get_lattice_tile(
__isl_keep isl_set *set);
#include <isl/map.h>
__isl_give isl_stride_info *
isl_map_get_range_stride_info(
__isl_keep isl_map *map, int pos);
__isl_give isl_fixed_box *
isl_map_get_range_lattice_tile(
__isl_keep isl_map *map);Check if the values of the given set dimension are equal to some affine expression of the other dimensions (the offset) modulo some integer stride or check if the values of the given output dimensions are equal to some affine expression of the input dimensions (the offset) modulo some integer stride. If no more specific information can be found, then the stride is taken to be one and the offset is taken to be the zero expression. The function isl_set_get_stride performs the same computation as isl_set_get_stride_info but only returns the stride. The function isl_map_get_range_lattice_tile collects the stride information over all output dimensions. In particular, it returns a tile of a rectangular lattice (possibly of size 1 in all directions) containing the output in terms of the parameters and the input dimensions. The size and the offset of this tile correspond to the strides and the offsets of the stride information and can be extracted from the returned isl_fixed_box using the functions described under "Box hull" in "Unary Operations". Note that the isl_fixed_box object returned by isl_map_get_range_lattice_tile is always valid. The function isl_set_get_lattice_tile collects the same stride information over all set dimensions. For the other functions, the stride and offset can be extracted from the returned object using the following functions.
#include <isl/stride_info.h>
__isl_give isl_val *isl_stride_info_get_stride(
__isl_keep isl_stride_info *si);
__isl_give isl_aff *isl_stride_info_get_offset(
__isl_keep isl_stride_info *si);The stride info object can be copied and released using the following functions.
#include <isl/stride_info.h>
__isl_give isl_stride_info *isl_stride_info_copy(
__isl_keep isl_stride_info *si);
__isl_null isl_stride_info *isl_stride_info_free(
__isl_take isl_stride_info *si);Dependence
To check whether a function involves any local variables, i.e., integer divisions, the following functions can be used.
#include <isl/set.h>
isl_bool isl_set_involves_locals(
__isl_keep isl_set *set);
#include <isl/aff.h>
isl_bool isl_aff_involves_locals(
__isl_keep isl_aff *aff);
isl_bool isl_multi_aff_involves_locals(
__isl_keep isl_multi_aff *ma);
isl_bool isl_pw_multi_aff_involves_locals(
__isl_keep isl_pw_multi_aff *pma);
isl_bool isl_union_pw_multi_aff_involves_locals(
__isl_keep isl_union_pw_multi_aff *upma);To check whether the description of a set, relation or function depends on a parameter or one or more given dimensions, the following functions can be used.
#include <isl/constraint.h>
isl_bool isl_constraint_involves_dims(
__isl_keep isl_constraint *constraint,
enum isl_dim_type type, unsigned first, unsigned n);
#include <isl/set.h>
isl_bool isl_basic_set_involves_dims(
__isl_keep isl_basic_set *bset,
enum isl_dim_type type, unsigned first, unsigned n);
isl_bool isl_set_involves_dims(__isl_keep isl_set *set,
enum isl_dim_type type, unsigned first, unsigned n);
#include <isl/map.h>
isl_bool isl_basic_map_involves_dims(
__isl_keep isl_basic_map *bmap,
enum isl_dim_type type, unsigned first, unsigned n);
isl_bool isl_map_involves_dims(__isl_keep isl_map *map,
enum isl_dim_type type, unsigned first, unsigned n);
#include <isl/union_map.h>
isl_bool isl_union_map_involves_dims(
__isl_keep isl_union_map *umap,
enum isl_dim_type type, unsigned first, unsigned n);
#include <isl/aff.h>
isl_bool isl_aff_involves_dims(__isl_keep isl_aff *aff,
enum isl_dim_type type, unsigned first, unsigned n);
isl_bool isl_pw_aff_involves_param_id(
__isl_keep isl_pw_aff *pa,
__isl_keep isl_id *id);
isl_bool isl_pw_aff_involves_dims(
__isl_keep isl_pw_aff *pwaff,
enum isl_dim_type type, unsigned first, unsigned n);
isl_bool isl_multi_aff_involves_dims(
__isl_keep isl_multi_aff *ma,
enum isl_dim_type type, unsigned first, unsigned n);
isl_bool isl_pw_multi_aff_involves_param_id(
__isl_keep isl_pw_multi_aff *pma,
__isl_keep isl_id *id);
isl_bool isl_pw_multi_aff_involves_dims(
__isl_keep isl_pw_multi_aff *pma,
enum isl_dim_type type, unsigned first, unsigned n);
isl_bool isl_multi_pw_aff_involves_dims(
__isl_keep isl_multi_pw_aff *mpa,
enum isl_dim_type type, unsigned first, unsigned n);
isl_bool isl_multi_pw_aff_involves_param_id(
__isl_keep isl_multi_pw_aff *mpa,
__isl_keep isl_id *id);
isl_bool isl_multi_pw_aff_involves_param_id_list(
__isl_keep isl_multi_pw_aff *mpa,
__isl_keep isl_id_list *list);
#include <isl/polynomial.h>
isl_bool isl_qpolynomial_involves_dims(
__isl_keep isl_qpolynomial *qp,
enum isl_dim_type type, unsigned first, unsigned n);
isl_bool isl_pw_qpolynomial_involves_param_id(
__isl_keep isl_pw_qpolynomial *pwqp,
__isl_keep isl_id *id);
isl_bool isl_pw_qpolynomial_fold_involves_param_id(
__isl_keep isl_pw_qpolynomial_fold *pwf,
__isl_keep isl_id *id);Similarly, the following functions can be used to check whether a given dimension is involved in any lower or upper bound.
#include <isl/set.h>
isl_bool isl_set_dim_has_any_lower_bound(
__isl_keep isl_set *set,
enum isl_dim_type type, unsigned pos);
isl_bool isl_set_dim_has_any_upper_bound(
__isl_keep isl_set *set,
enum isl_dim_type type, unsigned pos);Note that these functions return true even if there is a bound on the dimension on only some of the basic sets of set. To check if they have a bound for all of the basic sets in set, use the following functions instead.
#include <isl/set.h>
isl_bool isl_set_dim_has_lower_bound(
__isl_keep isl_set *set,
enum isl_dim_type type, unsigned pos);
isl_bool isl_set_dim_has_upper_bound(
__isl_keep isl_set *set,
enum isl_dim_type type, unsigned pos);Space
To check whether a set is a parameter domain, use this function:
isl_bool isl_set_is_params(__isl_keep isl_set *set);
isl_bool isl_union_set_is_params(
__isl_keep isl_union_set *uset);Wrapping
The following functions check whether the space of the given (basic) set or relation domain and/or range is a wrapped relation.
#include <isl/space.h>
isl_bool isl_space_is_wrapping(
__isl_keep isl_space *space);
isl_bool isl_space_domain_is_wrapping(
__isl_keep isl_space *space);
isl_bool isl_space_range_is_wrapping(
__isl_keep isl_space *space);
isl_bool isl_space_is_product(
__isl_keep isl_space *space);
#include <isl/set.h>
isl_bool isl_basic_set_is_wrapping(
__isl_keep isl_basic_set *bset);
isl_bool isl_set_is_wrapping(__isl_keep isl_set *set);
#include <isl/map.h>
isl_bool isl_map_domain_is_wrapping(
__isl_keep isl_map *map);
isl_bool isl_map_range_is_wrapping(
__isl_keep isl_map *map);
isl_bool isl_map_is_product(__isl_keep isl_map *map);
#include <isl/id.h>
isl_bool isl_multi_id_range_is_wrapping(
__isl_keep isl_multi_id *mi);
#include <isl/val.h>
isl_bool isl_multi_val_range_is_wrapping(
__isl_keep isl_multi_val *mv);
#include <isl/aff.h>
isl_bool isl_multi_aff_range_is_wrapping(
__isl_keep isl_multi_aff *ma);
isl_bool isl_multi_pw_aff_range_is_wrapping(
__isl_keep isl_multi_pw_aff *mpa);
isl_bool isl_multi_union_pw_aff_range_is_wrapping(
__isl_keep isl_multi_union_pw_aff *mupa);The input to isl_space_is_wrapping should be the space of a set, while that of isl_space_domain_is_wrapping and isl_space_range_is_wrapping should be the space of a relation. The input to isl_space_is_product can be either the space of a set or that of a binary relation. In case the input is the space of a binary relation, it checks whether both domain and range are wrapping.
Internal Product
isl_bool isl_basic_map_can_zip(
__isl_keep isl_basic_map *bmap);
isl_bool isl_map_can_zip(__isl_keep isl_map *map);Check whether the product of domain and range of the given relation can be computed, i.e., whether both domain and range are nested relations.
Currying
#include <isl/space.h>
isl_bool isl_space_can_curry(
__isl_keep isl_space *space);
#include <isl/map.h>
isl_bool isl_basic_map_can_curry(
__isl_keep isl_basic_map *bmap);
isl_bool isl_map_can_curry(__isl_keep isl_map *map);Check whether the domain of the (basic) relation is a wrapped relation.
#include <isl/space.h>
isl_bool isl_space_can_uncurry(
__isl_keep isl_space *space);
#include <isl/map.h>
isl_bool isl_basic_map_can_uncurry(
__isl_keep isl_basic_map *bmap);
isl_bool isl_map_can_uncurry(__isl_keep isl_map *map);Check whether the range of the (basic) relation is a wrapped relation.
#include <isl/space.h>
isl_bool isl_space_can_range_curry(
__isl_keep isl_space *space);
#include <isl/map.h>
isl_bool isl_map_can_range_curry(
__isl_keep isl_map *map);Check whether the domain of the relation wrapped in the range of the input is itself a wrapped relation.
Special Values
#include <isl/aff.h>
isl_bool isl_aff_is_cst(__isl_keep isl_aff *aff);
isl_bool isl_pw_aff_is_cst(__isl_keep isl_pw_aff *pwaff);
isl_bool isl_multi_pw_aff_is_cst(
__isl_keep isl_multi_pw_aff *mpa);Check whether the given expression is a constant.
#include <isl/val.h>
isl_bool isl_multi_val_involves_nan(
__isl_keep isl_multi_val *mv);
#include <isl/aff.h>
isl_bool isl_aff_is_nan(__isl_keep isl_aff *aff);
isl_bool isl_multi_aff_involves_nan(
__isl_keep isl_multi_aff *ma);
isl_bool isl_pw_aff_involves_nan(
__isl_keep isl_pw_aff *pa);
isl_bool isl_pw_multi_aff_involves_nan(
__isl_keep isl_pw_multi_aff *pma);
isl_bool isl_multi_pw_aff_involves_nan(
__isl_keep isl_multi_pw_aff *mpa);
isl_bool isl_union_pw_aff_involves_nan(
__isl_keep isl_union_pw_aff *upa);
isl_bool isl_union_pw_multi_aff_involves_nan(
__isl_keep isl_union_pw_multi_aff *upma);
isl_bool isl_multi_union_pw_aff_involves_nan(
__isl_keep isl_multi_union_pw_aff *mupa);
#include <isl/polynomial.h>
isl_bool isl_qpolynomial_is_nan(
__isl_keep isl_qpolynomial *qp);
isl_bool isl_qpolynomial_fold_is_nan(
__isl_keep isl_qpolynomial_fold *fold);
isl_bool isl_pw_qpolynomial_involves_nan(
__isl_keep isl_pw_qpolynomial *pwqp);
isl_bool isl_pw_qpolynomial_fold_involves_nan(
__isl_keep isl_pw_qpolynomial_fold *pwf);
isl_bool isl_union_pw_qpolynomial_involves_nan(
__isl_keep isl_union_pw_qpolynomial *upwqp);
isl_bool isl_union_pw_qpolynomial_fold_involves_nan(
__isl_keep isl_union_pw_qpolynomial_fold *upwf);Check whether the given expression is equal to or involves NaN.
#include <isl/val.h>
isl_bool isl_multi_val_is_zero(
__isl_keep isl_multi_val *mv);Check whether the multiple value is zero.
#include <isl/aff.h>
isl_bool isl_aff_plain_is_zero(
__isl_keep isl_aff *aff);Check whether the affine expression is obviously zero.
Equality
The following functions check whether two objects represent the same set, relation or function. The plain variants only return true if the objects are obviously the same. That is, they may return false even if the objects are the same, but they will never return true if the objects are not the same.
#include <isl/set.h>
isl_bool isl_basic_set_plain_is_equal(
__isl_keep isl_basic_set *bset1,
__isl_keep isl_basic_set *bset2);
isl_bool isl_basic_set_is_equal(
__isl_keep isl_basic_set *bset1,
__isl_keep isl_basic_set *bset2);
isl_bool isl_set_plain_is_equal(
__isl_keep isl_set *set1,
__isl_keep isl_set *set2);
isl_bool isl_set_is_equal(__isl_keep isl_set *set1,
__isl_keep isl_set *set2);
#include <isl/map.h>
isl_bool isl_basic_map_is_equal(
__isl_keep isl_basic_map *bmap1,
__isl_keep isl_basic_map *bmap2);
isl_bool isl_map_is_equal(__isl_keep isl_map *map1,
__isl_keep isl_map *map2);
isl_bool isl_map_plain_is_equal(
__isl_keep isl_map *map1,
__isl_keep isl_map *map2);
#include <isl/union_set.h>
isl_bool isl_union_set_is_equal(
__isl_keep isl_union_set *uset1,
__isl_keep isl_union_set *uset2);
#include <isl/union_map.h>
isl_bool isl_union_map_is_equal(
__isl_keep isl_union_map *umap1,
__isl_keep isl_union_map *umap2);
#include <isl/id.h>
isl_bool isl_multi_id_plain_is_equal(
__isl_keep isl_multi_id *mi1,
__isl_keep isl_multi_id *mi2);
#include <isl/val.h>
isl_bool isl_multi_val_plain_is_equal(
__isl_keep isl_multi_val *mv1,
__isl_keep isl_multi_val *mv2);
#include <isl/aff.h>
isl_bool isl_aff_plain_is_equal(
__isl_keep isl_aff *aff1,
__isl_keep isl_aff *aff2);
isl_bool isl_multi_aff_plain_is_equal(
__isl_keep isl_multi_aff *maff1,
__isl_keep isl_multi_aff *maff2);
isl_bool isl_pw_aff_plain_is_equal(
__isl_keep isl_pw_aff *pwaff1,
__isl_keep isl_pw_aff *pwaff2);
isl_bool isl_pw_aff_is_equal(
__isl_keep isl_pw_aff *pa1,
__isl_keep isl_pw_aff *pa2);
isl_bool isl_pw_multi_aff_plain_is_equal(
__isl_keep isl_pw_multi_aff *pma1,
__isl_keep isl_pw_multi_aff *pma2);
isl_bool isl_pw_multi_aff_is_equal(
__isl_keep isl_pw_multi_aff *pma1,
__isl_keep isl_pw_multi_aff *pma2);
isl_bool isl_multi_pw_aff_plain_is_equal(
__isl_keep isl_multi_pw_aff *mpa1,
__isl_keep isl_multi_pw_aff *mpa2);
isl_bool isl_multi_pw_aff_is_equal(
__isl_keep isl_multi_pw_aff *mpa1,
__isl_keep isl_multi_pw_aff *mpa2);
isl_bool isl_union_pw_aff_plain_is_equal(
__isl_keep isl_union_pw_aff *upa1,
__isl_keep isl_union_pw_aff *upa2);
isl_bool isl_union_pw_multi_aff_plain_is_equal(
__isl_keep isl_union_pw_multi_aff *upma1,
__isl_keep isl_union_pw_multi_aff *upma2);
isl_bool isl_multi_union_pw_aff_plain_is_equal(
__isl_keep isl_multi_union_pw_aff *mupa1,
__isl_keep isl_multi_union_pw_aff *mupa2);
#include <isl/polynomial.h>
isl_bool isl_union_pw_qpolynomial_plain_is_equal(
__isl_keep isl_union_pw_qpolynomial *upwqp1,
__isl_keep isl_union_pw_qpolynomial *upwqp2);
isl_bool isl_union_pw_qpolynomial_fold_plain_is_equal(
__isl_keep isl_union_pw_qpolynomial_fold *upwf1,
__isl_keep isl_union_pw_qpolynomial_fold *upwf2);Disjointness
#include <isl/set.h>
isl_bool isl_basic_set_is_disjoint(
__isl_keep isl_basic_set *bset1,
__isl_keep isl_basic_set *bset2);
isl_bool isl_set_plain_is_disjoint(
__isl_keep isl_set *set1,
__isl_keep isl_set *set2);
isl_bool isl_set_is_disjoint(__isl_keep isl_set *set1,
__isl_keep isl_set *set2);
#include <isl/map.h>
isl_bool isl_basic_map_is_disjoint(
__isl_keep isl_basic_map *bmap1,
__isl_keep isl_basic_map *bmap2);
isl_bool isl_map_is_disjoint(__isl_keep isl_map *map1,
__isl_keep isl_map *map2);
#include <isl/union_set.h>
isl_bool isl_union_set_is_disjoint(
__isl_keep isl_union_set *uset1,
__isl_keep isl_union_set *uset2);
#include <isl/union_map.h>
isl_bool isl_union_map_is_disjoint(
__isl_keep isl_union_map *umap1,
__isl_keep isl_union_map *umap2);Subset
isl_bool isl_basic_set_is_subset(
__isl_keep isl_basic_set *bset1,
__isl_keep isl_basic_set *bset2);
isl_bool isl_set_is_subset(__isl_keep isl_set *set1,
__isl_keep isl_set *set2);
isl_bool isl_set_is_strict_subset(
__isl_keep isl_set *set1,
__isl_keep isl_set *set2);
isl_bool isl_union_set_is_subset(
__isl_keep isl_union_set *uset1,
__isl_keep isl_union_set *uset2);
isl_bool isl_union_set_is_strict_subset(
__isl_keep isl_union_set *uset1,
__isl_keep isl_union_set *uset2);
isl_bool isl_basic_map_is_subset(
__isl_keep isl_basic_map *bmap1,
__isl_keep isl_basic_map *bmap2);
isl_bool isl_basic_map_is_strict_subset(
__isl_keep isl_basic_map *bmap1,
__isl_keep isl_basic_map *bmap2);
isl_bool isl_map_is_subset(
__isl_keep isl_map *map1,
__isl_keep isl_map *map2);
isl_bool isl_map_is_strict_subset(
__isl_keep isl_map *map1,
__isl_keep isl_map *map2);
isl_bool isl_union_map_is_subset(
__isl_keep isl_union_map *umap1,
__isl_keep isl_union_map *umap2);
isl_bool isl_union_map_is_strict_subset(
__isl_keep isl_union_map *umap1,
__isl_keep isl_union_map *umap2);Check whether the first argument is a (strict) subset of the second argument.
Order
Every comparison function returns a negative value if the first argument is considered smaller than the second, a positive value if the first argument is considered greater and zero if the two constraints are considered the same by the comparison criterion.
#include <isl/constraint.h>
int isl_constraint_plain_cmp(
__isl_keep isl_constraint *c1,
__isl_keep isl_constraint *c2);This function is useful for sorting isl_constraints. The order depends on the internal representation of the inputs. The order is fixed over different calls to the function (assuming the internal representation of the inputs has not changed), but may change over different versions of isl.
#include <isl/constraint.h>
int isl_constraint_cmp_last_non_zero(
__isl_keep isl_constraint *c1,
__isl_keep isl_constraint *c2);This function can be used to sort constraints that live in the same local space. Constraints that involve ``earlier'' dimensions or that have a smaller coefficient for the shared latest dimension are considered smaller than other constraints. This function only defines a partial order.
#include <isl/set.h>
int isl_set_plain_cmp(__isl_keep isl_set *set1,
__isl_keep isl_set *set2);This function is useful for sorting isl_sets. The order depends on the internal representation of the inputs. The order is fixed over different calls to the function (assuming the internal representation of the inputs has not changed), but may change over different versions of isl.
#include <isl/aff.h>
int isl_multi_aff_plain_cmp(
__isl_keep isl_multi_aff *ma1,
__isl_keep isl_multi_aff *ma2);
int isl_pw_aff_plain_cmp(__isl_keep isl_pw_aff *pa1,
__isl_keep isl_pw_aff *pa2);The functions isl_multi_aff_plain_cmp and isl_pw_aff_plain_cmp can be used to sort isl_multi_affs and isl_pw_affs. The order is not strictly defined. The current order sorts expressions that only involve earlier dimensions before those that involve later dimensions.
Complement
__isl_give isl_set *isl_set_complement(
__isl_take isl_set *set);
__isl_give isl_map *isl_map_complement(
__isl_take isl_map *map);Inverse map
#include <isl/space.h>
__isl_give isl_space *isl_space_reverse(
__isl_take isl_space *space);
__isl_give isl_space *isl_space_wrapped_reverse(
__isl_take isl_space *space);
__isl_give isl_space *isl_space_domain_reverse(
__isl_take isl_space *space);
__isl_give isl_space *isl_space_range_reverse(
__isl_take isl_space *space);
#include <isl/aff.h>
__isl_give isl_aff *isl_aff_domain_reverse(
__isl_take isl_aff *aff);
__isl_give isl_multi_aff *
isl_multi_aff_domain_reverse(
__isl_take isl_multi_aff *ma);
__isl_give isl_pw_aff *isl_pw_aff_domain_reverse(
__isl_take isl_pw_aff *pa);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_domain_reverse(
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_domain_reverse(
__isl_take isl_multi_pw_aff *mpa);
#include <isl/set.h>
__isl_give isl_set *isl_set_wrapped_reverse(
__isl_take isl_set *set);
#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_reverse(
__isl_take isl_basic_map *bmap);
__isl_give isl_map *isl_map_reverse(
__isl_take isl_map *map);
__isl_give isl_map *isl_map_domain_reverse(
__isl_take isl_map *map);
__isl_give isl_map *isl_map_range_reverse(
__isl_take isl_map *map);
#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_reverse(
__isl_take isl_union_map *umap);
__isl_give isl_union_map *isl_union_map_domain_reverse(
__isl_take isl_union_map *umap);
__isl_give isl_union_map *isl_union_map_range_reverse(
__isl_take isl_union_map *umap);
#include <isl/polynomial.h>
__isl_give isl_qpolynomial *
isl_qpolynomial_domain_reverse(
__isl_take isl_qpolynomial *qp);
__isl_give isl_pw_qpolynomial *
isl_pw_qpolynomial_domain_reverse(
__isl_take isl_pw_qpolynomial *pwqp);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_domain_reverse(
__isl_take isl_union_pw_qpolynomial *upwqp);The function isl_space_range_reverse reverses the relation that is embedded in the range of the input map space. The identifier of the range, if any, is only preserved if this embedded relation has identical input and output tuples. Similarly for isl_space_domain_reverse. Along the same lines, isl_space_wrapped_reverse reverses the relation that is embedded in a set space.
Tuple binding
The following function binds a tuple to a sequence of parameter identifiers, equating the tuple dimensions to the parameters with those identifiers and subsequently projecting out the tuple. If the original object did not reference any such parameters, then this means that the tuple dimensions are reinterpreted as parameters. The space of tuple needs to match that of the bound tuple.
#include <isl/set.h>
__isl_give isl_set *isl_set_bind(
__isl_take isl_set *set,
__isl_take isl_multi_id *tuple);
#include <isl/map.h>
__isl_give isl_set *isl_map_bind_domain(
__isl_take isl_map *map,
__isl_take isl_multi_id *tuple);
__isl_give isl_set *isl_map_bind_range(
__isl_take isl_map *map,
__isl_take isl_multi_id *tuple);
#include <isl/union_map.h>
__isl_give isl_union_set *isl_union_map_bind_range(
__isl_take isl_union_map *umap,
__isl_take isl_multi_id *tuple);
#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_bind_domain(
__isl_take isl_pw_aff *pa,
__isl_take isl_multi_id *tuple);
__isl_give isl_multi_aff *isl_multi_aff_bind_domain(
__isl_take isl_multi_aff *ma,
__isl_take isl_multi_id *tuple);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_bind_domain(
__isl_take isl_pw_multi_aff *pma,
__isl_take isl_multi_id *tuple);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_bind_domain(
__isl_take isl_multi_pw_aff *mpa,
__isl_take isl_multi_id *tuple);
__isl_give isl_pw_aff *
isl_pw_aff_bind_domain_wrapped_domain(
__isl_take isl_pw_aff *pa,
__isl_take isl_multi_id *tuple);
__isl_give isl_multi_aff *
isl_multi_aff_bind_domain_wrapped_domain(
__isl_take isl_multi_aff *ma,
__isl_take isl_multi_id *tuple);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_bind_domain_wrapped_domain(
__isl_take isl_pw_multi_aff *pma,
__isl_take isl_multi_id *tuple);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_bind_domain_wrapped_domain(
__isl_take isl_multi_pw_aff *mpa,
__isl_take isl_multi_id *tuple);
__isl_give isl_basic_set *isl_aff_bind_id(
__isl_take isl_aff *aff,
__isl_take isl_id *id);
__isl_give isl_set *isl_pw_aff_bind_id(
__isl_take isl_pw_aff *pa,
__isl_take isl_id *id);
__isl_give isl_basic_set *isl_multi_aff_bind(
__isl_take isl_multi_aff *ma,
__isl_take isl_multi_id *tuple);
__isl_give isl_set *isl_multi_pw_aff_bind(
__isl_take isl_multi_pw_aff *mpa,
__isl_take isl_multi_id *tuple);
__isl_give isl_union_set *isl_union_pw_aff_bind_id(
__isl_take isl_union_pw_aff *upa,
__isl_take isl_id *id);
__isl_give isl_union_set *
isl_multi_union_pw_aff_bind(
__isl_take isl_multi_union_pw_aff *mupa,
__isl_take isl_multi_id *tuple);Projecting out the domain of the wrapped relation in the domain of a function leaves the range of that wrapped relation in the domain of the resulting function. In the case of isl_aff_bind_id, isl_pw_aff_bind_id, isl_multi_aff_bind, isl_multi_pw_aff_bind, isl_union_pw_aff_bind_id and isl_multi_union_pw_aff_bind, the parameters are bound to the function values and the result lives in the domain of the input function.
Projection
#include <isl/space.h>
__isl_give isl_space *isl_space_domain(
__isl_take isl_space *space);
__isl_give isl_space *isl_space_range(
__isl_take isl_space *space);
__isl_give isl_space *isl_space_params(
__isl_take isl_space *space);
__isl_give isl_space *
isl_space_domain_wrapped_domain(
__isl_take isl_space *space);
__isl_give isl_space *
isl_space_domain_wrapped_range(
__isl_take isl_space *space);
__isl_give isl_space *
isl_space_range_wrapped_domain(
__isl_take isl_space *space);
__isl_give isl_space *
isl_space_range_wrapped_range(
__isl_take isl_space *space);
#include <isl/local_space.h>
__isl_give isl_local_space *isl_local_space_domain(
__isl_take isl_local_space *ls);
__isl_give isl_local_space *isl_local_space_range(
__isl_take isl_local_space *ls);
#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_project_out(
__isl_take isl_basic_set *bset,
enum isl_dim_type type, unsigned first, unsigned n);
__isl_give isl_set *isl_set_project_out_param_id(
__isl_take isl_set *set,
__isl_take isl_id *id);
__isl_give isl_set *
isl_set_project_out_param_id_list(
__isl_take isl_set *set,
__isl_take isl_id_list *list);
__isl_give isl_set *isl_set_project_out(__isl_take isl_set *set,
enum isl_dim_type type, unsigned first, unsigned n);
__isl_give isl_set *isl_set_project_out_all_params(
__isl_take isl_set *set);
__isl_give isl_map *isl_set_project_onto_map(
__isl_take isl_set *set,
enum isl_dim_type type, unsigned first,
unsigned n);
__isl_give isl_basic_set *isl_basic_set_params(
__isl_take isl_basic_set *bset);
__isl_give isl_set *isl_set_params(__isl_take isl_set *set);The function isl_space_domain_wrapped_domain returns the domain of the binary relation wrapped inside the domain of the input. The function isl_set_project_onto_map returns a relation that projects the input set onto the given set dimensions.
#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_project_out(
__isl_take isl_basic_map *bmap,
enum isl_dim_type type, unsigned first, unsigned n);
__isl_give isl_map *isl_map_project_out_param_id(
__isl_take isl_map *map,
__isl_take isl_id *id);
__isl_give isl_map *isl_map_project_out_param_id_list(
__isl_take isl_map *map,
__isl_take isl_id_list *list);
__isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
enum isl_dim_type type, unsigned first, unsigned n);
__isl_give isl_map *isl_map_project_out_all_params(
__isl_take isl_map *map);
__isl_give isl_basic_set *isl_basic_map_domain(
__isl_take isl_basic_map *bmap);
__isl_give isl_basic_set *isl_basic_map_range(
__isl_take isl_basic_map *bmap);
__isl_give isl_set *isl_map_params(__isl_take isl_map *map);
__isl_give isl_set *isl_map_domain(
__isl_take isl_map *bmap);
__isl_give isl_set *isl_map_range(
__isl_take isl_map *map);
#include <isl/union_set.h>
__isl_give isl_union_set *isl_union_set_project_out(
__isl_take isl_union_set *uset,
enum isl_dim_type type,
unsigned first, unsigned n);
__isl_give isl_union_set *
isl_union_set_project_out_all_params(
__isl_take isl_union_set *uset);
__isl_give isl_set *isl_union_set_params(
__isl_take isl_union_set *uset);The function isl_union_set_project_out can only project out parameters.
#include <isl/union_map.h>
__isl_give isl_union_map *
isl_union_map_project_out_param_id(
__isl_take isl_union_map *umap,
__isl_take isl_id *id);
__isl_give isl_union_map *
isl_union_map_project_out_param_id_list(
__isl_take isl_union_map *umap,
__isl_take isl_id_list *list);
__isl_give isl_union_map *isl_union_map_project_out(
__isl_take isl_union_map *umap,
enum isl_dim_type type, unsigned first, unsigned n);
__isl_give isl_union_map *
isl_union_map_project_out_all_params(
__isl_take isl_union_map *umap);
__isl_give isl_set *isl_union_map_params(
__isl_take isl_union_map *umap);
__isl_give isl_union_set *isl_union_map_domain(
__isl_take isl_union_map *umap);
__isl_give isl_union_set *isl_union_map_range(
__isl_take isl_union_map *umap);The function isl_union_map_project_out can only project out parameters.
#include <isl/aff.h>
__isl_give isl_aff *isl_aff_project_domain_on_params(
__isl_take isl_aff *aff);
__isl_give isl_multi_aff *
isl_multi_aff_project_domain_on_params(
__isl_take isl_multi_aff *ma);
__isl_give isl_pw_aff *
isl_pw_aff_project_domain_on_params(
__isl_take isl_pw_aff *pa);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_project_domain_on_params(
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_project_domain_on_params(
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_set *isl_pw_aff_domain(
__isl_take isl_pw_aff *pwaff);
__isl_give isl_set *isl_pw_multi_aff_domain(
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_set *isl_multi_pw_aff_domain(
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_union_set *isl_union_pw_aff_domain(
__isl_take isl_union_pw_aff *upa);
__isl_give isl_union_set *isl_union_pw_multi_aff_domain(
__isl_take isl_union_pw_multi_aff *upma);
__isl_give isl_union_set *
isl_multi_union_pw_aff_domain(
__isl_take isl_multi_union_pw_aff *mupa);
__isl_give isl_set *isl_pw_aff_params(
__isl_take isl_pw_aff *pwa);If no explicit domain was set on a zero-dimensional input to isl_multi_union_pw_aff_domain, then this function will return a parameter set.
#include <isl/polynomial.h>
__isl_give isl_qpolynomial *
isl_qpolynomial_project_domain_on_params(
__isl_take isl_qpolynomial *qp);
__isl_give isl_pw_qpolynomial *
isl_pw_qpolynomial_project_domain_on_params(
__isl_take isl_pw_qpolynomial *pwqp);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_project_domain_on_params(
__isl_take isl_pw_qpolynomial_fold *pwf);
__isl_give isl_set *isl_pw_qpolynomial_domain(
__isl_take isl_pw_qpolynomial *pwqp);
__isl_give isl_union_set *isl_union_pw_qpolynomial_fold_domain(
__isl_take isl_union_pw_qpolynomial_fold *upwf);
__isl_give isl_union_set *isl_union_pw_qpolynomial_domain(
__isl_take isl_union_pw_qpolynomial *upwqp);
#include <isl/space.h>
__isl_give isl_space *isl_space_domain_map(
__isl_take isl_space *space);
__isl_give isl_space *isl_space_range_map(
__isl_take isl_space *space);
#include <isl/map.h>
__isl_give isl_map *isl_set_wrapped_domain_map(
__isl_take isl_set *set);
__isl_give isl_basic_map *isl_basic_map_domain_map(
__isl_take isl_basic_map *bmap);
__isl_give isl_basic_map *isl_basic_map_range_map(
__isl_take isl_basic_map *bmap);
__isl_give isl_map *isl_map_domain_map(__isl_take isl_map *map);
__isl_give isl_map *isl_map_range_map(__isl_take isl_map *map);
#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_domain_map(
__isl_take isl_union_map *umap);
__isl_give isl_union_pw_multi_aff *
isl_union_map_domain_map_union_pw_multi_aff(
__isl_take isl_union_map *umap);
__isl_give isl_union_map *isl_union_map_range_map(
__isl_take isl_union_map *umap);
__isl_give isl_union_map *
isl_union_set_wrapped_domain_map(
__isl_take isl_union_set *uset);The functions above construct a (basic, regular or union) relation that maps (a wrapped version of) the input relation to its domain or range. isl_set_wrapped_domain_map maps the input set to the domain of its wrapped relation.
Elimination
__isl_give isl_basic_set *isl_basic_set_eliminate(
__isl_take isl_basic_set *bset,
enum isl_dim_type type,
unsigned first, unsigned n);
__isl_give isl_set *isl_set_eliminate(
__isl_take isl_set *set, enum isl_dim_type type,
unsigned first, unsigned n);
__isl_give isl_basic_map *isl_basic_map_eliminate(
__isl_take isl_basic_map *bmap,
enum isl_dim_type type,
unsigned first, unsigned n);
__isl_give isl_map *isl_map_eliminate(
__isl_take isl_map *map, enum isl_dim_type type,
unsigned first, unsigned n);Eliminate the coefficients for the given dimensions from the constraints, without removing the dimensions.
Constructing a set from a parameter domain
A set space of a given dimension and with an optional name can be created from a parameter space using the following functions.
#include <isl/space.h>
__isl_give isl_space *isl_space_add_unnamed_tuple_ui(
__isl_take isl_space *space, unsigned dim);
__isl_give isl_space *
isl_space_add_named_tuple_id_ui(
__isl_take isl_space *space,
__isl_take isl_id *tuple_id, unsigned dim);A set with a given tuple can be created from a parameter domain using the following function.
#include <isl/set.h>
__isl_give isl_set *isl_set_unbind_params(
__isl_take isl_set *set,
__isl_take isl_multi_id *tuple);Any parameters with identifiers in tuple are reinterpreted as the corresponding set dimensions.
A zero-dimensional (local) space or (basic) set can be constructed on a given parameter domain using the following functions.
#include <isl/space.h>
__isl_give isl_space *isl_space_set_from_params(
__isl_take isl_space *space);
#include <isl/local_space.h>
__isl_give isl_local_space *
isl_local_space_set_from_params(
__isl_take isl_local_space *ls);
#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_from_params(
__isl_take isl_basic_set *bset);
__isl_give isl_set *isl_set_from_params(
__isl_take isl_set *set);Constructing a relation from one or two sets
A map space with a range of a given dimension and with an optional name can be created from a domain space using the functions isl_space_add_unnamed_tuple_ui and isl_space_add_named_tuple_id_ui described above.
A relation with a given domain tuple can be created from a set that will become the range of the relation using the following function.
#include <isl/set.h>
__isl_give isl_map *
isl_set_unbind_params_insert_domain(
__isl_take isl_set *set,
__isl_take isl_multi_id *domain);Any parameters with identifiers in domain are reinterpreted as the corresponding input dimensions.
Similarly, a function defined over a parameter domain can be converted into one defined over a set domain using the following functions.
#include <isl/aff.h>
__isl_give isl_aff *
isl_aff_unbind_params_insert_domain(
__isl_take isl_aff *aff,
__isl_take isl_multi_id *domain);
__isl_give isl_multi_aff *
isl_multi_aff_unbind_params_insert_domain(
__isl_take isl_multi_aff *ma,
__isl_take isl_multi_id *domain);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_unbind_params_insert_domain(
__isl_take isl_multi_pw_aff *mpa,
__isl_take isl_multi_id *domain);Again, any parameters with identifiers in domain are reinterpreted as the corresponding input dimensions.
Create a relation with the given set(s) as domain and/or range. If only the domain or the range is specified, then the range or domain of the created relation is a zero-dimensional flat anonymous space. If the case of isl_space_map_from_set, the input space specifies both the domain and the range of the result.
#include <isl/space.h>
__isl_give isl_space *isl_space_from_domain(
__isl_take isl_space *space);
__isl_give isl_space *isl_space_from_range(
__isl_take isl_space *space);
__isl_give isl_space *isl_space_map_from_set(
__isl_take isl_space *space);
__isl_give isl_space *isl_space_map_from_domain_and_range(
__isl_take isl_space *domain,
__isl_take isl_space *range);
#include <isl/local_space.h>
__isl_give isl_local_space *isl_local_space_from_domain(
__isl_take isl_local_space *ls);
#include <isl/map.h>
__isl_give isl_map *isl_set_insert_domain(
__isl_take isl_set *set,
__isl_take isl_space *domain);
__isl_give isl_map *isl_map_from_domain(
__isl_take isl_set *set);
__isl_give isl_map *isl_map_from_range(
__isl_take isl_set *set);
#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_from_domain(
__isl_take isl_union_set *uset);
__isl_give isl_union_map *isl_union_map_from_range(
__isl_take isl_union_set *uset);
__isl_give isl_union_map *
isl_union_map_from_domain_and_range(
__isl_take isl_union_set *domain,
__isl_take isl_union_set *range);
#include <isl/id.h>
__isl_give isl_multi_id *isl_multi_id_from_range(
__isl_take isl_multi_id *mi);
#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_from_range(
__isl_take isl_multi_val *mv);
#include <isl/aff.h>
__isl_give isl_multi_aff *
isl_multi_aff_insert_domain(
__isl_take isl_multi_aff *ma,
__isl_take isl_space *domain);
__isl_give isl_pw_aff *isl_pw_aff_insert_domain(
__isl_take isl_pw_aff *pa,
__isl_take isl_space *domain);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_insert_domain(
__isl_take isl_pw_multi_aff *pma,
__isl_take isl_space *domain);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_insert_domain(
__isl_take isl_multi_pw_aff *mpa,
__isl_take isl_space *domain);
__isl_give isl_aff *isl_aff_from_range(
__isl_take isl_aff *aff);
__isl_give isl_multi_aff *isl_multi_aff_from_range(
__isl_take isl_multi_aff *ma);
__isl_give isl_pw_aff *isl_pw_aff_from_range(
__isl_take isl_pw_aff *pwa);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_range(
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_from_range(
__isl_take isl_multi_union_pw_aff *mupa);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_domain(
__isl_take isl_set *set);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_from_domain(
__isl_take isl_union_set *uset);
#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial *
isl_pw_qpolynomial_from_range(
__isl_take isl_pw_qpolynomial *pwqp);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_from_range(
__isl_take isl_pw_qpolynomial_fold *pwf);Slicing
#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_fix_si(
__isl_take isl_basic_set *bset,
enum isl_dim_type type, unsigned pos, int value);
__isl_give isl_basic_set *isl_basic_set_fix_val(
__isl_take isl_basic_set *bset,
enum isl_dim_type type, unsigned pos,
__isl_take isl_val *v);
__isl_give isl_set *isl_set_fix_si(__isl_take isl_set *set,
enum isl_dim_type type, unsigned pos, int value);
__isl_give isl_set *isl_set_fix_val(
__isl_take isl_set *set,
enum isl_dim_type type, unsigned pos,
__isl_take isl_val *v);
#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_fix_si(
__isl_take isl_basic_map *bmap,
enum isl_dim_type type, unsigned pos, int value);
__isl_give isl_basic_map *isl_basic_map_fix_val(
__isl_take isl_basic_map *bmap,
enum isl_dim_type type, unsigned pos,
__isl_take isl_val *v);
__isl_give isl_map *isl_map_fix_si(__isl_take isl_map *map,
enum isl_dim_type type, unsigned pos, int value);
__isl_give isl_map *isl_map_fix_val(
__isl_take isl_map *map,
enum isl_dim_type type, unsigned pos,
__isl_take isl_val *v);
#include <isl/aff.h>
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_fix_si(
__isl_take isl_pw_multi_aff *pma,
enum isl_dim_type type, unsigned pos, int value);
#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_fix_val(
__isl_take isl_pw_qpolynomial *pwqp,
enum isl_dim_type type, unsigned n,
__isl_take isl_val *v);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_fix_val(
__isl_take isl_pw_qpolynomial_fold *pwf,
enum isl_dim_type type, unsigned n,
__isl_take isl_val *v);Intersect the set, relation or function domain with the hyperplane where the given dimension has the fixed given value.
#include <isl/set.h>
__isl_give isl_basic_set *
isl_basic_set_lower_bound_val(
__isl_take isl_basic_set *bset,
enum isl_dim_type type, unsigned pos,
__isl_take isl_val *value);
__isl_give isl_basic_set *
isl_basic_set_upper_bound_val(
__isl_take isl_basic_set *bset,
enum isl_dim_type type, unsigned pos,
__isl_take isl_val *value);
__isl_give isl_set *isl_set_lower_bound_si(
__isl_take isl_set *set,
enum isl_dim_type type, unsigned pos, int value);
__isl_give isl_set *isl_set_lower_bound_val(
__isl_take isl_set *set,
enum isl_dim_type type, unsigned pos,
__isl_take isl_val *value);
__isl_give isl_set *isl_set_upper_bound_si(
__isl_take isl_set *set,
enum isl_dim_type type, unsigned pos, int value);
__isl_give isl_set *isl_set_upper_bound_val(
__isl_take isl_set *set,
enum isl_dim_type type, unsigned pos,
__isl_take isl_val *value);
__isl_give isl_set *isl_set_lower_bound_multi_val(
__isl_take isl_set *set,
__isl_take isl_multi_val *lower);
__isl_give isl_set *isl_set_upper_bound_multi_val(
__isl_take isl_set *set,
__isl_take isl_multi_val *upper);
__isl_give isl_set *isl_set_lower_bound_multi_pw_aff(
__isl_take isl_set *set,
__isl_take isl_multi_pw_aff *lower);
__isl_give isl_set *isl_set_upper_bound_multi_pw_aff(
__isl_take isl_set *set,
__isl_take isl_multi_pw_aff *upper);
#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_lower_bound_si(
__isl_take isl_basic_map *bmap,
enum isl_dim_type type, unsigned pos, int value);
__isl_give isl_basic_map *isl_basic_map_upper_bound_si(
__isl_take isl_basic_map *bmap,
enum isl_dim_type type, unsigned pos, int value);
__isl_give isl_map *isl_map_lower_bound_si(
__isl_take isl_map *map,
enum isl_dim_type type, unsigned pos, int value);
__isl_give isl_map *isl_map_upper_bound_si(
__isl_take isl_map *map,
enum isl_dim_type type, unsigned pos, int value);
__isl_give isl_map *isl_map_lower_bound_val(
__isl_take isl_map *map,
enum isl_dim_type type, unsigned pos,
__isl_take isl_val *value);
__isl_give isl_map *isl_map_upper_bound_val(
__isl_take isl_map *map,
enum isl_dim_type type, unsigned pos,
__isl_take isl_val *value);
__isl_give isl_map *isl_map_lower_bound_multi_pw_aff(
__isl_take isl_map *map,
__isl_take isl_multi_pw_aff *lower);
__isl_give isl_map *isl_map_upper_bound_multi_pw_aff(
__isl_take isl_map *map,
__isl_take isl_multi_pw_aff *upper);Intersect the set or relation with the half-space where the given dimension has a value bounded by the given fixed integer value or symbolic constant expression. For functions taking a multi expression, this applies to all set dimensions. Those that bound a map, bound the range of that map. If the multi expression is zero-dimensional but has an explicit domain, then the (parameter) domain of the set or map is intersected with this explicit domain.
__isl_give isl_set *isl_set_equate(__isl_take isl_set *set,
enum isl_dim_type type1, int pos1,
enum isl_dim_type type2, int pos2);
__isl_give isl_basic_map *isl_basic_map_equate(
__isl_take isl_basic_map *bmap,
enum isl_dim_type type1, int pos1,
enum isl_dim_type type2, int pos2);
__isl_give isl_map *isl_map_equate(__isl_take isl_map *map,
enum isl_dim_type type1, int pos1,
enum isl_dim_type type2, int pos2);Intersect the set or relation with the hyperplane where the given dimensions are equal to each other.
__isl_give isl_map *isl_map_oppose(__isl_take isl_map *map,
enum isl_dim_type type1, int pos1,
enum isl_dim_type type2, int pos2);Intersect the relation with the hyperplane where the given dimensions have opposite values.
__isl_give isl_map *isl_map_order_le(
__isl_take isl_map *map,
enum isl_dim_type type1, int pos1,
enum isl_dim_type type2, int pos2);
__isl_give isl_basic_map *isl_basic_map_order_ge(
__isl_take isl_basic_map *bmap,
enum isl_dim_type type1, int pos1,
enum isl_dim_type type2, int pos2);
__isl_give isl_map *isl_map_order_ge(
__isl_take isl_map *map,
enum isl_dim_type type1, int pos1,
enum isl_dim_type type2, int pos2);
__isl_give isl_map *isl_map_order_lt(__isl_take isl_map *map,
enum isl_dim_type type1, int pos1,
enum isl_dim_type type2, int pos2);
__isl_give isl_basic_map *isl_basic_map_order_gt(
__isl_take isl_basic_map *bmap,
enum isl_dim_type type1, int pos1,
enum isl_dim_type type2, int pos2);
__isl_give isl_map *isl_map_order_gt(__isl_take isl_map *map,
enum isl_dim_type type1, int pos1,
enum isl_dim_type type2, int pos2);Intersect the relation with the half-space where the given dimensions satisfy the given ordering.
#include <isl/union_set.h>
__isl_give isl_union_map *isl_union_map_remove_map_if(
__isl_take isl_union_map *umap,
isl_bool (*fn)(__isl_keep isl_map *map,
void *user), void *user);This function calls the callback function once for each pair of spaces for which there are elements in the input. If the callback returns isl_bool_true, then all those elements are removed from the result. The only remaining elements in the output are then those for which the callback returns isl_bool_false.
Locus
#include <isl/aff.h>
__isl_give isl_basic_set *isl_aff_zero_basic_set(
__isl_take isl_aff *aff);
__isl_give isl_basic_set *isl_aff_neg_basic_set(
__isl_take isl_aff *aff);
__isl_give isl_set *isl_pw_aff_pos_set(
__isl_take isl_pw_aff *pa);
__isl_give isl_set *isl_pw_aff_nonneg_set(
__isl_take isl_pw_aff *pwaff);
__isl_give isl_set *isl_pw_aff_zero_set(
__isl_take isl_pw_aff *pwaff);
__isl_give isl_set *isl_pw_aff_non_zero_set(
__isl_take isl_pw_aff *pwaff);
__isl_give isl_union_set *
isl_union_pw_aff_zero_union_set(
__isl_take isl_union_pw_aff *upa);
__isl_give isl_union_set *
isl_multi_union_pw_aff_zero_union_set(
__isl_take isl_multi_union_pw_aff *mupa);The function isl_aff_neg_basic_set returns a basic set containing those elements in the domain space of aff where aff is negative. The function isl_pw_aff_nonneg_set returns a set containing those elements in the domain of pwaff where pwaff is non-negative. The function isl_multi_union_pw_aff_zero_union_set returns a union set containing those elements in the domains of its elements where they are all zero.
Identity
__isl_give isl_map *isl_set_identity(
__isl_take isl_set *set);
__isl_give isl_union_map *isl_union_set_identity(
__isl_take isl_union_set *uset);
__isl_give isl_union_pw_multi_aff *
isl_union_set_identity_union_pw_multi_aff(
__isl_take isl_union_set *uset);Construct an identity relation on the given (union) set.
Function Extraction
A piecewise quasi affine expression that is equal to 1 on a set and 0 outside the set can be created using the following function.
#include <isl/aff.h>
__isl_give isl_pw_aff *isl_set_indicator_function(
__isl_take isl_set *set);A piecewise multiple quasi affine expression can be extracted from an isl_set or isl_map, provided the isl_set is a singleton and the isl_map is single-valued. In case of a conversion from an isl_union_map to an isl_union_pw_multi_aff, these properties need to hold in each domain space. A conversion to a isl_multi_union_pw_aff additionally requires that the input is non-empty and involves only a single range space.
#include <isl/aff.h>
__isl_give isl_pw_multi_aff *isl_set_as_pw_multi_aff(
__isl_take isl_set *set);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_set(
__isl_take isl_set *set);
__isl_give isl_pw_multi_aff *isl_map_as_pw_multi_aff(
__isl_take isl_map *map);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_map(
__isl_take isl_map *map);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_from_union_set(
__isl_take isl_union_set *uset);
__isl_give isl_union_pw_multi_aff *
isl_union_map_as_union_pw_multi_aff(
__isl_take isl_union_map *umap);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_from_union_map(
__isl_take isl_union_map *umap);
__isl_give isl_multi_union_pw_aff *
isl_union_map_as_multi_union_pw_aff(
__isl_take isl_union_map *umap);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_from_union_map(
__isl_take isl_union_map *umap);isl_map_as_pw_multi_aff and isl_pw_multi_aff_from_map perform the same operation. Similarly for isl_set_as_pw_multi_aff and isl_pw_multi_aff_from_set, for isl_union_map_as_union_pw_multi_aff and isl_union_pw_multi_aff_from_union_map and for isl_union_map_as_multi_union_pw_aff and isl_multi_union_pw_aff_from_union_map.
Deltas
__isl_give isl_basic_set *isl_basic_map_deltas(
__isl_take isl_basic_map *bmap);
__isl_give isl_set *isl_map_deltas(__isl_take isl_map *map);
__isl_give isl_union_set *isl_union_map_deltas(
__isl_take isl_union_map *umap);These functions return a (basic) set containing the differences between image elements and corresponding domain elements in the input.
__isl_give isl_basic_map *isl_basic_map_deltas_map(
__isl_take isl_basic_map *bmap);
__isl_give isl_map *isl_map_deltas_map(
__isl_take isl_map *map);
__isl_give isl_union_map *isl_union_map_deltas_map(
__isl_take isl_union_map *umap);The functions above construct a (basic, regular or union) relation that maps (a wrapped version of) the input relation to its delta set.
Translation
#include <isl/map.h>
__isl_give isl_map *isl_set_translation(
__isl_take isl_set *deltas);This function performs essentially the opposite operation of isl_map_deltas. In particular, it returns pairs of elements in the same space that have a difference in deltas.
Coalescing
Simplify the representation of a set, relation or functions by trying to combine pairs of basic sets or relations into a single basic set or relation.
#include <isl/set.h>
__isl_give isl_set *isl_set_coalesce(__isl_take isl_set *set);
#include <isl/map.h>
__isl_give isl_map *isl_map_coalesce(__isl_take isl_map *map);
#include <isl/union_set.h>
__isl_give isl_union_set *isl_union_set_coalesce(
__isl_take isl_union_set *uset);
#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_coalesce(
__isl_take isl_union_map *umap);
#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_coalesce(
__isl_take isl_pw_aff *pa);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_coalesce(
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_coalesce(
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_union_pw_aff *isl_union_pw_aff_coalesce(
__isl_take isl_union_pw_aff *upa);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_coalesce(
__isl_take isl_union_pw_multi_aff *upma);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_coalesce(
__isl_take isl_multi_union_pw_aff *mupa);
#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_coalesce(
__isl_take isl_pw_qpolynomial_fold *pwf);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_coalesce(
__isl_take isl_union_pw_qpolynomial *upwqp);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_coalesce(
__isl_take isl_union_pw_qpolynomial_fold *upwf);One of the methods for combining pairs of basic sets or relations can result in coefficients that are much larger than those that appear in the constraints of the input. By default, the coefficients are not allowed to grow larger, but this can be changed by unsetting the following option.
isl_stat isl_options_set_coalesce_bounded_wrapping(
isl_ctx *ctx, int val);
int isl_options_get_coalesce_bounded_wrapping(
isl_ctx *ctx);One of the other methods tries to combine pairs of basic sets with different local variables, treating them as existentially quantified variables even if they have known (but different) integer division expressions. The result may then also have existentially quantified variables. Turning on the following option prevents this from happening.
isl_stat isl_options_set_coalesce_preserve_locals(
isl_ctx *ctx, int val);
int isl_options_get_coalesce_preserve_locals(isl_ctx *ctx);Detecting equalities
__isl_give isl_basic_set *isl_basic_set_detect_equalities(
__isl_take isl_basic_set *bset);
__isl_give isl_basic_map *isl_basic_map_detect_equalities(
__isl_take isl_basic_map *bmap);
__isl_give isl_set *isl_set_detect_equalities(
__isl_take isl_set *set);
__isl_give isl_map *isl_map_detect_equalities(
__isl_take isl_map *map);
__isl_give isl_union_set *isl_union_set_detect_equalities(
__isl_take isl_union_set *uset);
__isl_give isl_union_map *isl_union_map_detect_equalities(
__isl_take isl_union_map *umap);Simplify the representation of a set or relation by detecting implicit equalities.
Removing redundant constraints
#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_remove_redundancies(
__isl_take isl_basic_set *bset);
__isl_give isl_set *isl_set_remove_redundancies(
__isl_take isl_set *set);
#include <isl/union_set.h>
__isl_give isl_union_set *
isl_union_set_remove_redundancies(
__isl_take isl_union_set *uset);
#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_remove_redundancies(
__isl_take isl_basic_map *bmap);
__isl_give isl_map *isl_map_remove_redundancies(
__isl_take isl_map *map);
#include <isl/union_map.h>
__isl_give isl_union_map *
isl_union_map_remove_redundancies(
__isl_take isl_union_map *umap);Convex hull
__isl_give isl_basic_set *isl_set_convex_hull(
__isl_take isl_set *set);
__isl_give isl_basic_map *isl_map_convex_hull(
__isl_take isl_map *map);If the input set or relation has any existentially quantified variables, then the result of these operations is currently undefined.
Simple hull
#include <isl/set.h>
__isl_give isl_basic_set *
isl_set_unshifted_simple_hull(
__isl_take isl_set *set);
__isl_give isl_basic_set *isl_set_simple_hull(
__isl_take isl_set *set);
__isl_give isl_basic_set *
isl_set_plain_unshifted_simple_hull(
__isl_take isl_set *set);
__isl_give isl_basic_set *
isl_set_unshifted_simple_hull_from_set_list(
__isl_take isl_set *set,
__isl_take isl_set_list *list);
#include <isl/map.h>
__isl_give isl_basic_map *
isl_map_unshifted_simple_hull(
__isl_take isl_map *map);
__isl_give isl_basic_map *isl_map_simple_hull(
__isl_take isl_map *map);
__isl_give isl_basic_map *
isl_map_plain_unshifted_simple_hull(
__isl_take isl_map *map);
__isl_give isl_basic_map *
isl_map_unshifted_simple_hull_from_map_list(
__isl_take isl_map *map,
__isl_take isl_map_list *list);
#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_simple_hull(
__isl_take isl_union_map *umap);These functions compute a single basic set or relation that contains the whole input set or relation. In particular, the output is described by translates of the constraints describing the basic sets or relations in the input. In case of isl_set_unshifted_simple_hull, only the original constraints are used, without any translation. In case of isl_set_plain_unshifted_simple_hull and isl_map_plain_unshifted_simple_hull, the result is described by original constraints that are obviously satisfied by the entire input set or relation. In case of isl_set_unshifted_simple_hull_from_set_list and isl_map_unshifted_simple_hull_from_map_list, the constraints are taken from the elements of the second argument.
Affine hull
__isl_give isl_basic_set *isl_basic_set_affine_hull(
__isl_take isl_basic_set *bset);
__isl_give isl_basic_set *isl_set_affine_hull(
__isl_take isl_set *set);
__isl_give isl_union_set *isl_union_set_affine_hull(
__isl_take isl_union_set *uset);
__isl_give isl_basic_map *isl_basic_map_affine_hull(
__isl_take isl_basic_map *bmap);
__isl_give isl_basic_map *isl_map_affine_hull(
__isl_take isl_map *map);
__isl_give isl_union_map *isl_union_map_affine_hull(
__isl_take isl_union_map *umap);In case of union sets and relations, the affine hull is computed per space.
Polyhedral hull
__isl_give isl_basic_set *isl_set_polyhedral_hull(
__isl_take isl_set *set);
__isl_give isl_basic_map *isl_map_polyhedral_hull(
__isl_take isl_map *map);
__isl_give isl_union_set *isl_union_set_polyhedral_hull(
__isl_take isl_union_set *uset);
__isl_give isl_union_map *isl_union_map_polyhedral_hull(
__isl_take isl_union_map *umap);These functions compute a single basic set or relation not involving any existentially quantified variables that contains the whole input set or relation. In case of union sets and relations, the polyhedral hull is computed per space.
Box hull
#include <isl/set.h>
__isl_give isl_fixed_box *
isl_set_get_simple_fixed_box_hull(
__isl_keep isl_set *set)
#include <isl/map.h>
__isl_give isl_fixed_box *
isl_map_get_range_simple_fixed_box_hull(
__isl_keep isl_map *map);These functions try to approximate the set or the range of the map by a box of fixed size. The box is described in terms of an offset living in the same space as the input and a size living in the set or range space. For any element in the input map, the range value is greater than or equal to the offset applied to the domain value and the difference with this offset is strictly smaller than the size. The same holds for the elements of the input set, where the offset is a parametric constant value. If no fixed-size approximation can be found, an invalid box is returned, i.e., one for which isl_fixed_box_is_valid below returns false.
The validity, the offset and the size of the box can be obtained using the following functions.
#include <isl/fixed_box.h>
isl_bool isl_fixed_box_is_valid(
__isl_keep isl_fixed_box *box);
__isl_give isl_multi_aff *isl_fixed_box_get_offset(
__isl_keep isl_fixed_box *box);
__isl_give isl_multi_val *isl_fixed_box_get_size(
__isl_keep isl_fixed_box *box);The box can be copied and freed using the following functions.
#include <isl/fixed_box.h>
__isl_give isl_fixed_box *isl_fixed_box_copy(
__isl_keep isl_fixed_box *box);
__isl_null isl_fixed_box *isl_fixed_box_free(
__isl_take isl_fixed_box *box);An object of type isl_fixed_box can be read from input using the following function.
#include <isl/fixed_box.h>
__isl_give isl_fixed_box *
isl_fixed_box_read_from_str(isl_ctx *ctx,
const char *str);A representation of the information contained in an object of type isl_fixed_box can be obtained using
#include <isl/fixed_box.h>
__isl_give isl_printer *isl_printer_print_fixed_box(
__isl_take isl_printer *p,
__isl_keep isl_fixed_box *box);
__isl_give char *isl_fixed_box_to_str(
__isl_keep isl_fixed_box *box);isl_fixed_box_to_str prints the information in flow format.
Other approximations
#include <isl/set.h>
__isl_give isl_basic_set *
isl_basic_set_drop_constraints_involving_dims(
__isl_take isl_basic_set *bset,
enum isl_dim_type type,
unsigned first, unsigned n);
__isl_give isl_basic_set *
isl_basic_set_drop_constraints_not_involving_dims(
__isl_take isl_basic_set *bset,
enum isl_dim_type type,
unsigned first, unsigned n);
__isl_give isl_set *
isl_set_drop_constraints_involving_dims(
__isl_take isl_set *set,
enum isl_dim_type type,
unsigned first, unsigned n);
__isl_give isl_set *
isl_set_drop_constraints_not_involving_dims(
__isl_take isl_set *set,
enum isl_dim_type type,
unsigned first, unsigned n);
#include <isl/map.h>
__isl_give isl_basic_map *
isl_basic_map_drop_constraints_involving_dims(
__isl_take isl_basic_map *bmap,
enum isl_dim_type type,
unsigned first, unsigned n);
__isl_give isl_basic_map *
isl_basic_map_drop_constraints_not_involving_dims(
__isl_take isl_basic_map *bmap,
enum isl_dim_type type,
unsigned first, unsigned n);
__isl_give isl_map *
isl_map_drop_constraints_involving_dims(
__isl_take isl_map *map,
enum isl_dim_type type,
unsigned first, unsigned n);
__isl_give isl_map *
isl_map_drop_constraints_not_involving_dims(
__isl_take isl_map *map,
enum isl_dim_type type,
unsigned first, unsigned n);These functions drop any constraints (not) involving the specified dimensions. Note that the result depends on the representation of the input.
#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_to_polynomial(
__isl_take isl_pw_qpolynomial *pwqp, int sign);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_to_polynomial(
__isl_take isl_union_pw_qpolynomial *upwqp, int sign);Approximate each quasipolynomial by a polynomial. If sign is positive, the polynomial will be an overapproximation. If sign is negative, it will be an underapproximation. If sign is zero, the approximation will lie somewhere in between.
Feasibility
__isl_give isl_basic_set *isl_basic_set_sample(
__isl_take isl_basic_set *bset);
__isl_give isl_basic_set *isl_set_sample(
__isl_take isl_set *set);
__isl_give isl_basic_map *isl_basic_map_sample(
__isl_take isl_basic_map *bmap);
__isl_give isl_basic_map *isl_map_sample(
__isl_take isl_map *map);If the input (basic) set or relation is non-empty, then return a singleton subset of the input. Otherwise, return an empty set.
Optimization
#include <isl/ilp.h>
__isl_give isl_val *isl_basic_set_max_val(
__isl_keep isl_basic_set *bset,
__isl_keep isl_aff *obj);
__isl_give isl_val *isl_set_min_val(
__isl_keep isl_set *set,
__isl_keep isl_aff *obj);
__isl_give isl_val *isl_set_max_val(
__isl_keep isl_set *set,
__isl_keep isl_aff *obj);
__isl_give isl_multi_val *
isl_union_set_min_multi_union_pw_aff(
__isl_keep isl_union_set *uset,
__isl_keep isl_multi_union_pw_aff *obj);Compute the minimum or maximum of the integer affine expression obj over the points in set. The result is NULL in case of an error, the optimal value in case there is one, negative infinity or infinity if the problem is unbounded and NaN if the problem is empty.
#include <isl/ilp.h>
__isl_give isl_val *isl_pw_aff_min_val(
__isl_take isl_pw_aff *pa);
__isl_give isl_val *isl_pw_aff_max_val(
__isl_take isl_pw_aff *pa);
__isl_give isl_multi_val *
isl_pw_multi_aff_min_multi_val(
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_multi_val *
isl_pw_multi_aff_max_multi_val(
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_multi_val *
isl_multi_pw_aff_min_multi_val(
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_multi_val *
isl_multi_pw_aff_max_multi_val(
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_val *isl_union_pw_aff_min_val(
__isl_take isl_union_pw_aff *upa);
__isl_give isl_val *isl_union_pw_aff_max_val(
__isl_take isl_union_pw_aff *upa);
__isl_give isl_multi_val *
isl_multi_union_pw_aff_min_multi_val(
__isl_take isl_multi_union_pw_aff *mupa);
__isl_give isl_multi_val *
isl_multi_union_pw_aff_max_multi_val(
__isl_take isl_multi_union_pw_aff *mupa);Compute the minimum or maximum of the integer affine expression over its definition domain. The result is NULL in case of an error, the optimal value in case there is one, negative infinity or infinity if the problem is unbounded and NaN if the problem is empty.
#include <isl/ilp.h>
__isl_give isl_val *isl_basic_set_dim_max_val(
__isl_take isl_basic_set *bset, int pos);
__isl_give isl_val *isl_set_dim_min_val(
__isl_take isl_set *set, int pos);
__isl_give isl_val *isl_set_dim_max_val(
__isl_take isl_set *set, int pos);Return the minimal or maximal value attained by the given set dimension, independently of the parameter values and of any other dimensions. The result is NULL in case of an error, the optimal value in case there is one, (negative) infinity if the problem is unbounded and NaN if the input is empty.
Parametric optimization
__isl_give isl_pw_aff *isl_set_dim_min(
__isl_take isl_set *set, int pos);
__isl_give isl_pw_aff *isl_set_dim_max(
__isl_take isl_set *set, int pos);
__isl_give isl_pw_aff *isl_map_dim_min(
__isl_take isl_map *map, int pos);
__isl_give isl_pw_aff *isl_map_dim_max(
__isl_take isl_map *map, int pos);
__isl_give isl_multi_pw_aff *
isl_set_min_multi_pw_aff(
__isl_take isl_set *set);
__isl_give isl_multi_pw_aff *
isl_set_max_multi_pw_aff(
__isl_take isl_set *set);
__isl_give isl_multi_pw_aff *
isl_map_min_multi_pw_aff(
__isl_take isl_map *map);
__isl_give isl_multi_pw_aff *
isl_map_max_multi_pw_aff(
__isl_take isl_map *map);Compute the minimum or maximum of the (given) set or output dimension(s) as a function of the parameters (and input dimensions), but independently of the other set or output dimensions. For lexicographic optimization, see "Lexicographic Optimization".
Dual
The following functions compute either the set of (rational) coefficient values of valid constraints for the given set or the set of (rational) values satisfying the constraints with coefficients from the given set. Internally, these two sets of functions perform essentially the same operations, except that the set of coefficients is assumed to be a cone, while the set of values may be any polyhedron. The current implementation is based on the Farkas lemma and Fourier-Motzkin elimination, but this may change or be made optional in future. In particular, future implementations may use different dualization algorithms or skip the elimination step.
#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_coefficients(
__isl_take isl_basic_set *bset);
__isl_give isl_basic_set_list *
isl_basic_set_list_coefficients(
__isl_take isl_basic_set_list *list);
__isl_give isl_basic_set *isl_set_coefficients(
__isl_take isl_set *set);
__isl_give isl_union_set *isl_union_set_coefficients(
__isl_take isl_union_set *bset);
__isl_give isl_basic_set *isl_basic_set_solutions(
__isl_take isl_basic_set *bset);
__isl_give isl_basic_set *isl_set_solutions(
__isl_take isl_set *set);
__isl_give isl_union_set *isl_union_set_solutions(
__isl_take isl_union_set *bset);Power
__isl_give isl_map *isl_map_fixed_power_val(
__isl_take isl_map *map,
__isl_take isl_val *exp);
__isl_give isl_union_map *
isl_union_map_fixed_power_val(
__isl_take isl_union_map *umap,
__isl_take isl_val *exp);Compute the given power of map, where exp is assumed to be non-zero. If the exponent exp is negative, then the -exp th power of the inverse of map is computed.
__isl_give isl_map *isl_map_power(__isl_take isl_map *map,
isl_bool *exact);
__isl_give isl_union_map *isl_union_map_power(
__isl_take isl_union_map *umap, isl_bool *exact);Compute a parametric representation for all positive powers k of map. The result maps k to a nested relation corresponding to the kth power of map. The result may be an overapproximation. If the result is known to be exact, then *exact is set to 1.
Transitive closure
__isl_give isl_map *isl_map_transitive_closure(
__isl_take isl_map *map, isl_bool *exact);
__isl_give isl_union_map *isl_union_map_transitive_closure(
__isl_take isl_union_map *umap, isl_bool *exact);Compute the transitive closure of map. The result may be an overapproximation. If the result is known to be exact, then *exact is set to 1.
Reaching path lengths
__isl_give isl_map *isl_map_reaching_path_lengths(
__isl_take isl_map *map, isl_bool *exact);Compute a relation that maps each element in the range of map to the lengths of all paths composed of edges in map that end up in the given element. The result may be an overapproximation. If the result is known to be exact, then *exact is set to 1. To compute the maximal path length, the resulting relation should be postprocessed by isl_map_lexmax. In particular, if the input relation is a dependence relation (mapping sources to sinks), then the maximal path length corresponds to the free schedule. Note, however, that isl_map_lexmax expects the maximum to be finite, so if the path lengths are unbounded (possibly due to the overapproximation), then you will get an error message.
Wrapping
#include <isl/space.h>
__isl_give isl_space *isl_space_wrap(
__isl_take isl_space *space);
__isl_give isl_space *isl_space_unwrap(
__isl_take isl_space *space);
#include <isl/local_space.h>
__isl_give isl_local_space *isl_local_space_wrap(
__isl_take isl_local_space *ls);
#include <isl/set.h>
__isl_give isl_basic_map *isl_basic_set_unwrap(
__isl_take isl_basic_set *bset);
__isl_give isl_map *isl_set_unwrap(
__isl_take isl_set *set);
#include <isl/map.h>
__isl_give isl_basic_set *isl_basic_map_wrap(
__isl_take isl_basic_map *bmap);
__isl_give isl_set *isl_map_wrap(
__isl_take isl_map *map);
#include <isl/union_set.h>
__isl_give isl_union_map *isl_union_set_unwrap(
__isl_take isl_union_set *uset);
#include <isl/union_map.h>
__isl_give isl_union_set *isl_union_map_wrap(
__isl_take isl_union_map *umap);The input to isl_space_unwrap should be the space of a set, while that of isl_space_wrap should be the space of a relation. Conversely, the output of isl_space_unwrap is the space of a relation, while that of isl_space_wrap is the space of a set.
Flattening
Remove any internal structure of domain (and range) of the given set or relation. If there is any such internal structure in the input, then the name of the space is also removed.
#include <isl/space.h>
__isl_give isl_space *isl_space_flatten_domain(
__isl_take isl_space *space);
__isl_give isl_space *isl_space_flatten_range(
__isl_take isl_space *space);
#include <isl/local_space.h>
__isl_give isl_local_space *
isl_local_space_flatten_domain(
__isl_take isl_local_space *ls);
__isl_give isl_local_space *
isl_local_space_flatten_range(
__isl_take isl_local_space *ls);
#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_flatten(
__isl_take isl_basic_set *bset);
__isl_give isl_set *isl_set_flatten(
__isl_take isl_set *set);
#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_flatten_domain(
__isl_take isl_basic_map *bmap);
__isl_give isl_basic_map *isl_basic_map_flatten_range(
__isl_take isl_basic_map *bmap);
__isl_give isl_map *isl_map_flatten_range(
__isl_take isl_map *map);
__isl_give isl_map *isl_map_flatten_domain(
__isl_take isl_map *map);
__isl_give isl_basic_map *isl_basic_map_flatten(
__isl_take isl_basic_map *bmap);
__isl_give isl_map *isl_map_flatten(
__isl_take isl_map *map);
#include <isl/id.h>
__isl_give isl_multi_id *isl_multi_id_flatten_range(
__isl_take isl_multi_id *mi);
#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_flatten_range(
__isl_take isl_multi_val *mv);
#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_flatten_domain(
__isl_take isl_multi_aff *ma);
__isl_give isl_multi_aff *isl_multi_aff_flatten_range(
__isl_take isl_multi_aff *ma);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_flatten_range(
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_flatten_range(
__isl_take isl_multi_union_pw_aff *mupa);
#include <isl/map.h>
__isl_give isl_map *isl_set_flatten_map(
__isl_take isl_set *set);The function above constructs a relation that maps the input set to a flattened version of the set.
Lifting
Lift the input set to a space with extra dimensions corresponding to the existentially quantified variables in the input. In particular, the result lives in a wrapped map where the domain is the original space and the range corresponds to the original existentially quantified variables.
#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_lift(
__isl_take isl_basic_set *bset);
__isl_give isl_set *isl_set_lift(
__isl_take isl_set *set);
__isl_give isl_union_set *isl_union_set_lift(
__isl_take isl_union_set *uset);Given a local space that contains the existentially quantified variables of a set, a basic relation that, when applied to a basic set, has essentially the same effect as isl_basic_set_lift, can be constructed using the following function.
#include <isl/local_space.h>
__isl_give isl_basic_map *isl_local_space_lifting(
__isl_take isl_local_space *ls);
#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_lift(
__isl_take isl_multi_aff *maff,
__isl_give isl_local_space **ls);If the ls argument of isl_multi_aff_lift is not NULL, then it is assigned the local space that lies at the basis of the lifting applied.
Internal Product
#include <isl/space.h>
__isl_give isl_space *isl_space_zip(
__isl_take isl_space *space);
#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_zip(
__isl_take isl_basic_map *bmap);
__isl_give isl_map *isl_map_zip(
__isl_take isl_map *map);
#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_zip(
__isl_take isl_union_map *umap);Given a relation with nested relations for domain and range, interchange the range of the domain with the domain of the range.
Currying
#include <isl/space.h>
__isl_give isl_space *isl_space_curry(
__isl_take isl_space *space);
__isl_give isl_space *isl_space_uncurry(
__isl_take isl_space *space);
#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_curry(
__isl_take isl_basic_map *bmap);
__isl_give isl_basic_map *isl_basic_map_uncurry(
__isl_take isl_basic_map *bmap);
__isl_give isl_map *isl_map_curry(
__isl_take isl_map *map);
__isl_give isl_map *isl_map_uncurry(
__isl_take isl_map *map);
#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_curry(
__isl_take isl_union_map *umap);
__isl_give isl_union_map *isl_union_map_uncurry(
__isl_take isl_union_map *umap);Given a relation with a nested relation for domain, the curry functions move the range of the nested relation out of the domain and use it as the domain of a nested relation in the range, with the original range as range of this nested relation. The uncurry functions perform the inverse operation.
#include <isl/space.h>
__isl_give isl_space *isl_space_range_curry(
__isl_take isl_space *space);
#include <isl/map.h>
__isl_give isl_map *isl_map_range_curry(
__isl_take isl_map *map);
#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_range_curry(
__isl_take isl_union_map *umap);These functions apply the currying to the relation that is nested inside the range of the input.
Aligning parameters
Change the order of the parameters of the given set, relation or function such that the first parameters match those of model. This may involve the introduction of extra parameters. All parameters need to be named.
#include <isl/space.h>
__isl_give isl_space *isl_space_align_params(
__isl_take isl_space *space1,
__isl_take isl_space *space2)
#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_align_params(
__isl_take isl_basic_set *bset,
__isl_take isl_space *model);
__isl_give isl_set *isl_set_align_params(
__isl_take isl_set *set,
__isl_take isl_space *model);
#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_align_params(
__isl_take isl_basic_map *bmap,
__isl_take isl_space *model);
__isl_give isl_map *isl_map_align_params(
__isl_take isl_map *map,
__isl_take isl_space *model);
#include <isl/id.h>
__isl_give isl_multi_id *isl_multi_id_align_params(
__isl_take isl_multi_id *mi,
__isl_take isl_space *model);
#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_align_params(
__isl_take isl_multi_val *mv,
__isl_take isl_space *model);
#include <isl/aff.h>
__isl_give isl_aff *isl_aff_align_params(
__isl_take isl_aff *aff,
__isl_take isl_space *model);
__isl_give isl_multi_aff *isl_multi_aff_align_params(
__isl_take isl_multi_aff *multi,
__isl_take isl_space *model);
__isl_give isl_pw_aff *isl_pw_aff_align_params(
__isl_take isl_pw_aff *pwaff,
__isl_take isl_space *model);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_align_params(
__isl_take isl_pw_multi_aff *pma,
__isl_take isl_space *model);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_align_params(
__isl_take isl_union_pw_aff *upa,
__isl_take isl_space *model);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_align_params(
__isl_take isl_union_pw_multi_aff *upma,
__isl_take isl_space *model);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_align_params(
__isl_take isl_multi_union_pw_aff *mupa,
__isl_take isl_space *model);
#include <isl/polynomial.h>
__isl_give isl_qpolynomial *isl_qpolynomial_align_params(
__isl_take isl_qpolynomial *qp,
__isl_take isl_space *model);Drop unused parameters
Drop parameters that are not referenced by the isl object. All parameters need to be named.
#include <isl/set.h>
__isl_give isl_basic_set *
isl_basic_set_drop_unused_params(
__isl_take isl_basic_set *bset);
__isl_give isl_set *isl_set_drop_unused_params(
__isl_take isl_set *set);
#include <isl/map.h>
__isl_give isl_basic_map *
isl_basic_map_drop_unused_params(
__isl_take isl_basic_map *bmap);
__isl_give isl_map *isl_map_drop_unused_params(
__isl_take isl_map *map);
#include <isl/union_set.h>
__isl_give isl_union_set *
isl_union_set_drop_unused_params(
__isl_take isl_union_set *uset);
#include <isl/union_map.h>
__isl_give isl_union_map *
isl_union_map_drop_unused_params(
__isl_take isl_union_map *umap);
#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_drop_unused_params(
__isl_take isl_pw_aff *pa);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_drop_unused_params(
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_drop_unused_params(
__isl_take isl_union_pw_aff *upa);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_drop_unused_params(
__isl_take isl_union_pw_multi_aff *upma);
#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial *
isl_pw_qpolynomial_drop_unused_params(
__isl_take isl_pw_qpolynomial *pwqp);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_drop_unused_params(
__isl_take isl_pw_qpolynomial_fold *pwf);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_drop_unused_params(
__isl_take isl_union_pw_qpolynomial *upwqp);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_drop_unused_params(
__isl_take isl_union_pw_qpolynomial_fold *upwf);Unary Arithmetic Operations
#include <isl/set.h>
__isl_give isl_set *isl_set_neg(
__isl_take isl_set *set);
#include <isl/map.h>
__isl_give isl_map *isl_map_neg(
__isl_take isl_map *map);isl_set_neg constructs a set containing the opposites of the elements in its argument. The domain of the result of isl_map_neg is the same as the domain of its argument. The corresponding range elements are the opposites of the corresponding range elements in the argument.
#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_neg(
__isl_take isl_multi_val *mv);
#include <isl/aff.h>
__isl_give isl_aff *isl_aff_neg(
__isl_take isl_aff *aff);
__isl_give isl_multi_aff *isl_multi_aff_neg(
__isl_take isl_multi_aff *ma);
__isl_give isl_pw_aff *isl_pw_aff_neg(
__isl_take isl_pw_aff *pwaff);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_neg(
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_neg(
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_union_pw_aff *isl_union_pw_aff_neg(
__isl_take isl_union_pw_aff *upa);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_neg(
__isl_take isl_union_pw_multi_aff *upma);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_neg(
__isl_take isl_multi_union_pw_aff *mupa);
__isl_give isl_aff *isl_aff_ceil(
__isl_take isl_aff *aff);
__isl_give isl_pw_aff *isl_pw_aff_ceil(
__isl_take isl_pw_aff *pwaff);
__isl_give isl_aff *isl_aff_floor(
__isl_take isl_aff *aff);
__isl_give isl_multi_aff *isl_multi_aff_floor(
__isl_take isl_multi_aff *ma);
__isl_give isl_pw_aff *isl_pw_aff_floor(
__isl_take isl_pw_aff *pwaff);
__isl_give isl_union_pw_aff *isl_union_pw_aff_floor(
__isl_take isl_union_pw_aff *upa);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_floor(
__isl_take isl_multi_union_pw_aff *mupa);
#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_list_min(
__isl_take isl_pw_aff_list *list);
__isl_give isl_pw_aff *isl_pw_aff_list_max(
__isl_take isl_pw_aff_list *list);
#include <isl/polynomial.h>
__isl_give isl_qpolynomial *isl_qpolynomial_neg(
__isl_take isl_qpolynomial *qp);
__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_neg(
__isl_take isl_pw_qpolynomial *pwqp);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_neg(
__isl_take isl_union_pw_qpolynomial *upwqp);
__isl_give isl_qpolynomial *isl_qpolynomial_pow(
__isl_take isl_qpolynomial *qp,
unsigned exponent);
__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_pow(
__isl_take isl_pw_qpolynomial *pwqp,
unsigned exponent);Evaluation
The following functions evaluate a function in a point.
#include <isl/aff.h>
__isl_give isl_val *isl_aff_eval(
__isl_take isl_aff *aff,
__isl_take isl_point *pnt);
__isl_give isl_val *isl_pw_aff_eval(
__isl_take isl_pw_aff *pa,
__isl_take isl_point *pnt);
#include <isl/polynomial.h>
__isl_give isl_val *isl_pw_qpolynomial_eval(
__isl_take isl_pw_qpolynomial *pwqp,
__isl_take isl_point *pnt);
__isl_give isl_val *isl_pw_qpolynomial_fold_eval(
__isl_take isl_pw_qpolynomial_fold *pwf,
__isl_take isl_point *pnt);
__isl_give isl_val *isl_union_pw_qpolynomial_eval(
__isl_take isl_union_pw_qpolynomial *upwqp,
__isl_take isl_point *pnt);
__isl_give isl_val *isl_union_pw_qpolynomial_fold_eval(
__isl_take isl_union_pw_qpolynomial_fold *upwf,
__isl_take isl_point *pnt);These functions return NaN when evaluated at a void point. Note that isl_pw_aff_eval returns NaN when the function is evaluated outside its definition domain, while isl_pw_qpolynomial_eval returns zero when the function is evaluated outside its explicit domain.
Dimension manipulation
It is usually not advisable to directly change the (input or output) space of a set or a relation as this removes the name and the internal structure of the space. However, the functions below can be useful to add new parameters, assuming isl_set_align_params and isl_map_align_params are not sufficient.
#include <isl/space.h>
__isl_give isl_space *isl_space_add_dims(
__isl_take isl_space *space,
enum isl_dim_type type, unsigned n);
__isl_give isl_space *isl_space_insert_dims(
__isl_take isl_space *space,
enum isl_dim_type type, unsigned pos, unsigned n);
__isl_give isl_space *isl_space_drop_dims(
__isl_take isl_space *space,
enum isl_dim_type type, unsigned first, unsigned n);
__isl_give isl_space *isl_space_move_dims(
__isl_take isl_space *space,
enum isl_dim_type dst_type, unsigned dst_pos,
enum isl_dim_type src_type, unsigned src_pos,
unsigned n);
#include <isl/local_space.h>
__isl_give isl_local_space *isl_local_space_add_dims(
__isl_take isl_local_space *ls,
enum isl_dim_type type, unsigned n);
__isl_give isl_local_space *isl_local_space_insert_dims(
__isl_take isl_local_space *ls,
enum isl_dim_type type, unsigned first, unsigned n);
__isl_give isl_local_space *isl_local_space_drop_dims(
__isl_take isl_local_space *ls,
enum isl_dim_type type, unsigned first, unsigned n);
#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_add_dims(
__isl_take isl_basic_set *bset,
enum isl_dim_type type, unsigned n);
__isl_give isl_set *isl_set_add_dims(
__isl_take isl_set *set,
enum isl_dim_type type, unsigned n);
__isl_give isl_basic_set *isl_basic_set_insert_dims(
__isl_take isl_basic_set *bset,
enum isl_dim_type type, unsigned pos,
unsigned n);
__isl_give isl_set *isl_set_insert_dims(
__isl_take isl_set *set,
enum isl_dim_type type, unsigned pos, unsigned n);
__isl_give isl_basic_set *isl_basic_set_move_dims(
__isl_take isl_basic_set *bset,
enum isl_dim_type dst_type, unsigned dst_pos,
enum isl_dim_type src_type, unsigned src_pos,
unsigned n);
__isl_give isl_set *isl_set_move_dims(
__isl_take isl_set *set,
enum isl_dim_type dst_type, unsigned dst_pos,
enum isl_dim_type src_type, unsigned src_pos,
unsigned n);
#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_add_dims(
__isl_take isl_basic_map *bmap,
enum isl_dim_type type, unsigned n);
__isl_give isl_map *isl_map_add_dims(
__isl_take isl_map *map,
enum isl_dim_type type, unsigned n);
__isl_give isl_basic_map *isl_basic_map_insert_dims(
__isl_take isl_basic_map *bmap,
enum isl_dim_type type, unsigned pos,
unsigned n);
__isl_give isl_map *isl_map_insert_dims(
__isl_take isl_map *map,
enum isl_dim_type type, unsigned pos, unsigned n);
__isl_give isl_basic_map *isl_basic_map_move_dims(
__isl_take isl_basic_map *bmap,
enum isl_dim_type dst_type, unsigned dst_pos,
enum isl_dim_type src_type, unsigned src_pos,
unsigned n);
__isl_give isl_map *isl_map_move_dims(
__isl_take isl_map *map,
enum isl_dim_type dst_type, unsigned dst_pos,
enum isl_dim_type src_type, unsigned src_pos,
unsigned n);
#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_insert_dims(
__isl_take isl_multi_val *mv,
enum isl_dim_type type, unsigned first, unsigned n);
__isl_give isl_multi_val *isl_multi_val_add_dims(
__isl_take isl_multi_val *mv,
enum isl_dim_type type, unsigned n);
__isl_give isl_multi_val *isl_multi_val_drop_dims(
__isl_take isl_multi_val *mv,
enum isl_dim_type type, unsigned first, unsigned n);
#include <isl/aff.h>
__isl_give isl_aff *isl_aff_insert_dims(
__isl_take isl_aff *aff,
enum isl_dim_type type, unsigned first, unsigned n);
__isl_give isl_multi_aff *isl_multi_aff_insert_dims(
__isl_take isl_multi_aff *ma,
enum isl_dim_type type, unsigned first, unsigned n);
__isl_give isl_pw_aff *isl_pw_aff_insert_dims(
__isl_take isl_pw_aff *pwaff,
enum isl_dim_type type, unsigned first, unsigned n);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_insert_dims(
__isl_take isl_multi_pw_aff *mpa,
enum isl_dim_type type, unsigned first, unsigned n);
__isl_give isl_aff *isl_aff_add_dims(
__isl_take isl_aff *aff,
enum isl_dim_type type, unsigned n);
__isl_give isl_multi_aff *isl_multi_aff_add_dims(
__isl_take isl_multi_aff *ma,
enum isl_dim_type type, unsigned n);
__isl_give isl_pw_aff *isl_pw_aff_add_dims(
__isl_take isl_pw_aff *pwaff,
enum isl_dim_type type, unsigned n);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_add_dims(
__isl_take isl_multi_pw_aff *mpa,
enum isl_dim_type type, unsigned n);
__isl_give isl_aff *isl_aff_drop_dims(
__isl_take isl_aff *aff,
enum isl_dim_type type, unsigned first, unsigned n);
__isl_give isl_multi_aff *isl_multi_aff_drop_dims(
__isl_take isl_multi_aff *maff,
enum isl_dim_type type, unsigned first, unsigned n);
__isl_give isl_pw_aff *isl_pw_aff_drop_dims(
__isl_take isl_pw_aff *pwaff,
enum isl_dim_type type, unsigned first, unsigned n);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_drop_dims(
__isl_take isl_pw_multi_aff *pma,
enum isl_dim_type type, unsigned first, unsigned n);
__isl_give isl_union_pw_aff *isl_union_pw_aff_drop_dims(
__isl_take isl_union_pw_aff *upa,
enum isl_dim_type type, unsigned first, unsigned n);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_drop_dims(
__isl_take isl_union_pw_multi_aff *upma,
enum isl_dim_type type,
unsigned first, unsigned n);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_drop_dims(
__isl_take isl_multi_union_pw_aff *mupa,
enum isl_dim_type type, unsigned first,
unsigned n);
__isl_give isl_aff *isl_aff_move_dims(
__isl_take isl_aff *aff,
enum isl_dim_type dst_type, unsigned dst_pos,
enum isl_dim_type src_type, unsigned src_pos,
unsigned n);
__isl_give isl_multi_aff *isl_multi_aff_move_dims(
__isl_take isl_multi_aff *ma,
enum isl_dim_type dst_type, unsigned dst_pos,
enum isl_dim_type src_type, unsigned src_pos,
unsigned n);
__isl_give isl_pw_aff *isl_pw_aff_move_dims(
__isl_take isl_pw_aff *pa,
enum isl_dim_type dst_type, unsigned dst_pos,
enum isl_dim_type src_type, unsigned src_pos,
unsigned n);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_move_dims(
__isl_take isl_multi_pw_aff *pma,
enum isl_dim_type dst_type, unsigned dst_pos,
enum isl_dim_type src_type, unsigned src_pos,
unsigned n);
#include <isl/polynomial.h>
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_drop_dims(
__isl_take isl_union_pw_qpolynomial *upwqp,
enum isl_dim_type type,
unsigned first, unsigned n);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_drop_dims(
__isl_take isl_union_pw_qpolynomial_fold *upwf,
enum isl_dim_type type,
unsigned first, unsigned n);The operations on union expressions can only manipulate parameters.
The two arguments of a binary operation not only need to live in the same isl_ctx, they currently also need to have the same (number of) parameters.
Intersection
#include <isl/local_space.h>
__isl_give isl_local_space *isl_local_space_intersect(
__isl_take isl_local_space *ls1,
__isl_take isl_local_space *ls2);
#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_intersect_params(
__isl_take isl_basic_set *bset1,
__isl_take isl_basic_set *bset2);
__isl_give isl_basic_set *isl_basic_set_intersect(
__isl_take isl_basic_set *bset1,
__isl_take isl_basic_set *bset2);
__isl_give isl_basic_set *isl_basic_set_list_intersect(
__isl_take struct isl_basic_set_list *list);
__isl_give isl_set *isl_set_intersect_params(
__isl_take isl_set *set,
__isl_take isl_set *params);
__isl_give isl_set *isl_set_intersect(
__isl_take isl_set *set1,
__isl_take isl_set *set2);
__isl_give isl_set *isl_set_intersect_factor_domain(
__isl_take isl_set *set,
__isl_take isl_set *domain);
__isl_give isl_set *isl_set_intersect_factor_range(
__isl_take isl_set *set,
__isl_take isl_set *range);
#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_intersect_params(
__isl_take isl_basic_map *bmap,
__isl_take isl_basic_set *bset);
__isl_give isl_basic_map *isl_basic_map_intersect_domain(
__isl_take isl_basic_map *bmap,
__isl_take isl_basic_set *bset);
__isl_give isl_basic_map *isl_basic_map_intersect_range(
__isl_take isl_basic_map *bmap,
__isl_take isl_basic_set *bset);
__isl_give isl_basic_map *isl_basic_map_intersect(
__isl_take isl_basic_map *bmap1,
__isl_take isl_basic_map *bmap2);
__isl_give isl_basic_map *isl_basic_map_list_intersect(
__isl_take isl_basic_map_list *list);
__isl_give isl_map *isl_map_intersect_params(
__isl_take isl_map *map,
__isl_take isl_set *params);
__isl_give isl_map *isl_map_intersect_domain(
__isl_take isl_map *map,
__isl_take isl_set *set);
__isl_give isl_map *isl_map_intersect_range(
__isl_take isl_map *map,
__isl_take isl_set *set);
__isl_give isl_map *isl_map_intersect(
__isl_take isl_map *map1,
__isl_take isl_map *map2);
__isl_give isl_map *
isl_map_intersect_domain_factor_domain(
__isl_take isl_map *map,
__isl_take isl_map *factor);
__isl_give isl_map *
isl_map_intersect_domain_factor_range(
__isl_take isl_map *map,
__isl_take isl_map *factor);
__isl_give isl_map *
isl_map_intersect_range_factor_domain(
__isl_take isl_map *map,
__isl_take isl_map *factor);
__isl_give isl_map *
isl_map_intersect_range_factor_range(
__isl_take isl_map *map,
__isl_take isl_map *factor);
__isl_give isl_map *
isl_map_intersect_domain_wrapped_domain(
__isl_take isl_map *map,
__isl_take isl_set *domain);
__isl_give isl_map *
isl_map_intersect_range_wrapped_domain(
__isl_take isl_map *map,
__isl_take isl_set *domain);
#include <isl/union_set.h>
__isl_give isl_union_set *isl_union_set_intersect_params(
__isl_take isl_union_set *uset,
__isl_take isl_set *set);
__isl_give isl_union_set *isl_union_set_intersect(
__isl_take isl_union_set *uset1,
__isl_take isl_union_set *uset2);
#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_intersect_params(
__isl_take isl_union_map *umap,
__isl_take isl_set *set);
__isl_give isl_union_map *
isl_union_map_intersect_domain_union_set(
__isl_take isl_union_map *umap,
__isl_take isl_union_set *uset);
__isl_give isl_union_map *
isl_union_map_intersect_domain_space(
__isl_take isl_union_map *umap,
__isl_take isl_space *space);
__isl_give isl_union_map *isl_union_map_intersect_domain(
__isl_take isl_union_map *umap,
__isl_take isl_union_set *uset);
__isl_give isl_union_map *
isl_union_map_intersect_range_union_set(
__isl_take isl_union_map *umap,
__isl_take isl_union_set *uset);
__isl_give isl_union_map *
isl_union_map_intersect_range_space(
__isl_take isl_union_map *umap,
__isl_take isl_space *space);
__isl_give isl_union_map *isl_union_map_intersect_range(
__isl_take isl_union_map *umap,
__isl_take isl_union_set *uset);
__isl_give isl_union_map *isl_union_map_intersect(
__isl_take isl_union_map *umap1,
__isl_take isl_union_map *umap2);
__isl_give isl_union_map *
isl_union_map_intersect_domain_factor_domain(
__isl_take isl_union_map *umap,
__isl_take isl_union_map *factor);
__isl_give isl_union_map *
isl_union_map_intersect_domain_factor_range(
__isl_take isl_union_map *umap,
__isl_take isl_union_map *factor);
__isl_give isl_union_map *
isl_union_map_intersect_range_factor_domain(
__isl_take isl_union_map *umap,
__isl_take isl_union_map *factor);
__isl_give isl_union_map *
isl_union_map_intersect_range_factor_range(
__isl_take isl_union_map *umap,
__isl_take isl_union_map *factor);
__isl_give isl_union_map *
isl_union_map_intersect_domain_wrapped_domain_union_set(
__isl_take isl_union_map *umap,
__isl_take isl_union_set *domain);
__isl_give isl_union_map *
isl_union_map_intersect_range_wrapped_domain_union_set(
__isl_take isl_union_map *umap,
__isl_take isl_union_set *domain);
#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_intersect_domain(
__isl_take isl_pw_aff *pa,
__isl_take isl_set *set);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_intersect_domain(
__isl_take isl_multi_pw_aff *mpa,
__isl_take isl_set *domain);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_domain(
__isl_take isl_pw_multi_aff *pma,
__isl_take isl_set *set);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_intersect_domain_space(
__isl_take isl_union_pw_aff *upa,
__isl_take isl_space *space);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_intersect_domain_union_set(
__isl_take isl_union_pw_aff *upa,
__isl_take isl_union_set *uset);
__isl_give isl_union_pw_aff *isl_union_pw_aff_intersect_domain(
__isl_take isl_union_pw_aff *upa,
__isl_take isl_union_set *uset);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_intersect_domain_space(
__isl_take isl_union_pw_multi_aff *upma,
__isl_take isl_space *space);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_intersect_domain_union_set(
__isl_take isl_union_pw_multi_aff *upma,
__isl_take isl_union_set *uset);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_intersect_domain(
__isl_take isl_union_pw_multi_aff *upma,
__isl_take isl_union_set *uset);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_intersect_domain(
__isl_take isl_multi_union_pw_aff *mupa,
__isl_take isl_union_set *uset);
__isl_give isl_pw_aff *
isl_pw_aff_intersect_domain_wrapped_domain(
__isl_take isl_pw_aff *pa,
__isl_take isl_set *set);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_intersect_domain_wrapped_domain(
__isl_take isl_pw_multi_aff *pma,
__isl_take isl_set *set);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_intersect_domain_wrapped_domain(
__isl_take isl_union_pw_aff *upa,
__isl_take isl_union_set *uset);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_intersect_domain_wrapped_domain(
__isl_take isl_union_pw_multi_aff *upma,
__isl_take isl_union_set *uset);
__isl_give isl_pw_aff *
isl_pw_aff_intersect_domain_wrapped_range(
__isl_take isl_pw_aff *pa,
__isl_take isl_set *set);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_intersect_domain_wrapped_range(
__isl_take isl_pw_multi_aff *pma,
__isl_take isl_set *set);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_intersect_domain_wrapped_range(
__isl_take isl_union_pw_multi_aff *upma,
__isl_take isl_union_set *uset);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_intersect_domain_wrapped_range(
__isl_take isl_union_pw_aff *upa,
__isl_take isl_union_set *uset);
__isl_give isl_pw_aff *isl_pw_aff_intersect_params(
__isl_take isl_pw_aff *pa,
__isl_take isl_set *set);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_intersect_params(
__isl_take isl_multi_pw_aff *mpa,
__isl_take isl_set *set);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_params(
__isl_take isl_pw_multi_aff *pma,
__isl_take isl_set *set);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_intersect_params(
__isl_take isl_union_pw_aff *upa,
__isl_take isl_set *set);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_intersect_params(
__isl_take isl_union_pw_multi_aff *upma,
__isl_take isl_set *set);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_intersect_params(
__isl_take isl_multi_union_pw_aff *mupa,
__isl_take isl_set *params);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_intersect_range(
__isl_take isl_multi_union_pw_aff *mupa,
__isl_take isl_set *set);
#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial *
isl_pw_qpolynomial_intersect_domain(
__isl_take isl_pw_qpolynomial *pwpq,
__isl_take isl_set *set);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_intersect_domain_space(
__isl_take isl_union_pw_qpolynomial *upwpq,
__isl_take isl_space *space);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_intersect_domain_union_set(
__isl_take isl_union_pw_qpolynomial *upwpq,
__isl_take isl_union_set *uset);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_intersect_domain(
__isl_take isl_union_pw_qpolynomial *upwpq,
__isl_take isl_union_set *uset);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_intersect_domain_space(
__isl_take isl_union_pw_qpolynomial_fold *upwf,
__isl_take isl_space *space);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_intersect_domain_union_set(
__isl_take isl_union_pw_qpolynomial_fold *upwf,
__isl_take isl_union_set *uset);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_intersect_domain(
__isl_take isl_union_pw_qpolynomial_fold *upwf,
__isl_take isl_union_set *uset);
__isl_give isl_pw_qpolynomial *
isl_pw_qpolynomial_intersect_domain_wrapped_domain(
__isl_take isl_pw_qpolynomial *pwpq,
__isl_take isl_set *set);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_intersect_domain_wrapped_domain(
__isl_take isl_pw_qpolynomial_fold *pwf,
__isl_take isl_set *set);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_intersect_domain_wrapped_domain(
__isl_take isl_union_pw_qpolynomial *upwpq,
__isl_take isl_union_set *uset);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_intersect_domain_wrapped_domain(
__isl_take isl_union_pw_qpolynomial_fold *upwf,
__isl_take isl_union_set *uset);
__isl_give isl_pw_qpolynomial *
isl_pw_qpolynomial_intersect_domain_wrapped_range(
__isl_take isl_pw_qpolynomial *pwpq,
__isl_take isl_set *set);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_intersect_domain_wrapped_range(
__isl_take isl_pw_qpolynomial_fold *pwf,
__isl_take isl_set *set);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_intersect_domain_wrapped_range(
__isl_take isl_union_pw_qpolynomial *upwpq,
__isl_take isl_union_set *uset);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_intersect_domain_wrapped_range(
__isl_take isl_union_pw_qpolynomial_fold *upwf,
__isl_take isl_union_set *uset);
__isl_give isl_pw_qpolynomial *
isl_pw_qpolynomial_intersect_params(
__isl_take isl_pw_qpolynomial *pwpq,
__isl_take isl_set *set);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_intersect_params(
__isl_take isl_pw_qpolynomial_fold *pwf,
__isl_take isl_set *set);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_intersect_params(
__isl_take isl_union_pw_qpolynomial *upwpq,
__isl_take isl_set *set);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_intersect_params(
__isl_take isl_union_pw_qpolynomial_fold *upwf,
__isl_take isl_set *set);The second argument to the _params functions needs to be a parametric (basic) set. For the other functions, a parametric set for either argument is only allowed if the other argument is a parametric set as well. The list passed to isl_basic_set_list_intersect needs to have at least one element and all elements need to live in the same space. The function isl_multi_union_pw_aff_intersect_range restricts the input function to those shared domain elements that map to the specified range. isl_union_map_intersect_domain is an alternative name for isl_union_map_intersect_domain_union_set. Similarly for the other pairs of functions.
Union
#include <isl/set.h>
__isl_give isl_set *isl_basic_set_union(
__isl_take isl_basic_set *bset1,
__isl_take isl_basic_set *bset2);
__isl_give isl_set *isl_set_union(
__isl_take isl_set *set1,
__isl_take isl_set *set2);
__isl_give isl_set *isl_set_list_union(
__isl_take isl_set_list *list);
#include <isl/map.h>
__isl_give isl_map *isl_basic_map_union(
__isl_take isl_basic_map *bmap1,
__isl_take isl_basic_map *bmap2);
__isl_give isl_map *isl_map_union(
__isl_take isl_map *map1,
__isl_take isl_map *map2);
#include <isl/union_set.h>
__isl_give isl_union_set *isl_union_set_union(
__isl_take isl_union_set *uset1,
__isl_take isl_union_set *uset2);
__isl_give isl_union_set *isl_union_set_list_union(
__isl_take isl_union_set_list *list);
#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_union(
__isl_take isl_union_map *umap1,
__isl_take isl_union_map *umap2);The list passed to isl_set_list_union needs to have at least one element and all elements need to live in the same space.
Set difference
#include <isl/set.h>
__isl_give isl_set *isl_set_subtract(
__isl_take isl_set *set1,
__isl_take isl_set *set2);
#include <isl/map.h>
__isl_give isl_map *isl_map_subtract(
__isl_take isl_map *map1,
__isl_take isl_map *map2);
__isl_give isl_map *isl_map_subtract_domain(
__isl_take isl_map *map,
__isl_take isl_set *dom);
__isl_give isl_map *isl_map_subtract_range(
__isl_take isl_map *map,
__isl_take isl_set *dom);
#include <isl/union_set.h>
__isl_give isl_union_set *isl_union_set_subtract(
__isl_take isl_union_set *uset1,
__isl_take isl_union_set *uset2);
#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_subtract(
__isl_take isl_union_map *umap1,
__isl_take isl_union_map *umap2);
__isl_give isl_union_map *isl_union_map_subtract_domain(
__isl_take isl_union_map *umap,
__isl_take isl_union_set *dom);
__isl_give isl_union_map *isl_union_map_subtract_range(
__isl_take isl_union_map *umap,
__isl_take isl_union_set *dom);
#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_subtract_domain(
__isl_take isl_pw_aff *pa,
__isl_take isl_set *set);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_subtract_domain(
__isl_take isl_pw_multi_aff *pma,
__isl_take isl_set *set);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_subtract_domain_union_set(
__isl_take isl_union_pw_aff *upa,
__isl_take isl_union_set *uset);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_subtract_domain_space(
__isl_take isl_union_pw_aff *upa,
__isl_take isl_space *space);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_subtract_domain(
__isl_take isl_union_pw_aff *upa,
__isl_take isl_union_set *uset);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_subtract_domain_union_set(
__isl_take isl_union_pw_multi_aff *upma,
__isl_take isl_set *set);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_subtract_domain_space(
__isl_take isl_union_pw_multi_aff *upma,
__isl_take isl_space *space);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_subtract_domain(
__isl_take isl_union_pw_multi_aff *upma,
__isl_take isl_union_set *uset);
#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial *
isl_pw_qpolynomial_subtract_domain(
__isl_take isl_pw_qpolynomial *pwpq,
__isl_take isl_set *set);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_subtract_domain(
__isl_take isl_pw_qpolynomial_fold *pwf,
__isl_take isl_set *set);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_subtract_domain_union_set(
__isl_take isl_union_pw_qpolynomial *upwpq,
__isl_take isl_union_set *uset);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_subtract_domain_space(
__isl_take isl_union_pw_qpolynomial *upwpq,
__isl_take isl_space *space);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_subtract_domain(
__isl_take isl_union_pw_qpolynomial *upwpq,
__isl_take isl_union_set *uset);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_subtract_domain_union_set(
__isl_take isl_union_pw_qpolynomial_fold *upwf,
__isl_take isl_union_set *uset);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_subtract_domain_space(
__isl_take isl_union_pw_qpolynomial_fold *upwf,
__isl_take isl_space *space);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_subtract_domain(
__isl_take isl_union_pw_qpolynomial_fold *upwf,
__isl_take isl_union_set *uset);isl_union_pw_aff_subtract_domain is an alternative name for isl_union_pw_aff_subtract_domain_union_set. Similarly for the other pairs of functions.
Application
#include <isl/space.h>
__isl_give isl_space *isl_space_join(
__isl_take isl_space *left,
__isl_take isl_space *right);
#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_apply(
__isl_take isl_basic_set *bset,
__isl_take isl_basic_map *bmap);
__isl_give isl_set *isl_set_apply(
__isl_take isl_set *set,
__isl_take isl_map *map);
#include <isl/union_set.h>
__isl_give isl_union_set *isl_union_set_apply(
__isl_take isl_union_set *uset,
__isl_take isl_union_map *umap);
#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_apply_domain(
__isl_take isl_basic_map *bmap1,
__isl_take isl_basic_map *bmap2);
__isl_give isl_basic_map *isl_basic_map_apply_range(
__isl_take isl_basic_map *bmap1,
__isl_take isl_basic_map *bmap2);
__isl_give isl_map *isl_map_apply_domain(
__isl_take isl_map *map1,
__isl_take isl_map *map2);
__isl_give isl_map *isl_map_apply_range(
__isl_take isl_map *map1,
__isl_take isl_map *map2);
#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_apply_domain(
__isl_take isl_union_map *umap1,
__isl_take isl_union_map *umap2);
__isl_give isl_union_map *isl_union_map_apply_range(
__isl_take isl_union_map *umap1,
__isl_take isl_union_map *umap2);
#include <isl/aff.h>
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_apply_union_pw_multi_aff(
__isl_take isl_union_pw_multi_aff *upma1,
__isl_take isl_union_pw_multi_aff *upma2);
__isl_give isl_union_pw_aff *
isl_multi_union_pw_aff_apply_aff(
__isl_take isl_multi_union_pw_aff *mupa,
__isl_take isl_aff *aff);
__isl_give isl_union_pw_aff *
isl_multi_union_pw_aff_apply_pw_aff(
__isl_take isl_multi_union_pw_aff *mupa,
__isl_take isl_pw_aff *pa);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_apply_multi_aff(
__isl_take isl_multi_union_pw_aff *mupa,
__isl_take isl_multi_aff *ma);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_apply_pw_multi_aff(
__isl_take isl_multi_union_pw_aff *mupa,
__isl_take isl_pw_multi_aff *pma);The result of isl_multi_union_pw_aff_apply_aff is defined over the shared domain of the elements of the input. The dimension is required to be greater than zero. The isl_multi_union_pw_aff argument of isl_multi_union_pw_aff_apply_multi_aff is allowed to be zero-dimensional, but only if the range of the isl_multi_aff argument is also zero-dimensional. Similarly for isl_multi_union_pw_aff_apply_pw_multi_aff.
#include <isl/polynomial.h>
__isl_give isl_pw_qpolynomial_fold *
isl_set_apply_pw_qpolynomial_fold(
__isl_take isl_set *set,
__isl_take isl_pw_qpolynomial_fold *pwf,
isl_bool *tight);
__isl_give isl_pw_qpolynomial_fold *
isl_map_apply_pw_qpolynomial_fold(
__isl_take isl_map *map,
__isl_take isl_pw_qpolynomial_fold *pwf,
isl_bool *tight);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_set_apply_union_pw_qpolynomial_fold(
__isl_take isl_union_set *uset,
__isl_take isl_union_pw_qpolynomial_fold *upwf,
isl_bool *tight);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_map_apply_union_pw_qpolynomial_fold(
__isl_take isl_union_map *umap,
__isl_take isl_union_pw_qpolynomial_fold *upwf,
isl_bool *tight);The functions taking a map compose the given map with the given piecewise quasipolynomial reduction. That is, compute a bound (of the same type as pwf or upwf itself) over all elements in the intersection of the range of the map and the domain of the piecewise quasipolynomial reduction as a function of an element in the domain of the map. The functions taking a set compute a bound over all elements in the intersection of the set and the domain of the piecewise quasipolynomial reduction.
Preimage
#include <isl/set.h>
__isl_give isl_basic_set *
isl_basic_set_preimage_multi_aff(
__isl_take isl_basic_set *bset,
__isl_take isl_multi_aff *ma);
__isl_give isl_set *isl_set_preimage_multi_aff(
__isl_take isl_set *set,
__isl_take isl_multi_aff *ma);
__isl_give isl_set *isl_set_preimage_pw_multi_aff(
__isl_take isl_set *set,
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_set *isl_set_preimage_multi_pw_aff(
__isl_take isl_set *set,
__isl_take isl_multi_pw_aff *mpa);
#include <isl/union_set.h>
__isl_give isl_union_set *
isl_union_set_preimage_multi_aff(
__isl_take isl_union_set *uset,
__isl_take isl_multi_aff *ma);
__isl_give isl_union_set *
isl_union_set_preimage_pw_multi_aff(
__isl_take isl_union_set *uset,
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_union_set *
isl_union_set_preimage_union_pw_multi_aff(
__isl_take isl_union_set *uset,
__isl_take isl_union_pw_multi_aff *upma);
#include <isl/map.h>
__isl_give isl_basic_map *
isl_basic_map_preimage_domain_multi_aff(
__isl_take isl_basic_map *bmap,
__isl_take isl_multi_aff *ma);
__isl_give isl_map *isl_map_preimage_domain_multi_aff(
__isl_take isl_map *map,
__isl_take isl_multi_aff *ma);
__isl_give isl_map *isl_map_preimage_range_multi_aff(
__isl_take isl_map *map,
__isl_take isl_multi_aff *ma);
__isl_give isl_map *
isl_map_preimage_domain_pw_multi_aff(
__isl_take isl_map *map,
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_map *
isl_map_preimage_range_pw_multi_aff(
__isl_take isl_map *map,
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_map *
isl_map_preimage_domain_multi_pw_aff(
__isl_take isl_map *map,
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_basic_map *
isl_basic_map_preimage_range_multi_aff(
__isl_take isl_basic_map *bmap,
__isl_take isl_multi_aff *ma);
#include <isl/union_map.h>
__isl_give isl_union_map *
isl_union_map_preimage_domain_multi_aff(
__isl_take isl_union_map *umap,
__isl_take isl_multi_aff *ma);
__isl_give isl_union_map *
isl_union_map_preimage_range_multi_aff(
__isl_take isl_union_map *umap,
__isl_take isl_multi_aff *ma);
__isl_give isl_union_map *
isl_union_map_preimage_domain_pw_multi_aff(
__isl_take isl_union_map *umap,
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_union_map *
isl_union_map_preimage_range_pw_multi_aff(
__isl_take isl_union_map *umap,
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_union_map *
isl_union_map_preimage_domain_union_pw_multi_aff(
__isl_take isl_union_map *umap,
__isl_take isl_union_pw_multi_aff *upma);
__isl_give isl_union_map *
isl_union_map_preimage_range_union_pw_multi_aff(
__isl_take isl_union_map *umap,
__isl_take isl_union_pw_multi_aff *upma);
#include <isl/aff.h>
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_preimage_domain_wrapped_domain_pw_multi_aff(
__isl_take isl_pw_multi_aff *pma1,
__isl_take isl_pw_multi_aff *pma2);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff(
__isl_take isl_union_pw_multi_aff *upma1,
__isl_take isl_union_pw_multi_aff *upma2);These functions compute the preimage of the given set or map domain/range under the given function. In other words, the expression is plugged into the set description or into the domain/range of the map or function.
Pullback
#include <isl/aff.h>
__isl_give isl_aff *isl_aff_pullback_aff(
__isl_take isl_aff *aff1,
__isl_take isl_aff *aff2);
__isl_give isl_aff *isl_aff_pullback_multi_aff(
__isl_take isl_aff *aff,
__isl_take isl_multi_aff *ma);
__isl_give isl_pw_aff *isl_pw_aff_pullback_multi_aff(
__isl_take isl_pw_aff *pa,
__isl_take isl_multi_aff *ma);
__isl_give isl_pw_aff *isl_pw_aff_pullback_pw_multi_aff(
__isl_take isl_pw_aff *pa,
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_pw_aff *isl_pw_aff_pullback_multi_pw_aff(
__isl_take isl_pw_aff *pa,
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_multi_aff *isl_multi_aff_pullback_multi_aff(
__isl_take isl_multi_aff *ma1,
__isl_take isl_multi_aff *ma2);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_pullback_multi_aff(
__isl_take isl_pw_multi_aff *pma,
__isl_take isl_multi_aff *ma);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_pullback_multi_aff(
__isl_take isl_multi_pw_aff *mpa,
__isl_take isl_multi_aff *ma);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_pullback_pw_multi_aff(
__isl_take isl_pw_multi_aff *pma1,
__isl_take isl_pw_multi_aff *pma2);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_pullback_pw_multi_aff(
__isl_take isl_multi_pw_aff *mpa,
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_pullback_multi_pw_aff(
__isl_take isl_multi_pw_aff *mpa1,
__isl_take isl_multi_pw_aff *mpa2);
__isl_give isl_union_pw_aff *
isl_union_pw_aff_pullback_union_pw_multi_aff(
__isl_take isl_union_pw_aff *upa,
__isl_take isl_union_pw_multi_aff *upma);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_pullback_union_pw_multi_aff(
__isl_take isl_union_pw_multi_aff *upma1,
__isl_take isl_union_pw_multi_aff *upma2);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_pullback_union_pw_multi_aff(
__isl_take isl_multi_union_pw_aff *mupa,
__isl_take isl_union_pw_multi_aff *upma);These functions precompose the first expression by the second function. In other words, the second function is plugged into the first expression.
Locus
#include <isl/aff.h>
__isl_give isl_basic_set *isl_aff_eq_basic_set(
__isl_take isl_aff *aff1,
__isl_take isl_aff *aff2);
__isl_give isl_set *isl_aff_eq_set(
__isl_take isl_aff *aff1,
__isl_take isl_aff *aff2);
__isl_give isl_set *isl_aff_ne_set(
__isl_take isl_aff *aff1,
__isl_take isl_aff *aff2);
__isl_give isl_basic_set *isl_aff_le_basic_set(
__isl_take isl_aff *aff1,
__isl_take isl_aff *aff2);
__isl_give isl_set *isl_aff_le_set(
__isl_take isl_aff *aff1,
__isl_take isl_aff *aff2);
__isl_give isl_basic_set *isl_aff_lt_basic_set(
__isl_take isl_aff *aff1,
__isl_take isl_aff *aff2);
__isl_give isl_set *isl_aff_lt_set(
__isl_take isl_aff *aff1,
__isl_take isl_aff *aff2);
__isl_give isl_basic_set *isl_aff_ge_basic_set(
__isl_take isl_aff *aff1,
__isl_take isl_aff *aff2);
__isl_give isl_set *isl_aff_ge_set(
__isl_take isl_aff *aff1,
__isl_take isl_aff *aff2);
__isl_give isl_basic_set *isl_aff_gt_basic_set(
__isl_take isl_aff *aff1,
__isl_take isl_aff *aff2);
__isl_give isl_set *isl_aff_gt_set(
__isl_take isl_aff *aff1,
__isl_take isl_aff *aff2);
__isl_give isl_set *isl_pw_aff_eq_set(
__isl_take isl_pw_aff *pwaff1,
__isl_take isl_pw_aff *pwaff2);
__isl_give isl_set *isl_pw_aff_ne_set(
__isl_take isl_pw_aff *pwaff1,
__isl_take isl_pw_aff *pwaff2);
__isl_give isl_set *isl_pw_aff_le_set(
__isl_take isl_pw_aff *pwaff1,
__isl_take isl_pw_aff *pwaff2);
__isl_give isl_set *isl_pw_aff_lt_set(
__isl_take isl_pw_aff *pwaff1,
__isl_take isl_pw_aff *pwaff2);
__isl_give isl_set *isl_pw_aff_ge_set(
__isl_take isl_pw_aff *pwaff1,
__isl_take isl_pw_aff *pwaff2);
__isl_give isl_set *isl_pw_aff_gt_set(
__isl_take isl_pw_aff *pwaff1,
__isl_take isl_pw_aff *pwaff2);
__isl_give isl_set *isl_multi_aff_lex_le_set(
__isl_take isl_multi_aff *ma1,
__isl_take isl_multi_aff *ma2);
__isl_give isl_set *isl_multi_aff_lex_lt_set(
__isl_take isl_multi_aff *ma1,
__isl_take isl_multi_aff *ma2);
__isl_give isl_set *isl_multi_aff_lex_ge_set(
__isl_take isl_multi_aff *ma1,
__isl_take isl_multi_aff *ma2);
__isl_give isl_set *isl_multi_aff_lex_gt_set(
__isl_take isl_multi_aff *ma1,
__isl_take isl_multi_aff *ma2);
__isl_give isl_set *isl_pw_aff_list_eq_set(
__isl_take isl_pw_aff_list *list1,
__isl_take isl_pw_aff_list *list2);
__isl_give isl_set *isl_pw_aff_list_ne_set(
__isl_take isl_pw_aff_list *list1,
__isl_take isl_pw_aff_list *list2);
__isl_give isl_set *isl_pw_aff_list_le_set(
__isl_take isl_pw_aff_list *list1,
__isl_take isl_pw_aff_list *list2);
__isl_give isl_set *isl_pw_aff_list_lt_set(
__isl_take isl_pw_aff_list *list1,
__isl_take isl_pw_aff_list *list2);
__isl_give isl_set *isl_pw_aff_list_ge_set(
__isl_take isl_pw_aff_list *list1,
__isl_take isl_pw_aff_list *list2);
__isl_give isl_set *isl_pw_aff_list_gt_set(
__isl_take isl_pw_aff_list *list1,
__isl_take isl_pw_aff_list *list2);The function isl_aff_ge_basic_set returns a basic set containing those elements in the shared space of aff1 and aff2 where aff1 is greater than or equal to aff2. The function isl_pw_aff_ge_set returns a set containing those elements in the shared domain of pwaff1 and pwaff2 where pwaff1 is greater than or equal to pwaff2. The function isl_multi_aff_lex_le_set returns a set containing those elements in the shared domain space where ma1 is lexicographically smaller than or equal to ma2. The functions operating on isl_pw_aff_list apply the corresponding isl_pw_aff function to each pair of elements in the two lists.
#include <isl/aff.h>
__isl_give isl_map *isl_pw_aff_eq_map(
__isl_take isl_pw_aff *pa1,
__isl_take isl_pw_aff *pa2);
__isl_give isl_map *isl_pw_aff_le_map(
__isl_take isl_pw_aff *pa1,
__isl_take isl_pw_aff *pa2);
__isl_give isl_map *isl_pw_aff_lt_map(
__isl_take isl_pw_aff *pa1,
__isl_take isl_pw_aff *pa2);
__isl_give isl_map *isl_pw_aff_ge_map(
__isl_take isl_pw_aff *pa1,
__isl_take isl_pw_aff *pa2);
__isl_give isl_map *isl_pw_aff_gt_map(
__isl_take isl_pw_aff *pa1,
__isl_take isl_pw_aff *pa2);
__isl_give isl_map *isl_multi_pw_aff_eq_map(
__isl_take isl_multi_pw_aff *mpa1,
__isl_take isl_multi_pw_aff *mpa2);
__isl_give isl_map *isl_multi_pw_aff_lex_le_map(
__isl_take isl_multi_pw_aff *mpa1,
__isl_take isl_multi_pw_aff *mpa2);
__isl_give isl_map *isl_multi_pw_aff_lex_lt_map(
__isl_take isl_multi_pw_aff *mpa1,
__isl_take isl_multi_pw_aff *mpa2);
__isl_give isl_map *isl_multi_pw_aff_lex_ge_map(
__isl_take isl_multi_pw_aff *mpa1,
__isl_take isl_multi_pw_aff *mpa2);
__isl_give isl_map *isl_multi_pw_aff_lex_gt_map(
__isl_take isl_multi_pw_aff *mpa1,
__isl_take isl_multi_pw_aff *mpa2);These functions return a map between domain elements of the arguments where the function values satisfy the given relation.
#include <isl/map.h>
__isl_give isl_map *isl_map_eq_at_multi_pw_aff(
__isl_take isl_map *map,
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_map *isl_map_lex_lt_at_multi_pw_aff(
__isl_take isl_map *map,
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_map *isl_map_lex_le_at_multi_pw_aff(
__isl_take isl_map *map,
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_map *isl_map_lex_gt_at_multi_pw_aff(
__isl_take isl_map *map,
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_map *isl_map_lex_ge_at_multi_pw_aff(
__isl_take isl_map *map,
__isl_take isl_multi_pw_aff *mpa);
#include <isl/union_map.h>
__isl_give isl_union_map *
isl_union_map_eq_at_multi_union_pw_aff(
__isl_take isl_union_map *umap,
__isl_take isl_multi_union_pw_aff *mupa);
__isl_give isl_union_map *
isl_union_map_lex_lt_at_multi_union_pw_aff(
__isl_take isl_union_map *umap,
__isl_take isl_multi_union_pw_aff *mupa);
__isl_give isl_union_map *
isl_union_map_lex_le_at_multi_union_pw_aff(
__isl_take isl_union_map *umap,
__isl_take isl_multi_union_pw_aff *mupa);
__isl_give isl_union_map *
isl_union_map_lex_gt_at_multi_union_pw_aff(
__isl_take isl_union_map *umap,
__isl_take isl_multi_union_pw_aff *mupa);
__isl_give isl_union_map *
isl_union_map_lex_ge_at_multi_union_pw_aff(
__isl_take isl_union_map *umap,
__isl_take isl_multi_union_pw_aff *mupa);These functions select the subset of elements in the union map that have an equal or lexicographically smaller or greater function value.
Cartesian Product
#include <isl/space.h>
__isl_give isl_space *isl_space_product(
__isl_take isl_space *space1,
__isl_take isl_space *space2);
__isl_give isl_space *isl_space_domain_product(
__isl_take isl_space *space1,
__isl_take isl_space *space2);
__isl_give isl_space *isl_space_range_product(
__isl_take isl_space *space1,
__isl_take isl_space *space2);The functions isl_space_product, isl_space_domain_product and isl_space_range_product take pairs or relation spaces and produce a single relations space, where either the domain, the range or both domain and range are wrapped spaces of relations between the domains and/or ranges of the input spaces. If the product is only constructed over the domain or the range then the ranges or the domains of the inputs should be the same. The function isl_space_product also accepts a pair of set spaces, in which case it returns a wrapped space of a relation between the two input spaces.
#include <isl/set.h>
__isl_give isl_set *isl_set_product(
__isl_take isl_set *set1,
__isl_take isl_set *set2);
#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_domain_product(
__isl_take isl_basic_map *bmap1,
__isl_take isl_basic_map *bmap2);
__isl_give isl_basic_map *isl_basic_map_range_product(
__isl_take isl_basic_map *bmap1,
__isl_take isl_basic_map *bmap2);
__isl_give isl_basic_map *isl_basic_map_product(
__isl_take isl_basic_map *bmap1,
__isl_take isl_basic_map *bmap2);
__isl_give isl_map *isl_map_domain_product(
__isl_take isl_map *map1,
__isl_take isl_map *map2);
__isl_give isl_map *isl_map_range_product(
__isl_take isl_map *map1,
__isl_take isl_map *map2);
__isl_give isl_map *isl_map_product(
__isl_take isl_map *map1,
__isl_take isl_map *map2);
#include <isl/union_set.h>
__isl_give isl_union_set *isl_union_set_product(
__isl_take isl_union_set *uset1,
__isl_take isl_union_set *uset2);
#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_domain_product(
__isl_take isl_union_map *umap1,
__isl_take isl_union_map *umap2);
__isl_give isl_union_map *isl_union_map_range_product(
__isl_take isl_union_map *umap1,
__isl_take isl_union_map *umap2);
__isl_give isl_union_map *isl_union_map_product(
__isl_take isl_union_map *umap1,
__isl_take isl_union_map *umap2);
#include <isl/id.h>
__isl_give isl_multi_id *isl_multi_id_range_product(
__isl_take isl_multi_id *mi1,
__isl_take isl_multi_id *mi2);
#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_range_product(
__isl_take isl_multi_val *mv1,
__isl_take isl_multi_val *mv2);
__isl_give isl_multi_val *isl_multi_val_product(
__isl_take isl_multi_val *mv1,
__isl_take isl_multi_val *mv2);
#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_range_product(
__isl_take isl_multi_aff *ma1,
__isl_take isl_multi_aff *ma2);
__isl_give isl_multi_aff *isl_multi_aff_product(
__isl_take isl_multi_aff *ma1,
__isl_take isl_multi_aff *ma2);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_range_product(
__isl_take isl_multi_pw_aff *mpa1,
__isl_take isl_multi_pw_aff *mpa2);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_product(
__isl_take isl_multi_pw_aff *mpa1,
__isl_take isl_multi_pw_aff *mpa2);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_range_product(
__isl_take isl_pw_multi_aff *pma1,
__isl_take isl_pw_multi_aff *pma2);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_product(
__isl_take isl_pw_multi_aff *pma1,
__isl_take isl_pw_multi_aff *pma2);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_range_product(
__isl_take isl_union_pw_multi_aff *upma1,
__isl_take isl_union_pw_multi_aff *upma2);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_range_product(
__isl_take isl_multi_union_pw_aff *mupa1,
__isl_take isl_multi_union_pw_aff *mupa2);The above functions compute the cross product of the given sets, relations or functions. The domains and ranges of the results are wrapped maps between domains and ranges of the inputs. To obtain a ``flat'' product, use the following functions instead.
#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_flat_product(
__isl_take isl_basic_set *bset1,
__isl_take isl_basic_set *bset2);
__isl_give isl_set *isl_set_flat_product(
__isl_take isl_set *set1,
__isl_take isl_set *set2);
#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_flat_range_product(
__isl_take isl_basic_map *bmap1,
__isl_take isl_basic_map *bmap2);
__isl_give isl_map *isl_map_flat_domain_product(
__isl_take isl_map *map1,
__isl_take isl_map *map2);
__isl_give isl_map *isl_map_flat_range_product(
__isl_take isl_map *map1,
__isl_take isl_map *map2);
__isl_give isl_basic_map *isl_basic_map_flat_product(
__isl_take isl_basic_map *bmap1,
__isl_take isl_basic_map *bmap2);
__isl_give isl_map *isl_map_flat_product(
__isl_take isl_map *map1,
__isl_take isl_map *map2);
#include <isl/union_map.h>
__isl_give isl_union_map *
isl_union_map_flat_domain_product(
__isl_take isl_union_map *umap1,
__isl_take isl_union_map *umap2);
__isl_give isl_union_map *
isl_union_map_flat_range_product(
__isl_take isl_union_map *umap1,
__isl_take isl_union_map *umap2);
#include <isl/id.h>
__isl_give isl_multi_id *
isl_multi_id_flat_range_product(
__isl_take isl_multi_id *mi1,
__isl_take isl_multi_id *mi2);
#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_flat_range_product(
__isl_take isl_multi_val *mv1,
__isl_take isl_multi_val *mv2);
#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_flat_range_product(
__isl_take isl_multi_aff *ma1,
__isl_take isl_multi_aff *ma2);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_flat_range_product(
__isl_take isl_pw_multi_aff *pma1,
__isl_take isl_pw_multi_aff *pma2);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_flat_range_product(
__isl_take isl_multi_pw_aff *mpa1,
__isl_take isl_multi_pw_aff *mpa2);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_flat_range_product(
__isl_take isl_union_pw_multi_aff *upma1,
__isl_take isl_union_pw_multi_aff *upma2);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_flat_range_product(
__isl_take isl_multi_union_pw_aff *mupa1,
__isl_take isl_multi_union_pw_aff *mupa2);
#include <isl/space.h>
__isl_give isl_space *isl_space_factor_domain(
__isl_take isl_space *space);
__isl_give isl_space *isl_space_factor_range(
__isl_take isl_space *space);
__isl_give isl_space *isl_space_domain_factor_domain(
__isl_take isl_space *space);
__isl_give isl_space *isl_space_domain_factor_range(
__isl_take isl_space *space);
__isl_give isl_space *isl_space_range_factor_domain(
__isl_take isl_space *space);
__isl_give isl_space *isl_space_range_factor_range(
__isl_take isl_space *space);The functions isl_space_range_factor_domain and isl_space_range_factor_range extract the two arguments from the result of a call to isl_space_range_product.
The arguments of a call to a product can be extracted from the result using the following functions.
#include <isl/map.h>
__isl_give isl_map *isl_map_factor_domain(
__isl_take isl_map *map);
__isl_give isl_map *isl_map_factor_range(
__isl_take isl_map *map);
__isl_give isl_map *isl_map_domain_factor_domain(
__isl_take isl_map *map);
__isl_give isl_map *isl_map_domain_factor_range(
__isl_take isl_map *map);
__isl_give isl_map *isl_map_range_factor_domain(
__isl_take isl_map *map);
__isl_give isl_map *isl_map_range_factor_range(
__isl_take isl_map *map);
#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_factor_domain(
__isl_take isl_union_map *umap);
__isl_give isl_union_map *isl_union_map_factor_range(
__isl_take isl_union_map *umap);
__isl_give isl_union_map *
isl_union_map_domain_factor_domain(
__isl_take isl_union_map *umap);
__isl_give isl_union_map *
isl_union_map_domain_factor_range(
__isl_take isl_union_map *umap);
__isl_give isl_union_map *
isl_union_map_range_factor_domain(
__isl_take isl_union_map *umap);
__isl_give isl_union_map *
isl_union_map_range_factor_range(
__isl_take isl_union_map *umap);
#include <isl/id.h>
__isl_give isl_multi_id *isl_multi_id_factor_range(
__isl_take isl_multi_id *mi);
__isl_give isl_multi_id *
isl_multi_id_range_factor_domain(
__isl_take isl_multi_id *mi);
__isl_give isl_multi_id *
isl_multi_id_range_factor_range(
__isl_take isl_multi_id *mi);
#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_factor_range(
__isl_take isl_multi_val *mv);
__isl_give isl_multi_val *
isl_multi_val_range_factor_domain(
__isl_take isl_multi_val *mv);
__isl_give isl_multi_val *
isl_multi_val_range_factor_range(
__isl_take isl_multi_val *mv);
#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_factor_range(
__isl_take isl_multi_aff *ma);
__isl_give isl_multi_aff *
isl_multi_aff_range_factor_domain(
__isl_take isl_multi_aff *ma);
__isl_give isl_multi_aff *
isl_multi_aff_range_factor_range(
__isl_take isl_multi_aff *ma);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_factor_range(
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_range_factor_domain(
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_range_factor_range(
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_range_factor_domain(
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_range_factor_range(
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_range_factor_domain(
__isl_take isl_union_pw_multi_aff *upma);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_range_factor_range(
__isl_take isl_union_pw_multi_aff *upma);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_factor_range(
__isl_take isl_multi_union_pw_aff *mupa);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_range_factor_domain(
__isl_take isl_multi_union_pw_aff *mupa);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_range_factor_range(
__isl_take isl_multi_union_pw_aff *mupa);The splice functions are a generalization of the flat product functions, where the second argument may be inserted at any position inside the first argument rather than being placed at the end. The functions isl_multi_val_factor_range, isl_multi_aff_factor_range, isl_multi_pw_aff_factor_range and isl_multi_union_pw_aff_factor_range take functions that live in a set space.
#include <isl/id.h>
__isl_give isl_multi_id *isl_multi_id_range_splice(
__isl_take isl_multi_id *mi1, unsigned pos,
__isl_take isl_multi_id *mi2);
#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_range_splice(
__isl_take isl_multi_val *mv1, unsigned pos,
__isl_take isl_multi_val *mv2);
#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_range_splice(
__isl_take isl_multi_aff *ma1, unsigned pos,
__isl_take isl_multi_aff *ma2);
__isl_give isl_multi_aff *isl_multi_aff_splice(
__isl_take isl_multi_aff *ma1,
unsigned in_pos, unsigned out_pos,
__isl_take isl_multi_aff *ma2);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_range_splice(
__isl_take isl_multi_pw_aff *mpa1, unsigned pos,
__isl_take isl_multi_pw_aff *mpa2);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_splice(
__isl_take isl_multi_pw_aff *mpa1,
unsigned in_pos, unsigned out_pos,
__isl_take isl_multi_pw_aff *mpa2);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_range_splice(
__isl_take isl_multi_union_pw_aff *mupa1,
unsigned pos,
__isl_take isl_multi_union_pw_aff *mupa2);Simplification
When applied to a set or relation, the gist operation returns a set or relation that has the same intersection with the context as the input set or relation. Any implicit equality in the intersection is made explicit in the result, while all inequalities that are redundant with respect to the intersection are removed. In case of union sets and relations, the gist operation is performed per space.
When applied to a function, the gist operation applies the set gist operation to each of the cells in the domain of the input piecewise expression. The context is also exploited to simplify the expression associated to each cell.
#include <isl/set.h>
__isl_give isl_basic_set *isl_basic_set_gist(
__isl_take isl_basic_set *bset,
__isl_take isl_basic_set *context);
__isl_give isl_set *isl_set_gist(__isl_take isl_set *set,
__isl_take isl_set *context);
__isl_give isl_set *isl_set_gist_params(
__isl_take isl_set *set,
__isl_take isl_set *context);
#include <isl/map.h>
__isl_give isl_basic_map *isl_basic_map_gist(
__isl_take isl_basic_map *bmap,
__isl_take isl_basic_map *context);
__isl_give isl_basic_map *isl_basic_map_gist_domain(
__isl_take isl_basic_map *bmap,
__isl_take isl_basic_set *context);
__isl_give isl_map *isl_map_gist(__isl_take isl_map *map,
__isl_take isl_map *context);
__isl_give isl_map *isl_map_gist_params(
__isl_take isl_map *map,
__isl_take isl_set *context);
__isl_give isl_map *isl_map_gist_domain(
__isl_take isl_map *map,
__isl_take isl_set *context);
__isl_give isl_map *isl_map_gist_range(
__isl_take isl_map *map,
__isl_take isl_set *context);
#include <isl/union_set.h>
__isl_give isl_union_set *isl_union_set_gist(
__isl_take isl_union_set *uset,
__isl_take isl_union_set *context);
__isl_give isl_union_set *isl_union_set_gist_params(
__isl_take isl_union_set *uset,
__isl_take isl_set *set);
#include <isl/union_map.h>
__isl_give isl_union_map *isl_union_map_gist(
__isl_take isl_union_map *umap,
__isl_take isl_union_map *context);
__isl_give isl_union_map *isl_union_map_gist_params(
__isl_take isl_union_map *umap,
__isl_take isl_set *set);
__isl_give isl_union_map *isl_union_map_gist_domain(
__isl_take isl_union_map *umap,
__isl_take isl_union_set *uset);
__isl_give isl_union_map *isl_union_map_gist_range(
__isl_take isl_union_map *umap,
__isl_take isl_union_set *uset);
#include <isl/aff.h>
__isl_give isl_aff *isl_aff_gist_params(
__isl_take isl_aff *aff,
__isl_take isl_set *context);
__isl_give isl_aff *isl_aff_gist(__isl_take isl_aff *aff,
__isl_take isl_set *context);
__isl_give isl_multi_aff *isl_multi_aff_gist_params(
__isl_take isl_multi_aff *maff,
__isl_take isl_set *context);
__isl_give isl_multi_aff *isl_multi_aff_gist(
__isl_take isl_multi_aff *maff,
__isl_take isl_set *context);
__isl_give isl_pw_aff *isl_pw_aff_gist_params(
__isl_take isl_pw_aff *pwaff,
__isl_take isl_set *context);
__isl_give isl_pw_aff *isl_pw_aff_gist(
__isl_take isl_pw_aff *pwaff,
__isl_take isl_set *context);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist_params(
__isl_take isl_pw_multi_aff *pma,
__isl_take isl_set *set);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist(
__isl_take isl_pw_multi_aff *pma,
__isl_take isl_set *set);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_gist_params(
__isl_take isl_multi_pw_aff *mpa,
__isl_take isl_set *set);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_gist(
__isl_take isl_multi_pw_aff *mpa,
__isl_take isl_set *set);
__isl_give isl_union_pw_aff *isl_union_pw_aff_gist(
__isl_take isl_union_pw_aff *upa,
__isl_take isl_union_set *context);
__isl_give isl_union_pw_aff *isl_union_pw_aff_gist_params(
__isl_take isl_union_pw_aff *upa,
__isl_take isl_set *context);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_gist_params(
__isl_take isl_union_pw_multi_aff *upma,
__isl_take isl_set *context);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_gist(
__isl_take isl_union_pw_multi_aff *upma,
__isl_take isl_union_set *context);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_gist_params(
__isl_take isl_multi_union_pw_aff *mupa,
__isl_take isl_set *context);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_gist(
__isl_take isl_multi_union_pw_aff *mupa,
__isl_take isl_union_set *context);
#include <isl/polynomial.h>
__isl_give isl_qpolynomial *isl_qpolynomial_gist_params(
__isl_take isl_qpolynomial *qp,
__isl_take isl_set *context);
__isl_give isl_qpolynomial *isl_qpolynomial_gist(
__isl_take isl_qpolynomial *qp,
__isl_take isl_set *context);
__isl_give isl_qpolynomial_fold *
isl_qpolynomial_fold_gist_params(
__isl_take isl_qpolynomial_fold *fold,
__isl_take isl_set *context);
__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist(
__isl_take isl_qpolynomial_fold *fold,
__isl_take isl_set *context);
__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist_params(
__isl_take isl_pw_qpolynomial *pwqp,
__isl_take isl_set *context);
__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist(
__isl_take isl_pw_qpolynomial *pwqp,
__isl_take isl_set *context);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_gist(
__isl_take isl_pw_qpolynomial_fold *pwf,
__isl_take isl_set *context);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_gist_params(
__isl_take isl_pw_qpolynomial_fold *pwf,
__isl_take isl_set *context);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_gist_params(
__isl_take isl_union_pw_qpolynomial *upwqp,
__isl_take isl_set *context);
__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_gist(
__isl_take isl_union_pw_qpolynomial *upwqp,
__isl_take isl_union_set *context);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_gist(
__isl_take isl_union_pw_qpolynomial_fold *upwf,
__isl_take isl_union_set *context);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_gist_params(
__isl_take isl_union_pw_qpolynomial_fold *upwf,
__isl_take isl_set *context);Binary Arithmetic Operations
#include <isl/set.h>
__isl_give isl_set *isl_set_sum(
__isl_take isl_set *set1,
__isl_take isl_set *set2);
#include <isl/map.h>
__isl_give isl_map *isl_map_sum(
__isl_take isl_map *map1,
__isl_take isl_map *map2);isl_set_sum computes the Minkowski sum of its two arguments, i.e., the set containing the sums of pairs of elements from set1 and set2. The domain of the result of isl_map_sum is the intersection of the domains of its two arguments. The corresponding range elements are the sums of the corresponding range elements in the two arguments.
#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_add(
__isl_take isl_multi_val *mv1,
__isl_take isl_multi_val *mv2);
__isl_give isl_multi_val *isl_multi_val_sub(
__isl_take isl_multi_val *mv1,
__isl_take isl_multi_val *mv2);
__isl_give isl_multi_val *isl_multi_val_min(
__isl_take isl_multi_val *mv1,
__isl_take isl_multi_val *mv2);
__isl_give isl_multi_val *isl_multi_val_max(
__isl_take isl_multi_val *mv1,
__isl_take isl_multi_val *mv2);
#include <isl/aff.h>
__isl_give isl_aff *isl_aff_add(
__isl_take isl_aff *aff1,
__isl_take isl_aff *aff2);
__isl_give isl_multi_aff *isl_multi_aff_add(
__isl_take isl_multi_aff *maff1,
__isl_take isl_multi_aff *maff2);
__isl_give isl_pw_aff *isl_pw_aff_add(
__isl_take isl_pw_aff *pwaff1,
__isl_take isl_pw_aff *pwaff2);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_add(
__isl_take isl_multi_pw_aff *mpa1,
__isl_take isl_multi_pw_aff *mpa2);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_add(
__isl_take isl_pw_multi_aff *pma1,
__isl_take isl_pw_multi_aff *pma2);
__isl_give isl_union_pw_aff *isl_union_pw_aff_add(
__isl_take isl_union_pw_aff *upa1,
__isl_take isl_union_pw_aff *upa2);
__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_add(
__isl_take isl_union_pw_multi_aff *upma1,
__isl_take isl_union_pw_multi_aff *upma2);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_add(
__isl_take isl_multi_union_pw_aff *mupa1,
__isl_take isl_multi_union_pw_aff *mupa2);
__isl_give isl_pw_aff *isl_pw_aff_add_constant_val(
__isl_take isl_pw_aff *pa,
__isl_take isl_val *v);
__isl_give isl_multi_aff *
isl_multi_aff_add_constant_val(
__isl_take isl_multi_aff *pa,
__isl_take isl_val *v);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_add_constant_val(
__isl_take isl_pw_multi_aff *pma,
__isl_take isl_val *v);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_add_constant_multi_val(
__isl_take isl_pw_multi_aff *pma,
__isl_take isl_multi_val *mv);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_add_constant_val(
__isl_take isl_multi_pw_aff *mpa,
__isl_take isl_val *v);
__isl_give isl_multi_aff *
isl_multi_aff_add_constant_multi_val(
__isl_take isl_multi_aff *pa,
__isl_take isl_multi_val *mv);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_add_constant_multi_val(
__isl_take isl_multi_pw_aff *mpa,
__isl_take isl_multi_val *mv);
__isl_give isl_pw_aff *isl_pw_aff_min(
__isl_take isl_pw_aff *pwaff1,
__isl_take isl_pw_aff *pwaff2);
__isl_give isl_pw_aff *isl_pw_aff_max(
__isl_take isl_pw_aff *pwaff1,
__isl_take isl_pw_aff *pwaff2);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_min(
__isl_take isl_multi_pw_aff *mpa1,
__isl_take isl_multi_pw_aff *mpa2);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_max(
__isl_take isl_multi_pw_aff *mpa1,
__isl_take isl_multi_pw_aff *mpa2);
__isl_give isl_aff *isl_aff_sub(
__isl_take isl_aff *aff1,
__isl_take isl_aff *aff2);
__isl_give isl_multi_aff *isl_multi_aff_sub(
__isl_take isl_multi_aff *ma1,
__isl_take isl_multi_aff *ma2);
__isl_give isl_pw_aff *isl_pw_aff_sub(
__isl_take isl_pw_aff *pwaff1,
__isl_take isl_pw_aff *pwaff2);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_sub(
__isl_take isl_multi_pw_aff *mpa1,
__isl_take isl_multi_pw_aff *mpa2);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_sub(
__isl_take isl_pw_multi_aff *pma1,
__isl_take isl_pw_multi_aff *pma2);
__isl_give isl_union_pw_aff *isl_union_pw_aff_sub(
__isl_take isl_union_pw_aff *upa1,
__isl_take isl_union_pw_aff *upa2);
__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_sub(
__isl_take isl_union_pw_multi_aff *upma1,
__isl_take isl_union_pw_multi_aff *upma2);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_sub(
__isl_take isl_multi_union_pw_aff *mupa1,
__isl_take isl_multi_union_pw_aff *mupa2);isl_aff_sub subtracts the second argument from the first.
#include <isl/polynomial.h>
__isl_give isl_qpolynomial *isl_qpolynomial_add(
__isl_take isl_qpolynomial *qp1,
__isl_take isl_qpolynomial *qp2);
__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add(
__isl_take isl_pw_qpolynomial *pwqp1,
__isl_take isl_pw_qpolynomial *pwqp2);
__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add_disjoint(
__isl_take isl_pw_qpolynomial *pwqp1,
__isl_take isl_pw_qpolynomial *pwqp2);
__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_add(
__isl_take isl_pw_qpolynomial_fold *pwf1,
__isl_take isl_pw_qpolynomial_fold *pwf2);
__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add(
__isl_take isl_union_pw_qpolynomial *upwqp1,
__isl_take isl_union_pw_qpolynomial *upwqp2);
__isl_give isl_qpolynomial *isl_qpolynomial_sub(
__isl_take isl_qpolynomial *qp1,
__isl_take isl_qpolynomial *qp2);
__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_sub(
__isl_take isl_pw_qpolynomial *pwqp1,
__isl_take isl_pw_qpolynomial *pwqp2);
__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_sub(
__isl_take isl_union_pw_qpolynomial *upwqp1,
__isl_take isl_union_pw_qpolynomial *upwqp2);
__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_fold(
__isl_take isl_pw_qpolynomial_fold *pwf1,
__isl_take isl_pw_qpolynomial_fold *pwf2);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_fold(
__isl_take isl_union_pw_qpolynomial_fold *upwf1,
__isl_take isl_union_pw_qpolynomial_fold *upwf2);
#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_union_add(
__isl_take isl_pw_aff *pwaff1,
__isl_take isl_pw_aff *pwaff2);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_union_add(
__isl_take isl_multi_pw_aff *mpa1,
__isl_take isl_multi_pw_aff *mpa2);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_add(
__isl_take isl_pw_multi_aff *pma1,
__isl_take isl_pw_multi_aff *pma2);
__isl_give isl_union_pw_aff *isl_union_pw_aff_union_add(
__isl_take isl_union_pw_aff *upa1,
__isl_take isl_union_pw_aff *upa2);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_union_add(
__isl_take isl_union_pw_multi_aff *upma1,
__isl_take isl_union_pw_multi_aff *upma2);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_union_add(
__isl_take isl_multi_union_pw_aff *mupa1,
__isl_take isl_multi_union_pw_aff *mupa2);
__isl_give isl_pw_aff *isl_pw_aff_union_min(
__isl_take isl_pw_aff *pwaff1,
__isl_take isl_pw_aff *pwaff2);
__isl_give isl_pw_aff *isl_pw_aff_union_max(
__isl_take isl_pw_aff *pwaff1,
__isl_take isl_pw_aff *pwaff2);The function isl_pw_aff_union_max computes a piecewise quasi-affine expression with a domain that is the union of those of pwaff1 and pwaff2 and such that on each cell, the quasi-affine expression is the maximum of those of pwaff1 and pwaff2. If only one of pwaff1 or pwaff2 is defined on a given cell, then the associated expression is the defined one. This in contrast to the isl_pw_aff_max function, which is only defined on the shared definition domain of the arguments.
#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_add_val(
__isl_take isl_multi_val *mv,
__isl_take isl_val *v);
__isl_give isl_multi_val *isl_multi_val_mod_val(
__isl_take isl_multi_val *mv,
__isl_take isl_val *v);
__isl_give isl_multi_val *isl_multi_val_scale_val(
__isl_take isl_multi_val *mv,
__isl_take isl_val *v);
__isl_give isl_multi_val *isl_multi_val_scale_down_val(
__isl_take isl_multi_val *mv,
__isl_take isl_val *v);
#include <isl/aff.h>
__isl_give isl_aff *isl_aff_mod_val(__isl_take isl_aff *aff,
__isl_take isl_val *mod);
__isl_give isl_pw_aff *isl_pw_aff_mod_val(
__isl_take isl_pw_aff *pa,
__isl_take isl_val *mod);
__isl_give isl_union_pw_aff *isl_union_pw_aff_mod_val(
__isl_take isl_union_pw_aff *upa,
__isl_take isl_val *f);
__isl_give isl_aff *isl_aff_scale_val(__isl_take isl_aff *aff,
__isl_take isl_val *v);
__isl_give isl_multi_aff *isl_multi_aff_scale_val(
__isl_take isl_multi_aff *ma,
__isl_take isl_val *v);
__isl_give isl_pw_aff *isl_pw_aff_scale_val(
__isl_take isl_pw_aff *pa, __isl_take isl_val *v);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_scale_val(
__isl_take isl_multi_pw_aff *mpa,
__isl_take isl_val *v);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_val(
__isl_take isl_pw_multi_aff *pma,
__isl_take isl_val *v);
__isl_give isl_union_pw_aff *isl_union_pw_aff_scale_val(
__isl_take isl_union_pw_aff *upa,
__isl_take isl_val *f);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_scale_val(
__isl_take isl_union_pw_multi_aff *upma,
__isl_take isl_val *val);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_scale_val(
__isl_take isl_multi_union_pw_aff *mupa,
__isl_take isl_val *v);
__isl_give isl_aff *isl_aff_scale_down_ui(
__isl_take isl_aff *aff, unsigned f);
__isl_give isl_aff *isl_aff_scale_down_val(
__isl_take isl_aff *aff, __isl_take isl_val *v);
__isl_give isl_multi_aff *isl_multi_aff_scale_down_val(
__isl_take isl_multi_aff *ma,
__isl_take isl_val *v);
__isl_give isl_pw_aff *isl_pw_aff_scale_down_val(
__isl_take isl_pw_aff *pa,
__isl_take isl_val *f);
__isl_give isl_multi_pw_aff *isl_multi_pw_aff_scale_down_val(
__isl_take isl_multi_pw_aff *mpa,
__isl_take isl_val *v);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_down_val(
__isl_take isl_pw_multi_aff *pma,
__isl_take isl_val *v);
__isl_give isl_union_pw_aff *isl_union_pw_aff_scale_down_val(
__isl_take isl_union_pw_aff *upa,
__isl_take isl_val *v);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_scale_down_val(
__isl_take isl_union_pw_multi_aff *upma,
__isl_take isl_val *val);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_scale_down_val(
__isl_take isl_multi_union_pw_aff *mupa,
__isl_take isl_val *v);
#include <isl/polynomial.h>
__isl_give isl_qpolynomial *isl_qpolynomial_scale_val(
__isl_take isl_qpolynomial *qp,
__isl_take isl_val *v);
__isl_give isl_qpolynomial_fold *
isl_qpolynomial_fold_scale_val(
__isl_take isl_qpolynomial_fold *fold,
__isl_take isl_val *v);
__isl_give isl_pw_qpolynomial *
isl_pw_qpolynomial_scale_val(
__isl_take isl_pw_qpolynomial *pwqp,
__isl_take isl_val *v);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_scale_val(
__isl_take isl_pw_qpolynomial_fold *pwf,
__isl_take isl_val *v);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_scale_val(
__isl_take isl_union_pw_qpolynomial *upwqp,
__isl_take isl_val *v);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_scale_val(
__isl_take isl_union_pw_qpolynomial_fold *upwf,
__isl_take isl_val *v);
__isl_give isl_qpolynomial *
isl_qpolynomial_scale_down_val(
__isl_take isl_qpolynomial *qp,
__isl_take isl_val *v);
__isl_give isl_qpolynomial_fold *
isl_qpolynomial_fold_scale_down_val(
__isl_take isl_qpolynomial_fold *fold,
__isl_take isl_val *v);
__isl_give isl_pw_qpolynomial *
isl_pw_qpolynomial_scale_down_val(
__isl_take isl_pw_qpolynomial *pwqp,
__isl_take isl_val *v);
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_fold_scale_down_val(
__isl_take isl_pw_qpolynomial_fold *pwf,
__isl_take isl_val *v);
__isl_give isl_union_pw_qpolynomial *
isl_union_pw_qpolynomial_scale_down_val(
__isl_take isl_union_pw_qpolynomial *upwqp,
__isl_take isl_val *v);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_fold_scale_down_val(
__isl_take isl_union_pw_qpolynomial_fold *upwf,
__isl_take isl_val *v);
#include <isl/val.h>
__isl_give isl_multi_val *isl_multi_val_mod_multi_val(
__isl_take isl_multi_val *mv1,
__isl_take isl_multi_val *mv2);
__isl_give isl_multi_val *isl_multi_val_scale_multi_val(
__isl_take isl_multi_val *mv1,
__isl_take isl_multi_val *mv2);
__isl_give isl_multi_val *
isl_multi_val_scale_down_multi_val(
__isl_take isl_multi_val *mv1,
__isl_take isl_multi_val *mv2);
#include <isl/aff.h>
__isl_give isl_multi_aff *isl_multi_aff_mod_multi_val(
__isl_take isl_multi_aff *ma,
__isl_take isl_multi_val *mv);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_mod_multi_val(
__isl_take isl_multi_union_pw_aff *upma,
__isl_take isl_multi_val *mv);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_mod_multi_val(
__isl_take isl_multi_pw_aff *mpa,
__isl_take isl_multi_val *mv);
__isl_give isl_multi_aff *isl_multi_aff_scale_multi_val(
__isl_take isl_multi_aff *ma,
__isl_take isl_multi_val *mv);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_scale_multi_val(
__isl_take isl_pw_multi_aff *pma,
__isl_take isl_multi_val *mv);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_scale_multi_val(
__isl_take isl_multi_pw_aff *mpa,
__isl_take isl_multi_val *mv);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_scale_multi_val(
__isl_take isl_multi_union_pw_aff *mupa,
__isl_take isl_multi_val *mv);
__isl_give isl_union_pw_multi_aff *
isl_union_pw_multi_aff_scale_multi_val(
__isl_take isl_union_pw_multi_aff *upma,
__isl_take isl_multi_val *mv);
__isl_give isl_multi_aff *
isl_multi_aff_scale_down_multi_val(
__isl_take isl_multi_aff *ma,
__isl_take isl_multi_val *mv);
__isl_give isl_pw_multi_aff *
isl_pw_multi_aff_scale_down_multi_val(
__isl_take isl_pw_multi_aff *pma,
__isl_take isl_multi_val *mv);
__isl_give isl_multi_pw_aff *
isl_multi_pw_aff_scale_down_multi_val(
__isl_take isl_multi_pw_aff *mpa,
__isl_take isl_multi_val *mv);
__isl_give isl_multi_union_pw_aff *
isl_multi_union_pw_aff_scale_down_multi_val(
__isl_take isl_multi_union_pw_aff *mupa,
__isl_take isl_multi_val *mv);isl_multi_aff_scale_multi_val scales the elements of ma by the corresponding elements of mv.
#include <isl/aff.h>
__isl_give isl_aff *isl_aff_mul(
__isl_take isl_aff *aff1,
__isl_take isl_aff *aff2);
__isl_give isl_aff *isl_aff_div(
__isl_take isl_aff *aff1,
__isl_take isl_aff *aff2);
__isl_give isl_pw_aff *isl_pw_aff_mul(
__isl_take isl_pw_aff *pwaff1,
__isl_take isl_pw_aff *pwaff2);
__isl_give isl_pw_aff *isl_pw_aff_div(
__isl_take isl_pw_aff *pa1,
__isl_take isl_pw_aff *pa2);
__isl_give isl_pw_aff *isl_pw_aff_tdiv_q(
__isl_take isl_pw_aff *pa1,
__isl_take isl_pw_aff *pa2);
__isl_give isl_pw_aff *isl_pw_aff_tdiv_r(
__isl_take isl_pw_aff *pa1,
__isl_take isl_pw_aff *pa2);When multiplying two affine expressions, at least one of the two needs to be a constant. Similarly, when dividing an affine expression by another, the second expression needs to be a constant. isl_pw_aff_tdiv_q computes the quotient of an integer division with rounding towards zero. isl_pw_aff_tdiv_r computes the corresponding remainder.
#include <isl/polynomial.h>
__isl_give isl_qpolynomial *isl_qpolynomial_mul(
__isl_take isl_qpolynomial *qp1,
__isl_take isl_qpolynomial *qp2);
__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_mul(
__isl_take isl_pw_qpolynomial *pwqp1,
__isl_take isl_pw_qpolynomial *pwqp2);
__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_mul(
__isl_take isl_union_pw_qpolynomial *upwqp1,
__isl_take isl_union_pw_qpolynomial *upwqp2);Given a (basic) set set (or bset) and a zero-dimensional domain dom, the following functions compute a set that contains the lexicographic minimum or maximum of the elements in set (or bset) for those values of the parameters that satisfy dom. If empty is not NULL, then *empty is assigned a set that contains the parameter values in dom for which set (or bset) has no elements. In other words, the union of the parameter values for which the result is non-empty and of *empty is equal to dom.
#include <isl/set.h>
__isl_give isl_set *isl_basic_set_partial_lexmin(
__isl_take isl_basic_set *bset,
__isl_take isl_basic_set *dom,
__isl_give isl_set **empty);
__isl_give isl_set *isl_basic_set_partial_lexmax(
__isl_take isl_basic_set *bset,
__isl_take isl_basic_set *dom,
__isl_give isl_set **empty);
__isl_give isl_set *isl_set_partial_lexmin(
__isl_take isl_set *set, __isl_take isl_set *dom,
__isl_give isl_set **empty);
__isl_give isl_set *isl_set_partial_lexmax(
__isl_take isl_set *set, __isl_take isl_set *dom,
__isl_give isl_set **empty);Given a (basic) set set (or bset), the following functions simply return a set containing the lexicographic minimum or maximum of the elements in set (or bset). In case of union sets, the optimum is computed per space.
#include <isl/set.h>
__isl_give isl_set *isl_basic_set_lexmin(
__isl_take isl_basic_set *bset);
__isl_give isl_set *isl_basic_set_lexmax(
__isl_take isl_basic_set *bset);
__isl_give isl_set *isl_set_lexmin(
__isl_take isl_set *set);
__isl_give isl_set *isl_set_lexmax(
__isl_take isl_set *set);
__isl_give isl_union_set *isl_union_set_lexmin(
__isl_take isl_union_set *uset);
__isl_give isl_union_set *isl_union_set_lexmax(
__isl_take isl_union_set *uset);Given a (basic) relation map (or bmap) and a domain dom, the following functions compute a relation that maps each element of dom to the single lexicographic minimum or maximum of the elements that are associated to that same element in map (or bmap). If empty is not NULL, then *empty is assigned a set that contains the elements in dom that do not map to any elements in map (or bmap). In other words, the union of the domain of the result and of *empty is equal to dom.
#include <isl/map.h>
__isl_give isl_map *isl_basic_map_partial_lexmax(
__isl_take isl_basic_map *bmap,
__isl_take isl_basic_set *dom,
__isl_give isl_set **empty);
__isl_give isl_map *isl_basic_map_partial_lexmin(
__isl_take isl_basic_map *bmap,
__isl_take isl_basic_set *dom,
__isl_give isl_set **empty);
__isl_give isl_map *isl_map_partial_lexmax(
__isl_take isl_map *map, __isl_take isl_set *dom,
__isl_give isl_set **empty);
__isl_give isl_map *isl_map_partial_lexmin(
__isl_take isl_map *map, __isl_take isl_set *dom,
__isl_give isl_set **empty);Given a (basic) map map (or bmap), the following functions simply return a map mapping each element in the domain of map (or bmap) to the lexicographic minimum or maximum of all elements associated to that element. In case of union relations, the optimum is computed per space.
#include <isl/map.h>
__isl_give isl_map *isl_basic_map_lexmin(
__isl_take isl_basic_map *bmap);
__isl_give isl_map *isl_basic_map_lexmax(
__isl_take isl_basic_map *bmap);
__isl_give isl_map *isl_map_lexmin(
__isl_take isl_map *map);
__isl_give isl_map *isl_map_lexmax(
__isl_take isl_map *map);
__isl_give isl_union_map *isl_union_map_lexmin(
__isl_take isl_union_map *umap);
__isl_give isl_union_map *isl_union_map_lexmax(
__isl_take isl_union_map *umap);The following functions return their result in the form of a piecewise multi-affine expression, but are otherwise equivalent to the corresponding functions returning a basic set or relation.
#include <isl/set.h>
__isl_give isl_pw_multi_aff *
isl_basic_set_partial_lexmin_pw_multi_aff(
__isl_take isl_basic_set *bset,
__isl_take isl_basic_set *dom,
__isl_give isl_set **empty);
__isl_give isl_pw_multi_aff *
isl_basic_set_partial_lexmax_pw_multi_aff(
__isl_take isl_basic_set *bset,
__isl_take isl_basic_set *dom,
__isl_give isl_set **empty);
__isl_give isl_pw_multi_aff *isl_set_lexmin_pw_multi_aff(
__isl_take isl_set *set);
__isl_give isl_pw_multi_aff *isl_set_lexmax_pw_multi_aff(
__isl_take isl_set *set);
#include <isl/map.h>
__isl_give isl_pw_multi_aff *
isl_basic_map_lexmin_pw_multi_aff(
__isl_take isl_basic_map *bmap);
__isl_give isl_pw_multi_aff *
isl_basic_map_partial_lexmin_pw_multi_aff(
__isl_take isl_basic_map *bmap,
__isl_take isl_basic_set *dom,
__isl_give isl_set **empty);
__isl_give isl_pw_multi_aff *
isl_basic_map_partial_lexmax_pw_multi_aff(
__isl_take isl_basic_map *bmap,
__isl_take isl_basic_set *dom,
__isl_give isl_set **empty);
__isl_give isl_pw_multi_aff *isl_map_lexmin_pw_multi_aff(
__isl_take isl_map *map);
__isl_give isl_pw_multi_aff *isl_map_lexmax_pw_multi_aff(
__isl_take isl_map *map);The following functions return the lexicographic minimum or maximum on the shared domain of the inputs and the single defined function on those parts of the domain where only a single function is defined.
#include <isl/aff.h>
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmin(
__isl_take isl_pw_multi_aff *pma1,
__isl_take isl_pw_multi_aff *pma2);
__isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmax(
__isl_take isl_pw_multi_aff *pma1,
__isl_take isl_pw_multi_aff *pma2);If the input to a lexicographic optimization problem has multiple constraints with the same coefficients for the optimized variables, then, by default, this symmetry is exploited by replacing those constraints by a single constraint with an abstract bound, which is in turn bounded by the corresponding terms in the original constraints. Without this optimization, the solver would typically consider all possible orderings of those original bounds, resulting in a needless decomposition of the domain. However, the optimization can also result in slowdowns since an extra parameter is introduced that may get used in additional integer divisions. The following option determines whether symmetry detection is applied during lexicographic optimization.
#include <isl/options.h>
isl_stat isl_options_set_pip_symmetry(isl_ctx *ctx,
int val);
int isl_options_get_pip_symmetry(isl_ctx *ctx);#include <isl/aff.h>
__isl_give isl_pw_aff *isl_pw_aff_cond(
__isl_take isl_pw_aff *cond,
__isl_take isl_pw_aff *pwaff_true,
__isl_take isl_pw_aff *pwaff_false);The function isl_pw_aff_cond performs a conditional operator and returns an expression that is equal to pwaff_true for elements where cond is non-zero and equal to pwaff_false for elements where cond is zero.
Lists are defined over several element types, including isl_val, isl_id, isl_aff, isl_pw_aff, isl_pw_multi_aff, isl_union_pw_aff, isl_union_pw_multi_aff, isl_qpolynomial, isl_pw_qpolynomial, isl_pw_qpolynomial_fold, isl_constraint, isl_basic_set, isl_set, isl_basic_map, isl_map, isl_union_set, isl_union_map, isl_ast_expr and isl_ast_node. Here we take lists of isl_sets as an example. Lists can be created, copied, modified and freed using the following functions.
#include <isl/set.h>
__isl_give isl_set_list *isl_set_to_list(
__isl_take isl_set *el);
__isl_give isl_set_list *isl_set_list_from_set(
__isl_take isl_set *el);
__isl_give isl_set_list *isl_set_list_alloc(
isl_ctx *ctx, int n);
__isl_give isl_set_list *isl_set_list_copy(
__isl_keep isl_set_list *list);
__isl_give isl_set_list *isl_set_list_insert(
__isl_take isl_set_list *list, unsigned pos,
__isl_take isl_set *el);
__isl_give isl_set_list *isl_set_list_add(
__isl_take isl_set_list *list,
__isl_take isl_set *el);
__isl_give isl_set_list *isl_set_list_drop(
__isl_take isl_set_list *list,
unsigned first, unsigned n);
__isl_give isl_set_list *isl_set_list_clear(
__isl_take isl_set_list *list);
__isl_give isl_set_list *isl_set_list_swap(
__isl_take isl_set_list *list,
unsigned pos1, unsigned pos2);
__isl_give isl_set_list *isl_set_list_reverse(
__isl_take isl_set_list *list);
__isl_give isl_set_list *isl_set_list_set_at(
__isl_take isl_set_list *list, int index,
__isl_take isl_set *set);
__isl_give isl_set_list *isl_set_list_set_set(
__isl_take isl_set_list *list, int index,
__isl_take isl_set *set);
__isl_give isl_set_list *isl_set_list_concat(
__isl_take isl_set_list *list1,
__isl_take isl_set_list *list2);
__isl_give isl_set_list *isl_set_list_map(
__isl_take isl_set_list *list,
__isl_give isl_set *(*fn)(__isl_take isl_set *el,
void *user),
void *user);
__isl_give isl_set_list *isl_set_list_sort(
__isl_take isl_set_list *list,
int (*cmp)(__isl_keep isl_set *a,
__isl_keep isl_set *b, void *user),
void *user);
__isl_null isl_set_list *isl_set_list_free(
__isl_take isl_set_list *list);isl_set_list_alloc creates an empty list with an initial capacity for n elements. isl_set_list_insert and isl_set_list_add add elements to a list, increasing its capacity as needed. isl_set_to_list creates a list with a single element. isl_set_list_from_set performs the same operation. isl_set_list_clear removes all elements from a list. isl_set_list_swap swaps the elements at the specified locations. isl_set_list_reverse reverses the elements in the list. isl_set_list_set_set is an alternative name for isl_set_list_set_at.
Lists can be inspected using the following functions.
#include <isl/set.h>
isl_size isl_set_list_size(__isl_keep isl_set_list *list);
isl_size isl_set_list_n_set(__isl_keep isl_set_list *list);
__isl_give isl_set *isl_set_list_get_at(
__isl_keep isl_set_list *list, int index);
__isl_give isl_set *isl_set_list_get_set(
__isl_keep isl_set_list *list, int index);
isl_stat isl_set_list_foreach(__isl_keep isl_set_list *list,
isl_stat (*fn)(__isl_take isl_set *el, void *user),
void *user);
isl_bool isl_set_list_every(__isl_keep isl_set_list *list,
isl_bool (*test)(__isl_take isl_set *el,
void *user),
void *user);
isl_stat isl_set_list_foreach_scc(
__isl_keep isl_set_list *list,
isl_bool (*follows)(__isl_keep isl_set *a,
__isl_keep isl_set *b, void *user),
void *follows_user,
isl_stat (*fn)(__isl_take isl_set_list *scc,
void *user),
void *fn_user);isl_set_list_n_set is an alternative name for isl_set_list_size. Similarly, isl_set_list_get_set is an alternative name for isl_set_list_get_at. The function isl_set_list_foreach_scc calls fn on each of the strongly connected components of the graph with as vertices the elements of list and a directed edge from vertex b to vertex a iff follows(a, b) returns isl_bool_true. The callbacks follows and fn should return isl_bool_error or isl_stat_error on error.
Lists can be printed using
#include <isl/set.h>
__isl_give isl_printer *isl_printer_print_set_list(
__isl_take isl_printer *p,
__isl_keep isl_set_list *list);Alternatively, a string representation can be obtained directly using the following function, which always prints in isl format.
#include <isl/set.h>
__isl_give char *isl_set_list_to_str(
__isl_keep isl_set_list *list);An isl_val_list, isl_id_list, isl_aff_list, isl_pw_aff_list, isl_pw_multi_aff_list, isl_union_pw_aff_list, isl_set_list, isl_map_list or isl_union_set_list object can also be read from input using the following functions.
#include <isl/val.h>
__isl_give isl_val_list *isl_val_list_read_from_str(
isl_ctx *ctx, const char *str);
#include <isl/id.h>
__isl_give isl_id_list *isl_id_list_read_from_str(
isl_ctx *ctx, const char *str);
#include <isl/aff.h>
__isl_give isl_aff_list *
isl_aff_list_read_from_str(isl_ctx *ctx,
const char *str);
__isl_give isl_pw_aff_list *
isl_pw_aff_list_read_from_str(isl_ctx *ctx,
const char *str);
__isl_give isl_pw_multi_aff_list *
isl_pw_multi_aff_list_read_from_str(isl_ctx *ctx,
const char *str);
__isl_give isl_union_pw_aff_list *
isl_union_pw_aff_list_read_from_str(isl_ctx *ctx,
const char *str);
#include <isl/set.h>
__isl_give isl_set_list *isl_set_list_read_from_str(
isl_ctx *ctx, const char *str);
#include <isl/map.h>
__isl_give isl_map_list *isl_map_list_read_from_str(
isl_ctx *ctx, const char *str);
#include <isl/union_set.h>
__isl_give isl_union_set_list *
isl_union_set_list_read_from_str(isl_ctx *ctx,
const char *str);Associative arrays map isl objects of a specific type to isl objects of some (other) specific type. They are defined for several pairs of types, including (isl_map, isl_basic_set), (isl_id, isl_ast_expr), (isl_id, isl_id) and (isl_id, isl_pw_aff). Here, we take associative arrays that map isl_ids to isl_ast_exprs as an example.
Associative arrays can be created, copied and freed using the following functions.
#include <isl/id_to_ast_expr.h>
__isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_alloc(
isl_ctx *ctx, int min_size);
__isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_copy(
__isl_keep isl_id_to_ast_expr *id2expr);
__isl_null isl_id_to_ast_expr *isl_id_to_ast_expr_free(
__isl_take isl_id_to_ast_expr *id2expr);The min_size argument to isl_id_to_ast_expr_alloc can be used to specify the expected size of the associative array. The associative array will be grown automatically as needed.
Associative arrays can be inspected using the following functions.
#include <isl/id_to_ast_expr.h>
__isl_give isl_maybe_isl_ast_expr
isl_id_to_ast_expr_try_get(
__isl_keep isl_id_to_ast_expr *id2expr,
__isl_keep isl_id *key);
isl_bool isl_id_to_ast_expr_has(
__isl_keep isl_id_to_ast_expr *id2expr,
__isl_keep isl_id *key);
__isl_give isl_ast_expr *isl_id_to_ast_expr_get(
__isl_keep isl_id_to_ast_expr *id2expr,
__isl_take isl_id *key);
isl_stat isl_id_to_ast_expr_foreach(
__isl_keep isl_id_to_ast_expr *id2expr,
isl_stat (*fn)(__isl_take isl_id *key,
__isl_take isl_ast_expr *val, void *user),
void *user);
isl_bool isl_id_to_ast_expr_every(
__isl_keep isl_id_to_ast_expr *id2expr,
isl_bool (*test)(__isl_keep isl_id *key,
__isl_keep isl_ast_expr *val, void *user),
void *user);The function isl_id_to_ast_expr_try_get returns a structure containing two elements, valid and value. If there is a value associated to the key, then valid is set to isl_bool_true and value contains a copy of the associated value. Otherwise value is NULL and valid may be isl_bool_error or isl_bool_false depending on whether some error has occurred or there simply is no associated value. The function isl_id_to_ast_expr_has returns the valid field in the structure and the function isl_id_to_ast_expr_get returns the value field.
Associative arrays can be modified using the following functions.
#include <isl/id_to_ast_expr.h>
__isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_set(
__isl_take isl_id_to_ast_expr *id2expr,
__isl_take isl_id *key,
__isl_take isl_ast_expr *val);
__isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_drop(
__isl_take isl_id_to_ast_expr *id2expr,
__isl_take isl_id *key);Associative arrays can be checked for (obvious) equality using the following function.
#include <isl/id_to_ast_expr.h>
isl_bool isl_id_to_ast_expr_is_equal(
__isl_take isl_id_to_ast_expr *id2expr1,
__isl_take isl_id_to_ast_expr *id2expr2);Note that depending on how the keys and values are being compared, for other types of keys and/or values, this function may be called plain_is_equal rather than is_equal.
Associative arrays can be printed using the following functions.
#include <isl/id_to_ast_expr.h>
__isl_give isl_printer *isl_printer_print_id_to_ast_expr(
__isl_take isl_printer *p,
__isl_keep isl_id_to_ast_expr *id2expr);
__isl_give char *isl_id_to_ast_expr_to_str(
__isl_keep isl_id_to_ast_expr *id2expr);They can be read from input using the following function.
#include <isl/id_to_ast_expr.h>
__isl_give isl_id_to_ast_expr *
isl_id_to_ast_expr_read_from_str(isl_ctx *ctx,
const char *str);Vectors can be created, copied and freed using the following functions.
#include <isl/vec.h>
__isl_give isl_vec *isl_vec_alloc(isl_ctx *ctx,
unsigned size);
__isl_give isl_vec *isl_vec_zero(isl_ctx *ctx,
unsigned size);
__isl_give isl_vec *isl_vec_copy(__isl_keep isl_vec *vec);
__isl_null isl_vec *isl_vec_free(__isl_take isl_vec *vec);Note that the elements of a vector created by isl_vec_alloc may have arbitrary values. A vector created by isl_vec_zero has elements with value zero. The elements can be changed and inspected using the following functions.
isl_size isl_vec_size(__isl_keep isl_vec *vec);
__isl_give isl_val *isl_vec_get_element_val(
__isl_keep isl_vec *vec, int pos);
__isl_give isl_vec *isl_vec_set_element_si(
__isl_take isl_vec *vec, int pos, int v);
__isl_give isl_vec *isl_vec_set_element_val(
__isl_take isl_vec *vec, int pos,
__isl_take isl_val *v);
__isl_give isl_vec *isl_vec_set_si(__isl_take isl_vec *vec,
int v);
__isl_give isl_vec *isl_vec_set_val(
__isl_take isl_vec *vec, __isl_take isl_val *v);
int isl_vec_cmp_element(__isl_keep isl_vec *vec1,
__isl_keep isl_vec *vec2, int pos);isl_vec_get_element will return a negative value if anything went wrong. In that case, the value of *v is undefined.
The following function can be used to concatenate two vectors.
__isl_give isl_vec *isl_vec_concat(__isl_take isl_vec *vec1,
__isl_take isl_vec *vec2);Matrices can be created, copied and freed using the following functions.
#include <isl/mat.h>
__isl_give isl_mat *isl_mat_alloc(isl_ctx *ctx,
unsigned n_row, unsigned n_col);
__isl_give isl_mat *isl_mat_copy(__isl_keep isl_mat *mat);
__isl_null isl_mat *isl_mat_free(__isl_take isl_mat *mat);Note that the elements of a newly created matrix may have arbitrary values. The elements can be changed and inspected using the following functions.
isl_size isl_mat_rows(__isl_keep isl_mat *mat);
isl_size isl_mat_cols(__isl_keep isl_mat *mat);
__isl_give isl_val *isl_mat_get_element_val(
__isl_keep isl_mat *mat, int row, int col);
__isl_give isl_mat *isl_mat_set_element_si(__isl_take isl_mat *mat,
int row, int col, int v);
__isl_give isl_mat *isl_mat_set_element_val(
__isl_take isl_mat *mat, int row, int col,
__isl_take isl_val *v);The following function computes the rank of a matrix. The return value may be -1 if some error occurred.
#include <isl/mat.h>
isl_size isl_mat_rank(__isl_keep isl_mat *mat);The following function can be used to compute the (right) inverse of a matrix, i.e., a matrix such that the product of the original and the inverse (in that order) is a multiple of the identity matrix. The input matrix is assumed to be of full row-rank.
__isl_give isl_mat *isl_mat_right_inverse(__isl_take isl_mat *mat);The following function can be used to compute the (right) kernel (or null space) of a matrix, i.e., a matrix such that the product of the original and the kernel (in that order) is the zero matrix.
__isl_give isl_mat *isl_mat_right_kernel(__isl_take isl_mat *mat);The following function computes a basis for the space spanned by the rows of a matrix.
__isl_give isl_mat *isl_mat_row_basis(
__isl_take isl_mat *mat);The following function computes rows that extend a basis of mat1 to a basis that also covers mat2.
__isl_give isl_mat *isl_mat_row_basis_extension(
__isl_take isl_mat *mat1,
__isl_take isl_mat *mat2);The following function checks whether there is no linear dependence among the combined rows of "mat1" and "mat2" that is not already present in "mat1" or "mat2" individually. If "mat1" and "mat2" have linearly independent rows by themselves, then this means that there is no linear dependence among all rows together.
isl_bool isl_mat_has_linearly_independent_rows(
__isl_keep isl_mat *mat1,
__isl_keep isl_mat *mat2);The following functions determine an upper or lower bound on a quasipolynomial over its domain.
__isl_give isl_pw_qpolynomial_fold *
isl_pw_qpolynomial_bound(
__isl_take isl_pw_qpolynomial *pwqp,
enum isl_fold type, isl_bool *tight);
__isl_give isl_union_pw_qpolynomial_fold *
isl_union_pw_qpolynomial_bound(
__isl_take isl_union_pw_qpolynomial *upwqp,
enum isl_fold type, isl_bool *tight);The type argument may be either isl_fold_min or isl_fold_max. If tight is not NULL, then *tight is set to 1 is the returned bound is known be tight, i.e., for each value of the parameters there is at least one element in the domain that reaches the bound. If the domain of pwqp is not wrapping, then the bound is computed over all elements in that domain and the result has a purely parametric domain. If the domain of pwqp is wrapping, then the bound is computed over the range of the wrapped relation. The domain of the wrapped relation becomes the domain of the result.
The parametric vertex enumeration described in this section is mainly intended to be used internally and by the barvinok library.
#include <isl/vertices.h>
__isl_give isl_vertices *isl_basic_set_compute_vertices(
__isl_keep isl_basic_set *bset);The function isl_basic_set_compute_vertices performs the actual computation of the parametric vertices and the chamber decomposition and stores the result in an isl_vertices object. This information can be queried by either iterating over all the vertices or iterating over all the chambers or cells and then iterating over all vertices that are active on the chamber.
isl_stat isl_vertices_foreach_vertex(
__isl_keep isl_vertices *vertices,
isl_stat (*fn)(__isl_take isl_vertex *vertex,
void *user), void *user);
isl_stat isl_vertices_foreach_cell(
__isl_keep isl_vertices *vertices,
isl_stat (*fn)(__isl_take isl_cell *cell,
void *user), void *user);
isl_stat isl_cell_foreach_vertex(__isl_keep isl_cell *cell,
isl_stat (*fn)(__isl_take isl_vertex *vertex,
void *user), void *user);Other operations that can be performed on an isl_vertices object are the following.
isl_size isl_vertices_get_n_vertices(
__isl_keep isl_vertices *vertices);
__isl_null isl_vertices *isl_vertices_free(
__isl_take isl_vertices *vertices);Vertices can be inspected and destroyed using the following functions.
isl_size isl_vertex_get_id(__isl_keep isl_vertex *vertex);
__isl_give isl_basic_set *isl_vertex_get_domain(
__isl_keep isl_vertex *vertex);
__isl_give isl_multi_aff *isl_vertex_get_expr(
__isl_keep isl_vertex *vertex);
__isl_null isl_vertex *isl_vertex_free(
__isl_take isl_vertex *vertex);isl_vertex_get_expr returns a multiple quasi-affine expression describing the vertex in terms of the parameters, while isl_vertex_get_domain returns the activity domain of the vertex.
Chambers can be inspected and destroyed using the following functions.
__isl_give isl_basic_set *isl_cell_get_domain(
__isl_keep isl_cell *cell);
__isl_null isl_cell *isl_cell_free(
__isl_take isl_cell *cell);This section collects functionality in isl that has been specifically designed for use during polyhedral compilation.
A schedule tree is a structured representation of a schedule, assigning a relative order to a set of domain elements. The relative order expressed by the schedule tree is defined recursively. In particular, the order between two domain elements is determined by the node that is closest to the root that refers to both elements and that orders them apart. Each node in the tree is of one of several types. The root node is always of type isl_schedule_node_domain (or isl_schedule_node_extension) and it describes the (extra) domain elements to which the schedule applies. The other types of nodes are as follows.
isl_schedule_node_bandA band of schedule dimensions. Each schedule dimension is represented by a union piecewise quasi-affine expression. If this expression assigns a different value to two domain elements, while all previous schedule dimensions in the same band assign them the same value, then the two domain elements are ordered according to these two different values. Each expression is required to be total in the domain elements that reach the band node.
isl_schedule_node_expansionAn expansion node maps each of the domain elements that reach the node to one or more domain elements. The image of this mapping forms the set of domain elements that reach the child of the expansion node. The function that maps each of the expanded domain elements to the original domain element from which it was expanded is called the contraction.
isl_schedule_node_filterA filter node does not impose any ordering, but rather intersects the set of domain elements that the current subtree refers to with a given union set. The subtree of the filter node only refers to domain elements in the intersection. A filter node is typically only used as a child of a sequence or set node.
isl_schedule_node_leafA leaf of the schedule tree. Leaf nodes do not impose any ordering.
isl_schedule_node_markA mark node can be used to attach any kind of information to a subtree of the schedule tree.
isl_schedule_node_sequenceA sequence node has one or more children, each of which is a filter node. The filters on these filter nodes form a partition of the domain elements that the current subtree refers to. If two domain elements appear in distinct filters then the sequence node orders them according to the child positions of the corresponding filter nodes.
isl_schedule_node_setA set node is similar to a sequence node, except that it expresses that domain elements appearing in distinct filters may have any order. The order of the children of a set node is therefore also immaterial.
The following node types are only supported by the AST generator.
isl_schedule_node_contextThe context describes constraints on the parameters and the schedule dimensions of outer bands that the AST generator may assume to hold. It is also the only kind of node that may introduce additional parameters. The space of the context is that of the flat product of the outer band nodes. In particular, if there are no outer band nodes, then this space is the unnamed zero-dimensional space. Since a context node references the outer band nodes, any tree containing a context node is considered to be anchored.
isl_schedule_node_extensionAn extension node instructs the AST generator to add additional domain elements that need to be scheduled. The additional domain elements are described by the range of the extension map in terms of the outer schedule dimensions, i.e., the flat product of the outer band nodes. Note that domain elements are added whenever the AST generator reaches the extension node, meaning that there are still some active domain elements for which an AST needs to be generated. The conditions under which some domain elements are still active may however not be completely described by the outer AST nodes generated at that point. Since an extension node references the outer band nodes, any tree containing an extension node is considered to be anchored.
An extension node may also appear as the root of a schedule tree, when it is intended to be inserted into another tree using isl_schedule_node_graft_before or isl_schedule_node_graft_after. In this case, the domain of the extension node should correspond to the flat product of the outer band nodes in this other schedule tree at the point where the extension tree will be inserted.
isl_schedule_node_guardThe guard describes constraints on the parameters and the schedule dimensions of outer bands that need to be enforced by the outer nodes in the generated AST. That is, the part of the AST that is generated from descendants of the guard node can assume that these constraints are satisfied. The space of the guard is that of the flat product of the outer band nodes. In particular, if there are no outer band nodes, then this space is the unnamed zero-dimensional space. Since a guard node references the outer band nodes, any tree containing a guard node is considered to be anchored.
Except for the isl_schedule_node_context nodes, none of the nodes may introduce any parameters that were not already present in the root domain node.
A schedule tree is encapsulated in an isl_schedule object. The simplest such objects, those with a tree consisting of single domain node, can be created using the following functions with either an empty domain or a given domain.
#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_empty(
__isl_take isl_space *space);
__isl_give isl_schedule *isl_schedule_from_domain(
__isl_take isl_union_set *domain);The function isl_schedule_constraints_compute_schedule described in "Scheduling" can also be used to construct schedules.
isl_schedule objects may be copied and freed using the following functions.
#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_copy(
__isl_keep isl_schedule *sched);
__isl_null isl_schedule *isl_schedule_free(
__isl_take isl_schedule *sched);The following functions checks whether two isl_schedule objects are obviously the same.
#include <isl/schedule.h>
isl_bool isl_schedule_plain_is_equal(
__isl_keep isl_schedule *schedule1,
__isl_keep isl_schedule *schedule2);The domain of the schedule, i.e., the domain described by the root node, can be obtained using the following function.
#include <isl/schedule.h>
__isl_give isl_union_set *isl_schedule_get_domain(
__isl_keep isl_schedule *schedule);An extra top-level band node (right underneath the domain node) can be introduced into the schedule using the following function. The schedule tree is assumed not to have any anchored nodes.
#include <isl/schedule.h>
__isl_give isl_schedule *
isl_schedule_insert_partial_schedule(
__isl_take isl_schedule *schedule,
__isl_take isl_multi_union_pw_aff *partial);A top-level context node (right underneath the domain node) can be introduced into the schedule using the following function.
#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_insert_context(
__isl_take isl_schedule *schedule,
__isl_take isl_set *context)A top-level guard node (right underneath the domain node) can be introduced into the schedule using the following function.
#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_insert_guard(
__isl_take isl_schedule *schedule,
__isl_take isl_set *guard)A schedule that combines two schedules either in the given order or in an arbitrary order, i.e., with an isl_schedule_node_sequence or an isl_schedule_node_set node, can be created using the following functions.
#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_sequence(
__isl_take isl_schedule *schedule1,
__isl_take isl_schedule *schedule2);
__isl_give isl_schedule *isl_schedule_set(
__isl_take isl_schedule *schedule1,
__isl_take isl_schedule *schedule2);The domains of the two input schedules need to be disjoint.
The following function can be used to restrict the domain of a schedule with a domain node as root to be a subset of the given union set. This operation may remove nodes in the tree that have become redundant.
#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_intersect_domain(
__isl_take isl_schedule *schedule,
__isl_take isl_union_set *domain);The following function can be used to simplify the domain of a schedule with a domain node as root with respect to the given parameter domain.
#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_gist_domain_params(
__isl_take isl_schedule *schedule,
__isl_take isl_set *context);The following function resets the user pointers on all parameter and tuple identifiers referenced by the nodes of the given schedule.
#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_reset_user(
__isl_take isl_schedule *schedule);The following function aligns the parameters of all nodes in the given schedule to the given space.
#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_align_params(
__isl_take isl_schedule *schedule,
__isl_take isl_space *space);The following function allows the user to plug in a given function in the iteration domains. The input schedule is not allowed to contain any expansion nodes.
#include <isl/schedule.h>
__isl_give isl_schedule *
isl_schedule_pullback_union_pw_multi_aff(
__isl_take isl_schedule *schedule,
__isl_take isl_union_pw_multi_aff *upma);The following function can be used to plug in the schedule expansion in the leaves of schedule, where contraction describes how the domain elements of expansion map to the domain elements at the original leaves of schedule. The resulting schedule will contain expansion nodes, unless contraction is an identity function.
#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_expand(
__isl_take isl_schedule *schedule,
__isl_take isl_union_pw_multi_aff *contraction,
__isl_take isl_schedule *expansion);An isl_union_map representation of the schedule can be obtained from an isl_schedule using the following function.
#include <isl/schedule.h>
__isl_give isl_union_map *isl_schedule_get_map(
__isl_keep isl_schedule *sched);The resulting relation encodes the same relative ordering as the schedule by mapping the domain elements to a common schedule space. If the schedule_separate_components option is set, then the order of the children of a set node is explicitly encoded in the result. If the tree contains any expansion nodes, then the relation is formulated in terms of the expanded domain elements.
Schedules can be read from input using the following functions.
#include <isl/schedule.h>
__isl_give isl_schedule *isl_schedule_read_from_file(
isl_ctx *ctx, FILE *input);
__isl_give isl_schedule *isl_schedule_read_from_str(
isl_ctx *ctx, const char *str);A representation of the schedule can be printed using
#include <isl/schedule.h>
__isl_give isl_printer *isl_printer_print_schedule(
__isl_take isl_printer *p,
__isl_keep isl_schedule *schedule);
__isl_give char *isl_schedule_to_str(
__isl_keep isl_schedule *schedule);isl_schedule_to_str prints the schedule in flow format.
The schedule tree can be traversed through the use of isl_schedule_node objects that point to a particular position in the schedule tree. Whenever a isl_schedule_node is used to modify a node in the schedule tree, the original schedule tree is left untouched and the modifications are performed to a copy of the tree. The returned isl_schedule_node then points to this modified copy of the tree.
The root of the schedule tree can be obtained using the following function.
#include <isl/schedule.h>
__isl_give isl_schedule_node *isl_schedule_get_root(
__isl_keep isl_schedule *schedule);A pointer to a newly created schedule tree with a single domain node can be created using the following functions.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_from_domain(
__isl_take isl_union_set *domain);
__isl_give isl_schedule_node *
isl_schedule_node_from_extension(
__isl_take isl_union_map *extension);isl_schedule_node_from_extension creates a tree with an extension node as root.
Schedule nodes can be copied and freed using the following functions.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *isl_schedule_node_copy(
__isl_keep isl_schedule_node *node);
__isl_null isl_schedule_node *isl_schedule_node_free(
__isl_take isl_schedule_node *node);The following functions can be used to check if two schedule nodes point to the same position in the same schedule.
#include <isl/schedule_node.h>
isl_bool isl_schedule_node_is_equal(
__isl_keep isl_schedule_node *node1,
__isl_keep isl_schedule_node *node2);The following properties can be obtained from a schedule node.
#include <isl/schedule_node.h>
enum isl_schedule_node_type isl_schedule_node_get_type(
__isl_keep isl_schedule_node *node);
enum isl_schedule_node_type
isl_schedule_node_get_parent_type(
__isl_keep isl_schedule_node *node);
__isl_give isl_schedule *isl_schedule_node_get_schedule(
__isl_keep isl_schedule_node *node);The function isl_schedule_node_get_type returns the type of the node, while isl_schedule_node_get_parent_type returns type of the parent of the node, which is required to exist. The function isl_schedule_node_get_schedule returns a copy to the schedule to which the node belongs.
The following functions can be used to move the schedule node to a different position in the tree or to check if such a position exists.
#include <isl/schedule_node.h>
isl_bool isl_schedule_node_has_parent(
__isl_keep isl_schedule_node *node);
__isl_give isl_schedule_node *isl_schedule_node_parent(
__isl_take isl_schedule_node *node);
__isl_give isl_schedule_node *
isl_schedule_node_grandparent(
__isl_take isl_schedule_node *node);
__isl_give isl_schedule_node *isl_schedule_node_root(
__isl_take isl_schedule_node *node);
__isl_give isl_schedule_node *isl_schedule_node_ancestor(
__isl_take isl_schedule_node *node,
int generation);
isl_size isl_schedule_node_n_children(
__isl_keep isl_schedule_node *node);
__isl_give isl_schedule_node *isl_schedule_node_child(
__isl_take isl_schedule_node *node, int pos);
isl_bool isl_schedule_node_has_children(
__isl_keep isl_schedule_node *node);
__isl_give isl_schedule_node *
isl_schedule_node_grandchild(
__isl_take isl_schedule_node *node,
int pos1, int pos2);
__isl_give isl_schedule_node *isl_schedule_node_first_child(
__isl_take isl_schedule_node *node);
isl_bool isl_schedule_node_has_previous_sibling(
__isl_keep isl_schedule_node *node);
__isl_give isl_schedule_node *
isl_schedule_node_previous_sibling(
__isl_take isl_schedule_node *node);
isl_bool isl_schedule_node_has_next_sibling(
__isl_keep isl_schedule_node *node);
__isl_give isl_schedule_node *
isl_schedule_node_next_sibling(
__isl_take isl_schedule_node *node);For isl_schedule_node_ancestor, the ancestor of generation 0 is the node itself, the ancestor of generation 1 is its parent and so on.
It is also possible to query the number of ancestors of a node, the position of the current node within the children of its parent, the position of the subtree containing a node within the children of an ancestor or to obtain a copy of a given child without destroying the current node. Given two nodes that point to the same schedule, their closest shared ancestor can be obtained using isl_schedule_node_get_shared_ancestor.
#include <isl/schedule_node.h>
isl_size isl_schedule_node_get_tree_depth(
__isl_keep isl_schedule_node *node);
isl_size isl_schedule_node_get_child_position(
__isl_keep isl_schedule_node *node);
isl_size isl_schedule_node_get_ancestor_child_position(
__isl_keep isl_schedule_node *node,
__isl_keep isl_schedule_node *ancestor);
__isl_give isl_schedule_node *isl_schedule_node_get_child(
__isl_keep isl_schedule_node *node, int pos);
__isl_give isl_schedule_node *
isl_schedule_node_get_shared_ancestor(
__isl_keep isl_schedule_node *node1,
__isl_keep isl_schedule_node *node2);All nodes in a schedule tree or all descendants of a specific node (including the node) can be visited in depth-first pre-order using the following functions.
#include <isl/schedule.h>
isl_stat isl_schedule_foreach_schedule_node_top_down(
__isl_keep isl_schedule *sched,
isl_bool (*fn)(__isl_keep isl_schedule_node *node,
void *user), void *user);
#include <isl/schedule_node.h>
isl_stat isl_schedule_node_foreach_descendant_top_down(
__isl_keep isl_schedule_node *node,
isl_bool (*fn)(__isl_keep isl_schedule_node *node,
void *user), void *user);The callback function is slightly different from the usual callbacks in that it not only indicates success (non-negative result) or failure (negative result), but also indicates whether the children of the given node should be visited. In particular, if the callback returns a positive value, then the children are visited, but if the callback returns zero, then the children are not visited.
The following functions checks whether all descendants of a specific node (including the node itself) satisfy a user-specified test.
#include <isl/schedule_node.h>
isl_bool isl_schedule_node_every_descendant(
__isl_keep isl_schedule_node *node,
isl_bool (*test)(__isl_keep isl_schedule_node *node,
void *user), void *user)The ancestors of a node in a schedule tree can be visited from the root down to and including the parent of the node using the following function.
#include <isl/schedule_node.h>
isl_stat isl_schedule_node_foreach_ancestor_top_down(
__isl_keep isl_schedule_node *node,
isl_stat (*fn)(__isl_keep isl_schedule_node *node,
void *user), void *user);The following functions allows for a depth-first post-order traversal of the nodes in a schedule tree or of the descendants of a specific node (including the node itself), where the user callback is allowed to modify the visited node.
#include <isl/schedule.h>
__isl_give isl_schedule *
isl_schedule_map_schedule_node_bottom_up(
__isl_take isl_schedule *schedule,
__isl_give isl_schedule_node *(*fn)(
__isl_take isl_schedule_node *node,
void *user), void *user);
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_map_descendant_bottom_up(
__isl_take isl_schedule_node *node,
__isl_give isl_schedule_node *(*fn)(
__isl_take isl_schedule_node *node,
void *user), void *user);The traversal continues from the node returned by the callback function. It is the responsibility of the user to ensure that this does not lead to an infinite loop. It is safest to always return a pointer to the same position (same ancestors and child positions) as the input node.
The following function removes a node (along with its descendants) from a schedule tree and returns a pointer to the leaf at the same position in the updated tree. It is not allowed to remove the root of a schedule tree or a child of a set or sequence node.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *isl_schedule_node_cut(
__isl_take isl_schedule_node *node);The following function removes a single node from a schedule tree and returns a pointer to the child of the node, now located at the position of the original node or to a leaf node at that position if there was no child. It is not allowed to remove the root of a schedule tree, a set or sequence node, a child of a set or sequence node or a band node with an anchored subtree.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *isl_schedule_node_delete(
__isl_take isl_schedule_node *node);Most nodes in a schedule tree only contain local information. In some cases, however, a node may also refer to the schedule dimensions of its outer band nodes. This means that the position of the node within the tree should not be changed, or at least that no changes are performed to the outer band nodes. The following function can be used to test whether the subtree rooted at a given node contains any such nodes.
#include <isl/schedule_node.h>
isl_bool isl_schedule_node_is_subtree_anchored(
__isl_keep isl_schedule_node *node);The following function resets the user pointers on all parameter and tuple identifiers referenced by the given schedule node.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *isl_schedule_node_reset_user(
__isl_take isl_schedule_node *node);The following function aligns the parameters of the given schedule node to the given space.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_align_params(
__isl_take isl_schedule_node *node,
__isl_take isl_space *space);Several node types have their own functions for querying (and in some cases setting) some node type specific properties.
#include <isl/schedule_node.h>
__isl_give isl_space *isl_schedule_node_band_get_space(
__isl_keep isl_schedule_node *node);
__isl_give isl_multi_union_pw_aff *
isl_schedule_node_band_get_partial_schedule(
__isl_keep isl_schedule_node *node);
__isl_give isl_union_map *
isl_schedule_node_band_get_partial_schedule_union_map(
__isl_keep isl_schedule_node *node);
isl_size isl_schedule_node_band_n_member(
__isl_keep isl_schedule_node *node);
isl_bool isl_schedule_node_band_member_get_coincident(
__isl_keep isl_schedule_node *node, int pos);
__isl_give isl_schedule_node *
isl_schedule_node_band_member_set_coincident(
__isl_take isl_schedule_node *node, int pos,
int coincident);
isl_bool isl_schedule_node_band_get_permutable(
__isl_keep isl_schedule_node *node);
__isl_give isl_schedule_node *
isl_schedule_node_band_set_permutable(
__isl_take isl_schedule_node *node, int permutable);
enum isl_ast_loop_type
isl_schedule_node_band_member_get_ast_loop_type(
__isl_keep isl_schedule_node *node, int pos);
__isl_give isl_schedule_node *
isl_schedule_node_band_member_set_ast_loop_type(
__isl_take isl_schedule_node *node, int pos,
enum isl_ast_loop_type type);
enum isl_ast_loop_type
isl_schedule_node_band_member_get_isolate_ast_loop_type(
__isl_keep isl_schedule_node *node, int pos);
__isl_give isl_schedule_node *
isl_schedule_node_band_member_set_isolate_ast_loop_type(
__isl_take isl_schedule_node *node, int pos,
enum isl_ast_loop_type type);
__isl_give isl_union_set *
isl_schedule_node_band_get_ast_build_options(
__isl_keep isl_schedule_node *node);
__isl_give isl_schedule_node *
isl_schedule_node_band_set_ast_build_options(
__isl_take isl_schedule_node *node,
__isl_take isl_union_set *options);
__isl_give isl_set *
isl_schedule_node_band_get_ast_isolate_option(
__isl_keep isl_schedule_node *node);The function isl_schedule_node_band_get_space returns the space of the partial schedule of the band. The function isl_schedule_node_band_get_partial_schedule_union_map returns a representation of the partial schedule of the band node in the form of an isl_union_map. The coincident and permutable properties are set by isl_schedule_constraints_compute_schedule on the schedule tree it produces. A scheduling dimension is considered to be ``coincident'' if it satisfies the coincidence constraints within its band. That is, if the dependence distances of the coincidence constraints are all zero in that direction (for fixed iterations of outer bands). A band is marked permutable if it was produced using the Pluto-like scheduler. Note that the scheduler may have to resort to a Feautrier style scheduling step even if the default scheduler is used. An isl_ast_loop_type is one of isl_ast_loop_default, isl_ast_loop_atomic, isl_ast_loop_unroll or isl_ast_loop_separate. For the meaning of these loop AST generation types and the difference between the regular loop AST generation type and the isolate loop AST generation type, see "AST Generation Options (Schedule Tree)". The functions isl_schedule_node_band_member_get_ast_loop_type and isl_schedule_node_band_member_get_isolate_ast_loop_type may return isl_ast_loop_error if an error occurs. The AST build options govern how an AST is generated for the individual schedule dimensions during AST generation. See "AST Generation Options (Schedule Tree)". The isolate option for the given node can be extracted from these AST build options using the function isl_schedule_node_band_get_ast_isolate_option.
#include <isl/schedule_node.h>
__isl_give isl_set *
isl_schedule_node_context_get_context(
__isl_keep isl_schedule_node *node);
#include <isl/schedule_node.h>
__isl_give isl_union_set *
isl_schedule_node_domain_get_domain(
__isl_keep isl_schedule_node *node);
#include <isl/schedule_node.h>
__isl_give isl_union_map *
isl_schedule_node_expansion_get_expansion(
__isl_keep isl_schedule_node *node);
__isl_give isl_union_pw_multi_aff *
isl_schedule_node_expansion_get_contraction(
__isl_keep isl_schedule_node *node);
#include <isl/schedule_node.h>
__isl_give isl_union_map *
isl_schedule_node_extension_get_extension(
__isl_keep isl_schedule_node *node);
#include <isl/schedule_node.h>
__isl_give isl_union_set *
isl_schedule_node_filter_get_filter(
__isl_keep isl_schedule_node *node);
#include <isl/schedule_node.h>
__isl_give isl_set *isl_schedule_node_guard_get_guard(
__isl_keep isl_schedule_node *node);
#include <isl/schedule_node.h>
__isl_give isl_id *isl_schedule_node_mark_get_id(
__isl_keep isl_schedule_node *node);The following functions can be used to obtain an isl_multi_union_pw_aff, an isl_union_pw_multi_aff or isl_union_map representation of partial schedules related to the node.
#include <isl/schedule_node.h>
__isl_give isl_multi_union_pw_aff *
isl_schedule_node_get_prefix_schedule_multi_union_pw_aff(
__isl_keep isl_schedule_node *node);
__isl_give isl_union_pw_multi_aff *
isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(
__isl_keep isl_schedule_node *node);
__isl_give isl_union_map *
isl_schedule_node_get_prefix_schedule_union_map(
__isl_keep isl_schedule_node *node);
__isl_give isl_union_map *
isl_schedule_node_get_prefix_schedule_relation(
__isl_keep isl_schedule_node *node);
__isl_give isl_union_map *
isl_schedule_node_get_subtree_schedule_union_map(
__isl_keep isl_schedule_node *node);In particular, the functions isl_schedule_node_get_prefix_schedule_multi_union_pw_aff, isl_schedule_node_get_prefix_schedule_union_pw_multi_aff and isl_schedule_node_get_prefix_schedule_union_map return a relative ordering on the domain elements that reach the given node determined by its ancestors. The function isl_schedule_node_get_prefix_schedule_relation additionally includes the domain constraints in the result. The function isl_schedule_node_get_subtree_schedule_union_map returns a representation of the partial schedule defined by the subtree rooted at the given node. If the tree contains any expansion nodes, then the subtree schedule is formulated in terms of the expanded domain elements. The tree passed to functions returning a prefix schedule may only contain extension nodes if these would not affect the result of these functions. That is, if one of the ancestors is an extension node, then all of the domain elements that were added by the extension node need to have been filtered out by filter nodes between the extension node and the input node. The tree passed to isl_schedule_node_get_subtree_schedule_union_map may not contain in extension nodes in the selected subtree.
The expansion/contraction defined by an entire subtree, combining the expansions/contractions on the expansion nodes in the subtree, can be obtained using the following functions.
#include <isl/schedule_node.h>
__isl_give isl_union_map *
isl_schedule_node_get_subtree_expansion(
__isl_keep isl_schedule_node *node);
__isl_give isl_union_pw_multi_aff *
isl_schedule_node_get_subtree_contraction(
__isl_keep isl_schedule_node *node);The total number of outer band members of given node, i.e., the shared output dimension of the maps in the result of isl_schedule_node_get_prefix_schedule_union_map can be obtained using the following function.
#include <isl/schedule_node.h>
isl_size isl_schedule_node_get_schedule_depth(
__isl_keep isl_schedule_node *node);The following functions return the elements that reach the given node or the union of universes in the spaces that contain these elements.
#include <isl/schedule_node.h>
__isl_give isl_union_set *
isl_schedule_node_get_domain(
__isl_keep isl_schedule_node *node);
__isl_give isl_union_set *
isl_schedule_node_get_universe_domain(
__isl_keep isl_schedule_node *node);The input tree of isl_schedule_node_get_domain may only contain extension nodes if these would not affect the result of this function. That is, if one of the ancestors is an extension node, then all of the domain elements that were added by the extension node need to have been filtered out by filter nodes between the extension node and the input node.
The following functions can be used to introduce additional nodes in the schedule tree. The new node is introduced at the point in the tree where the isl_schedule_node points to and the results points to the new node.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_insert_partial_schedule(
__isl_take isl_schedule_node *node,
__isl_take isl_multi_union_pw_aff *schedule);This function inserts a new band node with (the greatest integer part of) the given partial schedule. The subtree rooted at the given node is assumed not to have any anchored nodes.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_insert_context(
__isl_take isl_schedule_node *node,
__isl_take isl_set *context);This function inserts a new context node with the given context constraints.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_insert_filter(
__isl_take isl_schedule_node *node,
__isl_take isl_union_set *filter);This function inserts a new filter node with the given filter. If the original node already pointed to a filter node, then the two filter nodes are merged into one.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_insert_guard(
__isl_take isl_schedule_node *node,
__isl_take isl_set *guard);This function inserts a new guard node with the given guard constraints.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_insert_mark(
__isl_take isl_schedule_node *node,
__isl_take isl_id *mark);This function inserts a new mark node with the give mark identifier.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_insert_sequence(
__isl_take isl_schedule_node *node,
__isl_take isl_union_set_list *filters);
__isl_give isl_schedule_node *
isl_schedule_node_insert_set(
__isl_take isl_schedule_node *node,
__isl_take isl_union_set_list *filters);These functions insert a new sequence or set node with the given filters as children.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *isl_schedule_node_group(
__isl_take isl_schedule_node *node,
__isl_take isl_id *group_id);This function introduces an expansion node in between the current node and its parent that expands instances of a space with tuple identifier group_id to the original domain elements that reach the node. The group instances are identified by the prefix schedule of those domain elements. The ancestors of the node are adjusted to refer to the group instances instead of the original domain elements. The return value points to the same node in the updated schedule tree as the input node, i.e., to the child of the newly introduced expansion node. Grouping instances of different statements ensures that they will be treated as a single statement by the AST generator up to the point of the expansion node.
The following functions can be used to flatten a nested sequence.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_sequence_splice_child(
__isl_take isl_schedule_node *node, int pos);
__isl_give isl_schedule_node *
isl_schedule_node_sequence_splice_children(
__isl_take isl_schedule_node *node);That is, given a sequence node node that has another sequence node in its child at position pos (in particular, the child of that filter node is a sequence node), the function isl_schedule_node_sequence_splice_child attaches the children of that other sequence node as children of node, replacing the original child at position pos. isl_schedule_node_sequence_splice_children does this for all such children.
The partial schedule of a band node can be scaled (down) or reduced using the following functions.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_band_scale(
__isl_take isl_schedule_node *node,
__isl_take isl_multi_val *mv);
__isl_give isl_schedule_node *
isl_schedule_node_band_scale_down(
__isl_take isl_schedule_node *node,
__isl_take isl_multi_val *mv);
__isl_give isl_schedule_node *
isl_schedule_node_band_mod(
__isl_take isl_schedule_node *node,
__isl_take isl_multi_val *mv);The spaces of the two arguments need to match. After scaling, the partial schedule is replaced by its greatest integer part to ensure that the schedule remains integral.
The partial schedule of a band node can be shifted by an isl_multi_union_pw_aff with a domain that is a superset of the domain of the partial schedule using the following function.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_band_shift(
__isl_take isl_schedule_node *node,
__isl_take isl_multi_union_pw_aff *shift);A band node can be tiled using the following function.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *isl_schedule_node_band_tile(
__isl_take isl_schedule_node *node,
__isl_take isl_multi_val *sizes);
isl_stat isl_options_set_tile_scale_tile_loops(isl_ctx *ctx,
int val);
int isl_options_get_tile_scale_tile_loops(isl_ctx *ctx);
isl_stat isl_options_set_tile_shift_point_loops(isl_ctx *ctx,
int val);
int isl_options_get_tile_shift_point_loops(isl_ctx *ctx);The isl_schedule_node_band_tile function tiles the band using the given tile sizes inside its schedule. A new child band node is created to represent the point loops and it is inserted between the modified band and its children. The subtree rooted at the given node is assumed not to have any anchored nodes. The tile_scale_tile_loops option specifies whether the tile loops iterators should be scaled by the tile sizes. If the tile_shift_point_loops option is set, then the point loops are shifted to start at zero.
A band node can be split into two nested band nodes using the following function.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *isl_schedule_node_band_split(
__isl_take isl_schedule_node *node, int pos);The resulting outer band node contains the first pos dimensions of the schedule of node while the inner band contains the remaining dimensions. The schedules of the two band nodes live in anonymous spaces. The loop AST generation type options and the isolate option are split over the two band nodes.
A band node can be moved down to the leaves of the subtree rooted at the band node using the following function.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *isl_schedule_node_band_sink(
__isl_take isl_schedule_node *node);The subtree rooted at the given node is assumed not to have any anchored nodes. The result points to the node in the resulting tree that is in the same position as the node pointed to by node in the original tree.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_order_before(
__isl_take isl_schedule_node *node,
__isl_take isl_union_set *filter);
__isl_give isl_schedule_node *
isl_schedule_node_order_after(
__isl_take isl_schedule_node *node,
__isl_take isl_union_set *filter);These functions split the domain elements that reach node into those that satisfy filter and those that do not and arranges for the elements that do satisfy the filter to be executed before (in case of isl_schedule_node_order_before) or after (in case of isl_schedule_node_order_after) those that do not. The order is imposed by a sequence node, possibly reusing the grandparent of node on two copies of the subtree attached to the original node. Both copies are simplified with respect to their filter.
Return a pointer to the copy of the subtree that does not satisfy filter. If there is no such copy (because all reaching domain elements satisfy the filter), then return the original pointer.
#include <isl/schedule_node.h>
__isl_give isl_schedule_node *
isl_schedule_node_graft_before(
__isl_take isl_schedule_node *node,
__isl_take isl_schedule_node *graft);
__isl_give isl_schedule_node *
isl_schedule_node_graft_after(
__isl_take isl_schedule_node *node,
__isl_take isl_schedule_node *graft);This function inserts the graft tree into the tree containing node such that it is executed before (in case of isl_schedule_node_graft_before) or after (in case of isl_schedule_node_graft_after) node. The root node of graft should be an extension node where the domain of the extension is the flat product of all outer band nodes of node. The root node may also be a domain node. The elements of the domain or the range of the extension may not intersect with the domain elements that reach "node". The schedule tree of graft may not be anchored.
The schedule tree of node is modified to include an extension node corresponding to the root node of graft as a child of the original parent of node. The original node that node points to and the child of the root node of graft are attached to this extension node through a sequence, with appropriate filters and with the child of graft appearing before or after the original node.
If node already appears inside a sequence that is the child of an extension node and if the spaces of the new domain elements do not overlap with those of the original domain elements, then that extension node is extended with the new extension rather than introducing a new segment of extension and sequence nodes.
Return a pointer to the same node in the modified tree that node pointed to in the original tree.
A representation of the schedule node can be printed using
#include <isl/schedule_node.h>
__isl_give isl_printer *isl_printer_print_schedule_node(
__isl_take isl_printer *p,
__isl_keep isl_schedule_node *node);
__isl_give char *isl_schedule_node_to_str(
__isl_keep isl_schedule_node *node);isl_schedule_node_to_str prints the schedule node in block format.
isl contains specialized functionality for performing array dataflow analysis. That is, given a sink access relation, a collection of possible source accesses and a collection of kill accesses, isl can compute relations that describe for each iteration of the sink access, which iterations of which of the source access relations may have accessed the same data element before the given iteration of the sink access without any intermediate kill of that data element. The resulting dependence relations map source iterations to either the corresponding sink iterations or pairs of corresponding sink iterations and accessed data elements. To compute standard flow dependences, the sink should be a read, while the sources should be writes. If no kills are specified, then memory based dependence analysis is performed. If, on the other hand, all sources are also kills, then value based dependence analysis is performed. If any of the source accesses are marked as being must accesses, then they are also treated as kills. Furthermore, the specification of must-sources results in the computation of must-dependences. Only dependences originating in a must access not coscheduled with any other access to the same element and without any may accesses between the must access and the sink access are considered to be must dependences.
A high-level interface to dependence analysis is provided by the following function.
#include <isl/flow.h>
__isl_give isl_union_flow *
isl_union_access_info_compute_flow(
__isl_take isl_union_access_info *access);The input isl_union_access_info object describes the sink access relations, the source access relations and a schedule, while the output isl_union_flow object describes the resulting dependence relations and the subsets of the sink relations for which no source was found.
An isl_union_access_info is created, modified, copied and freed using the following functions.
#include <isl/flow.h>
__isl_give isl_union_access_info *
isl_union_access_info_from_sink(
__isl_take isl_union_map *sink);
__isl_give isl_union_access_info *
isl_union_access_info_set_kill(
__isl_take isl_union_access_info *access,
__isl_take isl_union_map *kill);
__isl_give isl_union_access_info *
isl_union_access_info_set_may_source(
__isl_take isl_union_access_info *access,
__isl_take isl_union_map *may_source);
__isl_give isl_union_access_info *
isl_union_access_info_set_must_source(
__isl_take isl_union_access_info *access,
__isl_take isl_union_map *must_source);
__isl_give isl_union_access_info *
isl_union_access_info_set_schedule(
__isl_take isl_union_access_info *access,
__isl_take isl_schedule *schedule);
__isl_give isl_union_access_info *
isl_union_access_info_set_schedule_map(
__isl_take isl_union_access_info *access,
__isl_take isl_union_map *schedule_map);
__isl_give isl_union_access_info *
isl_union_access_info_copy(
__isl_keep isl_union_access_info *access);
__isl_null isl_union_access_info *
isl_union_access_info_free(
__isl_take isl_union_access_info *access);The may sources set by isl_union_access_info_set_may_source do not need to include the must sources set by isl_union_access_info_set_must_source as a subset. The kills set by isl_union_access_info_set_kill may overlap with the may-sources and/or must-sources. The user is free not to call one (or more) of these functions, in which case the corresponding set is kept to its empty default. Similarly, the default schedule initialized by isl_union_access_info_from_sink is empty. The current schedule is determined by the last call to either isl_union_access_info_set_schedule or isl_union_access_info_set_schedule_map. The domain of the schedule corresponds to the domains of the access relations. In particular, the domains of the access relations are effectively intersected with the domain of the schedule and only the resulting accesses are considered by the dependence analysis.
An isl_union_access_info object can be read from input using the following function.
#include <isl/flow.h>
__isl_give isl_union_access_info *
isl_union_access_info_read_from_file(isl_ctx *ctx,
FILE *input);A representation of the information contained in an object of type isl_union_access_info can be obtained using
#include <isl/flow.h>
__isl_give isl_printer *
isl_printer_print_union_access_info(
__isl_take isl_printer *p,
__isl_keep isl_union_access_info *access);
__isl_give char *isl_union_access_info_to_str(
__isl_keep isl_union_access_info *access);isl_union_access_info_to_str prints the information in flow format.
The output of isl_union_access_info_compute_flow can be examined, copied, and freed using the following functions.
#include <isl/flow.h>
__isl_give isl_union_map *isl_union_flow_get_must_dependence(
__isl_keep isl_union_flow *flow);
__isl_give isl_union_map *isl_union_flow_get_may_dependence(
__isl_keep isl_union_flow *flow);
__isl_give isl_union_map *
isl_union_flow_get_full_must_dependence(
__isl_keep isl_union_flow *flow);
__isl_give isl_union_map *
isl_union_flow_get_full_may_dependence(
__isl_keep isl_union_flow *flow);
__isl_give isl_union_map *isl_union_flow_get_must_no_source(
__isl_keep isl_union_flow *flow);
__isl_give isl_union_map *isl_union_flow_get_may_no_source(
__isl_keep isl_union_flow *flow);
__isl_give isl_union_flow *isl_union_flow_copy(
__isl_keep isl_union_flow *flow);
__isl_null isl_union_flow *isl_union_flow_free(
__isl_take isl_union_flow *flow);The relation returned by isl_union_flow_get_must_dependence relates domain elements of must sources to domain elements of the sink. The relation returned by isl_union_flow_get_may_dependence relates domain elements of must or may sources to domain elements of the sink and includes the previous relation as a subset. The relation returned by isl_union_flow_get_full_must_dependence relates domain elements of must sources to pairs of domain elements of the sink and accessed data elements. The relation returned by isl_union_flow_get_full_may_dependence relates domain elements of must or may sources to pairs of domain elements of the sink and accessed data elements. This relation includes the previous relation as a subset. The relation returned by isl_union_flow_get_must_no_source is the subset of the sink relation for which no dependences have been found. The relation returned by isl_union_flow_get_may_no_source is the subset of the sink relation for which no definite dependences have been found. That is, it contains those sink access that do not contribute to any of the elements in the relation returned by isl_union_flow_get_must_dependence.
A representation of the information contained in an object of type isl_union_flow can be obtained using
#include <isl/flow.h>
__isl_give isl_printer *isl_printer_print_union_flow(
__isl_take isl_printer *p,
__isl_keep isl_union_flow *flow);
__isl_give char *isl_union_flow_to_str(
__isl_keep isl_union_flow *flow);isl_union_flow_to_str prints the information in flow format.
A lower-level interface is provided by the following functions.
#include <isl/flow.h>
typedef int (*isl_access_level_before)(void *first, void *second);
__isl_give isl_access_info *isl_access_info_alloc(
__isl_take isl_map *sink,
void *sink_user, isl_access_level_before fn,
int max_source);
__isl_give isl_access_info *isl_access_info_add_source(
__isl_take isl_access_info *acc,
__isl_take isl_map *source, int must,
void *source_user);
__isl_null isl_access_info *isl_access_info_free(
__isl_take isl_access_info *acc);
__isl_give isl_flow *isl_access_info_compute_flow(
__isl_take isl_access_info *acc);
isl_stat isl_flow_foreach(__isl_keep isl_flow *deps,
isl_stat (*fn)(__isl_take isl_map *dep, int must,
void *dep_user, void *user),
void *user);
__isl_give isl_map *isl_flow_get_no_source(
__isl_keep isl_flow *deps, int must);
__isl_null isl_flow *isl_flow_free(
__isl_take isl_flow *deps);The function isl_access_info_compute_flow performs the actual dependence analysis. The other functions are used to construct the input for this function or to read off the output.
The input is collected in an isl_access_info, which can be created through a call to isl_access_info_alloc. The arguments to this functions are the sink access relation sink, a token sink_user used to identify the sink access to the user, a callback function for specifying the relative order of source and sink accesses, and the number of source access relations that will be added.
The callback function has type int (*)(void *first, void *second). The function is called with two user supplied tokens identifying either a source or the sink and it should return the shared nesting level and the relative order of the two accesses. In particular, let n be the number of loops shared by the two accesses. If first precedes second textually, then the function should return 2 * n + 1; otherwise, it should return 2 * n. The low-level interface assumes that no sources are coscheduled. If the information returned by the callback does not allow the relative order to be determined, then one of the sources is arbitrarily taken to be executed after the other(s).
The sources can be added to the isl_access_info object by performing (at most) max_source calls to isl_access_info_add_source. must indicates whether the source is a must access or a may access. Note that a multi-valued access relation should only be marked must if every iteration in the domain of the relation accesses all elements in its image. The source_user token is again used to identify the source access. The range of the source access relation source should have the same dimension as the range of the sink access relation. The isl_access_info_free function should usually not be called explicitly, because it is already called implicitly by isl_access_info_compute_flow.
The result of the dependence analysis is collected in an isl_flow. There may be elements of the sink access for which no preceding source access could be found or for which all preceding sources are may accesses. The relations containing these elements can be obtained through calls to isl_flow_get_no_source, the first with must set and the second with must unset. In the case of standard flow dependence analysis, with the sink a read and the sources must writes, the first relation corresponds to the reads from uninitialized array elements and the second relation is empty. The actual flow dependences can be extracted using isl_flow_foreach. This function will call the user-specified callback function fn for each non-empty dependence between a source and the sink. The callback function is called with four arguments, the actual flow dependence relation mapping source iterations to sink iterations, a boolean that indicates whether it is a must or may dependence, a token identifying the source and an additional void * with value equal to the third argument of the isl_flow_foreach call. A dependence is marked must if it originates from a must source and if it is not followed by any may sources.
After finishing with an isl_flow, the user should call isl_flow_free to free all associated memory.
During the dependence analysis, we frequently need to perform the following operation. Given a relation between sink iterations and potential source iterations from a particular source domain, what is the last potential source iteration corresponding to each sink iteration. It can sometimes be convenient to adjust the set of potential source iterations before or after each such operation. The prototypical example is fuzzy array dataflow analysis, where we need to analyze if, based on data-dependent constraints, the sink iteration can ever be executed without one or more of the corresponding potential source iterations being executed. If so, we can introduce extra parameters and select an unknown but fixed source iteration from the potential source iterations. To be able to perform such manipulations, isl provides the following function.
#include <isl/flow.h>
typedef __isl_give isl_restriction *(*isl_access_restrict)(
__isl_keep isl_map *source_map,
__isl_keep isl_set *sink, void *source_user,
void *user);
__isl_give isl_access_info *isl_access_info_set_restrict(
__isl_take isl_access_info *acc,
isl_access_restrict fn, void *user);The function isl_access_info_set_restrict should be called before calling isl_access_info_compute_flow and registers a callback function that will be called any time isl is about to compute the last potential source. The first argument is the (reverse) proto-dependence, mapping sink iterations to potential source iterations. The second argument represents the sink iterations for which we want to compute the last source iteration. The third argument is the token corresponding to the source and the final argument is the token passed to isl_access_info_set_restrict. The callback is expected to return a restriction on either the input or the output of the operation computing the last potential source. If the input needs to be restricted then restrictions are needed for both the source and the sink iterations. The sink iterations and the potential source iterations will be intersected with these sets. If the output needs to be restricted then only a restriction on the source iterations is required. If any error occurs, the callback should return NULL. An isl_restriction object can be created, freed and inspected using the following functions.
#include <isl/flow.h>
__isl_give isl_restriction *isl_restriction_input(
__isl_take isl_set *source_restr,
__isl_take isl_set *sink_restr);
__isl_give isl_restriction *isl_restriction_output(
__isl_take isl_set *source_restr);
__isl_give isl_restriction *isl_restriction_none(
__isl_take isl_map *source_map);
__isl_give isl_restriction *isl_restriction_empty(
__isl_take isl_map *source_map);
__isl_null isl_restriction *isl_restriction_free(
__isl_take isl_restriction *restr);isl_restriction_none and isl_restriction_empty are special cases of isl_restriction_input. isl_restriction_none is essentially equivalent to
isl_restriction_input(isl_set_universe(
isl_space_range(isl_map_get_space(source_map))),
isl_set_universe(
isl_space_domain(isl_map_get_space(source_map))));whereas isl_restriction_empty is essentially equivalent to
isl_restriction_input(isl_set_empty(
isl_space_range(isl_map_get_space(source_map))),
isl_set_universe(
isl_space_domain(isl_map_get_space(source_map))));#include <isl/schedule.h>
__isl_give isl_schedule *
isl_schedule_constraints_compute_schedule(
__isl_take isl_schedule_constraints *sc);The function isl_schedule_constraints_compute_schedule can be used to compute a schedule that satisfies the given schedule constraints. These schedule constraints include the iteration domain for which a schedule should be computed and dependences between pairs of iterations. In particular, these dependences include validity dependences and proximity dependences. By default, the algorithm used to construct the schedule is similar to that of Pluto. Alternatively, Feautrier's multi-dimensional scheduling algorithm can be selected. The generated schedule respects all validity dependences. That is, all dependence distances over these dependences in the scheduled space are lexicographically positive.
The default algorithm tries to ensure that the dependence distances over coincidence constraints are zero and to minimize the dependence distances over proximity dependences. Moreover, it tries to obtain sequences (bands) of schedule dimensions for groups of domains where the dependence distances over validity dependences have only non-negative values. Note that when minimizing the maximal dependence distance over proximity dependences, a single affine expression in the parameters is constructed that bounds all dependence distances. If no such expression exists, then the algorithm will fail and resort to an alternative scheduling algorithm. In particular, this means that adding proximity dependences may eliminate valid solutions. A typical example where this phenomenon may occur is when some subset of the proximity dependences has no restriction on some parameter, forcing the coefficient of that parameter to be zero, while some other subset forces the dependence distance to depend on that parameter, requiring the same coefficient to be non-zero. When using Feautrier's algorithm, the coincidence and proximity constraints are only taken into account during the extension to a full-dimensional schedule.
An isl_schedule_constraints object can be constructed and manipulated using the following functions.
#include <isl/schedule.h>
__isl_give isl_schedule_constraints *
isl_schedule_constraints_copy(
__isl_keep isl_schedule_constraints *sc);
__isl_give isl_schedule_constraints *
isl_schedule_constraints_on_domain(
__isl_take isl_union_set *domain);
__isl_give isl_schedule_constraints *
isl_schedule_constraints_set_context(
__isl_take isl_schedule_constraints *sc,
__isl_take isl_set *context);
__isl_give isl_schedule_constraints *
isl_schedule_constraints_set_validity(
__isl_take isl_schedule_constraints *sc,
__isl_take isl_union_map *validity);
__isl_give isl_schedule_constraints *
isl_schedule_constraints_set_coincidence(
__isl_take isl_schedule_constraints *sc,
__isl_take isl_union_map *coincidence);
__isl_give isl_schedule_constraints *
isl_schedule_constraints_set_proximity(
__isl_take isl_schedule_constraints *sc,
__isl_take isl_union_map *proximity);
__isl_give isl_schedule_constraints *
isl_schedule_constraints_set_conditional_validity(
__isl_take isl_schedule_constraints *sc,
__isl_take isl_union_map *condition,
__isl_take isl_union_map *validity);
__isl_give isl_schedule_constraints *
isl_schedule_constraints_apply(
__isl_take isl_schedule_constraints *sc,
__isl_take isl_union_map *umap);
__isl_null isl_schedule_constraints *
isl_schedule_constraints_free(
__isl_take isl_schedule_constraints *sc);The initial isl_schedule_constraints object created by isl_schedule_constraints_on_domain does not impose any constraints. That is, it has an empty set of dependences. The function isl_schedule_constraints_set_context allows the user to specify additional constraints on the parameters that may be assumed to hold during the construction of the schedule. The function isl_schedule_constraints_set_validity replaces the validity dependences, mapping domain elements i to domain elements that should be scheduled after i. The function isl_schedule_constraints_set_coincidence replaces the coincidence dependences, mapping domain elements i to domain elements that should be scheduled together with I, if possible. The function isl_schedule_constraints_set_proximity replaces the proximity dependences, mapping domain elements i to domain elements that should be scheduled either before I or as early as possible after i.
The function isl_schedule_constraints_set_conditional_validity replaces the conditional validity constraints. A conditional validity constraint is only imposed when any of the corresponding conditions is satisfied, i.e., when any of them is non-zero. That is, the scheduler ensures that within each band if the dependence distances over the condition constraints are not all zero then all corresponding conditional validity constraints are respected. A conditional validity constraint corresponds to a condition if the two are adjacent, i.e., if the domain of one relation intersect the range of the other relation. The typical use case of conditional validity constraints is to allow order constraints between live ranges to be violated as long as the live ranges themselves are local to the band. To allow more fine-grained control over which conditions correspond to which conditional validity constraints, the domains and ranges of these relations may include tags. That is, the domains and ranges of those relation may themselves be wrapped relations where the iteration domain appears in the domain of those wrapped relations and the range of the wrapped relations can be arbitrarily chosen by the user. Conditions and conditional validity constraints are only considered adjacent to each other if the entire wrapped relation matches. In particular, a relation with a tag will never be considered adjacent to a relation without a tag.
The function isl_schedule_constraints_apply takes schedule constraints that are defined on some set of domain elements and transforms them to schedule constraints on the elements to which these domain elements are mapped by the given transformation.
An isl_schedule_constraints object can be inspected using the following functions.
#include <isl/schedule.h>
__isl_give isl_union_set *
isl_schedule_constraints_get_domain(
__isl_keep isl_schedule_constraints *sc);
__isl_give isl_set *isl_schedule_constraints_get_context(
__isl_keep isl_schedule_constraints *sc);
__isl_give isl_union_map *
isl_schedule_constraints_get_validity(
__isl_keep isl_schedule_constraints *sc);
__isl_give isl_union_map *
isl_schedule_constraints_get_coincidence(
__isl_keep isl_schedule_constraints *sc);
__isl_give isl_union_map *
isl_schedule_constraints_get_proximity(
__isl_keep isl_schedule_constraints *sc);
__isl_give isl_union_map *
isl_schedule_constraints_get_conditional_validity(
__isl_keep isl_schedule_constraints *sc);
__isl_give isl_union_map *
isl_schedule_constraints_get_conditional_validity_condition(
__isl_keep isl_schedule_constraints *sc);An isl_schedule_constraints object can be read from input using the following functions.
#include <isl/schedule.h>
__isl_give isl_schedule_constraints *
isl_schedule_constraints_read_from_str(isl_ctx *ctx,
const char *str);
__isl_give isl_schedule_constraints *
isl_schedule_constraints_read_from_file(isl_ctx *ctx,
FILE *input);The contents of an isl_schedule_constraints object can be printed using the following functions.
#include <isl/schedule.h>
__isl_give isl_printer *
isl_printer_print_schedule_constraints(
__isl_take isl_printer *p,
__isl_keep isl_schedule_constraints *sc);
__isl_give char *isl_schedule_constraints_to_str(
__isl_keep isl_schedule_constraints *sc);The following function computes a schedule directly from an iteration domain and validity and proximity dependences and is implemented in terms of the functions described above. The use of isl_union_set_compute_schedule is discouraged.
#include <isl/schedule.h>
__isl_give isl_schedule *isl_union_set_compute_schedule(
__isl_take isl_union_set *domain,
__isl_take isl_union_map *validity,
__isl_take isl_union_map *proximity);The generated schedule represents a schedule tree. For more information on schedule trees, see "Schedule Trees".
#include <isl/schedule.h>
isl_stat isl_options_set_schedule_max_coefficient(
isl_ctx *ctx, int val);
int isl_options_get_schedule_max_coefficient(
isl_ctx *ctx);
isl_stat isl_options_set_schedule_max_constant_term(
isl_ctx *ctx, int val);
int isl_options_get_schedule_max_constant_term(
isl_ctx *ctx);
isl_stat isl_options_set_schedule_serialize_sccs(
isl_ctx *ctx, int val);
int isl_options_get_schedule_serialize_sccs(isl_ctx *ctx);
isl_stat isl_options_set_schedule_whole_component(
isl_ctx *ctx, int val);
int isl_options_get_schedule_whole_component(
isl_ctx *ctx);
isl_stat isl_options_set_schedule_maximize_band_depth(
isl_ctx *ctx, int val);
int isl_options_get_schedule_maximize_band_depth(
isl_ctx *ctx);
isl_stat isl_options_set_schedule_maximize_coincidence(
isl_ctx *ctx, int val);
int isl_options_get_schedule_maximize_coincidence(
isl_ctx *ctx);
isl_stat isl_options_set_schedule_outer_coincidence(
isl_ctx *ctx, int val);
int isl_options_get_schedule_outer_coincidence(
isl_ctx *ctx);
isl_stat isl_options_set_schedule_split_scaled(
isl_ctx *ctx, int val);
int isl_options_get_schedule_split_scaled(
isl_ctx *ctx);
isl_stat isl_options_set_schedule_treat_coalescing(
isl_ctx *ctx, int val);
int isl_options_get_schedule_treat_coalescing(
isl_ctx *ctx);
isl_stat isl_options_set_schedule_algorithm(
isl_ctx *ctx, int val);
int isl_options_get_schedule_algorithm(
isl_ctx *ctx);
isl_stat isl_options_set_schedule_carry_self_first(
isl_ctx *ctx, int val);
int isl_options_get_schedule_carry_self_first(
isl_ctx *ctx);
isl_stat isl_options_set_schedule_separate_components(
isl_ctx *ctx, int val);
int isl_options_get_schedule_separate_components(
isl_ctx *ctx);schedule_max_coefficient
This option enforces that the coefficients for variable and parameter dimensions in the calculated schedule are not larger than the specified value. This option can significantly increase the speed of the scheduling calculation and may also prevent fusing of unrelated dimensions. A value of -1 means that this option does not introduce bounds on the variable or parameter coefficients. This option has no effect on the Feautrier style scheduler.
schedule_max_constant_term
This option enforces that the constant coefficients in the calculated schedule are not larger than the maximal constant term. This option can significantly increase the speed of the scheduling calculation and may also prevent fusing of unrelated dimensions. A value of -1 means that this option does not introduce bounds on the constant coefficients.
schedule_serialize_sccs
If this option is set, then all strongly connected components in the dependence graph are serialized as soon as they are detected. This means in particular that instances of statements will only appear in the same band node if these statements belong to the same strongly connected component at the point where the band node is constructed.
schedule_whole_component
If this option is set, then entire (weakly) connected components in the dependence graph are scheduled together as a whole. Otherwise, each strongly connected component within such a weakly connected component is first scheduled separately and then combined with other strongly connected components. This option has no effect if schedule_serialize_sccs is set.
schedule_maximize_band_depth
If this option is set, then the scheduler tries to maximize the width of the bands. Wider bands give more possibilities for tiling. In particular, if the schedule_whole_component option is set, then bands are split if this might result in wider bands. Otherwise, the effect of this option is to only allow strongly connected components to be combined if this does not reduce the width of the bands. Note that if the schedule_serialize_sccs options is set, then the schedule_maximize_band_depth option therefore has no effect.
schedule_maximize_coincidence
This option is only effective if the schedule_whole_component option is turned off. If the schedule_maximize_coincidence option is set, then (clusters of) strongly connected components are only combined with each other if this does not reduce the number of coincident band members.
schedule_outer_coincidence
If this option is set, then we try to construct schedules where the outermost scheduling dimension in each band satisfies the coincidence constraints.
schedule_algorithm
Selects the scheduling algorithm to be used. Available scheduling algorithms are ISL_SCHEDULE_ALGORITHM_ISL and ISL_SCHEDULE_ALGORITHM_FEAUTRIER.
schedule_split_scaled
If this option is set, then we try to construct schedules in which the constant term is split off from the linear part if the linear parts of the scheduling rows for all nodes in the graph have a common non-trivial divisor. The constant term is then dropped and the linear part is reduced. This option is only effective when the Feautrier style scheduler is being used, either as the main scheduler or as a fallback for the Pluto-like scheduler.
schedule_treat_coalescing
If this option is set, then the scheduler will try and avoid producing schedules that perform loop coalescing. In particular, for the Pluto-like scheduler, this option places bounds on the schedule coefficients based on the sizes of the instance sets. For the Feautrier style scheduler, this option detects potentially coalescing schedules and then tries to adjust the schedule to avoid the coalescing.
schedule_carry_self_first
If this option is set, then the Feautrier style scheduler (when used as a fallback for the Pluto-like scheduler) will first try to only carry self-dependences.
schedule_separate_components
If this option is set then the function isl_schedule_get_map will treat set nodes in the same way as sequence nodes.
This section describes the isl functionality for generating ASTs that visit all the elements in a domain in an order specified by a schedule tree or a schedule map. In case the schedule given as a isl_union_map, an AST is generated that visits all the elements in the domain of the isl_union_map according to the lexicographic order of the corresponding image element(s). If the range of the isl_union_map consists of elements in more than one space, then each of these spaces is handled separately in an arbitrary order. It should be noted that the schedule tree or the image elements in a schedule map only specify the order in which the corresponding domain elements should be visited. No direct relation between the partial schedule values or the image elements on the one hand and the loop iterators in the generated AST on the other hand should be assumed.
Each AST is generated within a build. The initial build simply specifies the constraints on the parameters (if any) and can be created, inspected, copied and freed using the following functions.
#include <isl/ast_build.h>
__isl_give isl_ast_build *isl_ast_build_alloc(
isl_ctx *ctx);
__isl_give isl_ast_build *isl_ast_build_from_context(
__isl_take isl_set *set);
__isl_give isl_ast_build *isl_ast_build_copy(
__isl_keep isl_ast_build *build);
__isl_null isl_ast_build *isl_ast_build_free(
__isl_take isl_ast_build *build);The set argument is usually a parameter set with zero or more parameters. In fact, when creating an AST using isl_ast_build_node_from_schedule, this set is required to be a parameter set. An isl_ast_build created using isl_ast_build_alloc does not specify any parameter constraints. More isl_ast_build functions are described in "Nested AST Generation" and "Fine-grained Control over AST Generation". Finally, the AST itself can be constructed using one of the following functions.
#include <isl/ast_build.h>
__isl_give isl_ast_node *isl_ast_build_node_from_schedule(
__isl_keep isl_ast_build *build,
__isl_take isl_schedule *schedule);
__isl_give isl_ast_node *
isl_ast_build_node_from_schedule_map(
__isl_keep isl_ast_build *build,
__isl_take isl_union_map *schedule);The basic properties of an AST node can be obtained as follows.
#include <isl/ast.h>
enum isl_ast_node_type isl_ast_node_get_type(
__isl_keep isl_ast_node *node);The type of an AST node is one of isl_ast_node_for, isl_ast_node_if, isl_ast_node_block, isl_ast_node_mark or isl_ast_node_user. An isl_ast_node_for represents a for node. An isl_ast_node_if represents an if node. An isl_ast_node_block represents a compound node. An isl_ast_node_mark introduces a mark in the AST. An isl_ast_node_user represents an expression statement. An expression statement typically corresponds to a domain element, i.e., one of the elements that is visited by the AST.
Each type of node has its own additional properties.
#include <isl/ast.h>
__isl_give isl_ast_expr *isl_ast_node_for_get_iterator(
__isl_keep isl_ast_node *node);
__isl_give isl_ast_expr *isl_ast_node_for_get_init(
__isl_keep isl_ast_node *node);
__isl_give isl_ast_expr *isl_ast_node_for_get_cond(
__isl_keep isl_ast_node *node);
__isl_give isl_ast_expr *isl_ast_node_for_get_inc(
__isl_keep isl_ast_node *node);
__isl_give isl_ast_node *isl_ast_node_for_get_body(
__isl_keep isl_ast_node *node);
isl_bool isl_ast_node_for_is_degenerate(
__isl_keep isl_ast_node *node);An isl_ast_for is considered degenerate if it is known to execute exactly once.
#include <isl/ast.h>
__isl_give isl_ast_expr *isl_ast_node_if_get_cond(
__isl_keep isl_ast_node *node);
__isl_give isl_ast_node *isl_ast_node_if_get_then_node(
__isl_keep isl_ast_node *node);
__isl_give isl_ast_node *isl_ast_node_if_get_then(
__isl_keep isl_ast_node *node);
isl_bool isl_ast_node_if_has_else_node(
__isl_keep isl_ast_node *node);
isl_bool isl_ast_node_if_has_else(
__isl_keep isl_ast_node *node);
__isl_give isl_ast_node *isl_ast_node_if_get_else_node(
__isl_keep isl_ast_node *node);
__isl_give isl_ast_node *isl_ast_node_if_get_else(
__isl_keep isl_ast_node *node);isl_ast_node_if_get_then, isl_ast_node_if_has_else and isl_ast_node_if_get_else are alternative names for isl_ast_node_if_get_then_node, isl_ast_node_if_has_else_node and isl_ast_node_if_get_else_node, respectively.
__isl_give isl_ast_node_list *
isl_ast_node_block_get_children(
__isl_keep isl_ast_node *node);
__isl_give isl_id *isl_ast_node_mark_get_id(
__isl_keep isl_ast_node *node);
__isl_give isl_ast_node *isl_ast_node_mark_get_node(
__isl_keep isl_ast_node *node);isl_ast_node_mark_get_id returns the identifier of the mark. isl_ast_node_mark_get_node returns the child node that is being marked.
#include <isl/ast.h>
__isl_give isl_ast_expr *isl_ast_node_user_get_expr(
__isl_keep isl_ast_node *node);All descendants of a specific node in the AST (including the node itself) can be visited in depth-first pre-order using the following function.
#include <isl/ast.h>
isl_stat isl_ast_node_foreach_descendant_top_down(
__isl_keep isl_ast_node *node,
isl_bool (*fn)(__isl_keep isl_ast_node *node,
void *user), void *user);The callback function should return isl_bool_true if the children of the given node should be visited and isl_bool_false if they should not. It should return isl_bool_error in case of failure, in which case the entire traversal is aborted.
Each of the returned isl_ast_exprs can in turn be inspected using the following functions.
#include <isl/ast.h>
enum isl_ast_expr_type isl_ast_expr_get_type(
__isl_keep isl_ast_expr *expr);The type of an AST expression is one of isl_ast_expr_op, isl_ast_expr_id or isl_ast_expr_int. An isl_ast_expr_op represents the result of an operation. An isl_ast_expr_id represents an identifier. An isl_ast_expr_int represents an integer value.
Each type of expression has its own additional properties.
#include <isl/ast.h>
enum isl_ast_expr_op_type isl_ast_expr_op_get_type(
__isl_keep isl_ast_expr *expr);
enum isl_ast_expr_op_type isl_ast_expr_get_op_type(
__isl_keep isl_ast_expr *expr);
isl_size isl_ast_expr_op_get_n_arg(__isl_keep isl_ast_expr *expr);
isl_size isl_ast_expr_get_op_n_arg(__isl_keep isl_ast_expr *expr);
__isl_give isl_ast_expr *isl_ast_expr_op_get_arg(
__isl_keep isl_ast_expr *expr, int pos);
__isl_give isl_ast_expr *isl_ast_expr_get_op_arg(
__isl_keep isl_ast_expr *expr, int pos);
isl_stat isl_ast_expr_foreach_ast_expr_op_type(
__isl_keep isl_ast_expr *expr,
isl_stat (*fn)(enum isl_ast_expr_op_type type,
void *user), void *user);
isl_stat isl_ast_expr_foreach_ast_op_type(
__isl_keep isl_ast_expr *expr,
isl_stat (*fn)(enum isl_ast_expr_op_type type,
void *user), void *user);
isl_stat isl_ast_node_foreach_ast_expr_op_type(
__isl_keep isl_ast_node *node,
isl_stat (*fn)(enum isl_ast_expr_op_type type,
void *user), void *user);
isl_stat isl_ast_node_foreach_ast_op_type(
__isl_keep isl_ast_node *node,
isl_stat (*fn)(enum isl_ast_expr_op_type type,
void *user), void *user);isl_ast_expr_op_get_type returns the type of the operation performed. isl_ast_expr_op_get_n_arg returns the number of arguments. isl_ast_expr_get_op_arg returns the specified argument. isl_ast_expr_get_op_type is an alternative name for isl_ast_expr_op_get_type. Similarly, isl_ast_expr_get_op_n_arg is an alternative name for isl_ast_expr_op_get_n_arg and isl_ast_expr_get_op_arg is an alternative name for isl_ast_expr_op_get_arg.
isl_ast_expr_foreach_ast_expr_op_type calls fn for each distinct isl_ast_expr_op_type that appears in expr. isl_ast_expr_foreach_ast_op_type is an alternative name for isl_ast_expr_foreach_ast_expr_op_type. isl_ast_node_foreach_ast_expr_op_type does the same for each distinct isl_ast_expr_op_type that appears in node. isl_ast_node_foreach_ast_op_type is an alternative name for isl_ast_node_foreach_ast_expr_op_type. The operation type is one of the following.
isl_ast_expr_op_andLogical and of two arguments. Both arguments can be evaluated.
isl_ast_expr_op_and_thenLogical and of two arguments. The second argument can only be evaluated if the first evaluates to true.
isl_ast_expr_op_orLogical or of two arguments. Both arguments can be evaluated.
isl_ast_expr_op_or_elseLogical or of two arguments. The second argument can only be evaluated if the first evaluates to false.
isl_ast_expr_op_maxMaximum of two or more arguments.
isl_ast_expr_op_minMinimum of two or more arguments.
isl_ast_expr_op_minusChange sign.
isl_ast_expr_op_addSum of two arguments.
isl_ast_expr_op_subDifference of two arguments.
isl_ast_expr_op_mulProduct of two arguments.
isl_ast_expr_op_divExact division. That is, the result is known to be an integer.
isl_ast_expr_op_fdiv_qResult of integer division, rounded towards negative infinity. The divisor is known to be positive.
isl_ast_expr_op_pdiv_qResult of integer division, where dividend is known to be non-negative. The divisor is known to be positive.
isl_ast_expr_op_pdiv_rRemainder of integer division, where dividend is known to be non-negative. The divisor is known to be positive.
isl_ast_expr_op_zdiv_rEqual to zero iff the remainder on integer division is zero. The divisor is known to be positive.
isl_ast_expr_op_condConditional operator defined on three arguments. If the first argument evaluates to true, then the result is equal to the second argument. Otherwise, the result is equal to the third argument. The second and third argument may only be evaluated if the first argument evaluates to true and false, respectively. Corresponds to a ? b : c in C.
isl_ast_expr_op_selectConditional operator defined on three arguments. If the first argument evaluates to true, then the result is equal to the second argument. Otherwise, the result is equal to the third argument. The second and third argument may be evaluated independently of the value of the first argument. Corresponds to a * b + (1 - a) * c in C.
isl_ast_expr_op_eqEquality relation.
isl_ast_expr_op_leLess than or equal relation.
isl_ast_expr_op_ltLess than relation.
isl_ast_expr_op_geGreater than or equal relation.
isl_ast_expr_op_gtGreater than relation.
isl_ast_expr_op_callA function call. The number of arguments of the isl_ast_expr is one more than the number of arguments in the function call, the first argument representing the function being called.
isl_ast_expr_op_accessAn array access. The number of arguments of the isl_ast_expr is one more than the number of index expressions in the array access, the first argument representing the array being accessed.
isl_ast_expr_op_memberA member access. This operation has two arguments, a structure and the name of the member of the structure being accessed.
isl_ast_expr_op_address_ofThe address of its single argument, which is always an array access.
#include <isl/ast.h>
__isl_give isl_id *isl_ast_expr_id_get_id(
__isl_keep isl_ast_expr *expr);
__isl_give isl_id *isl_ast_expr_get_id(
__isl_keep isl_ast_expr *expr);Return the identifier represented by the AST expression. isl_ast_expr_get_id is an alternative name for isl_ast_expr_id_get_id.
#include <isl/ast.h>
__isl_give isl_val *isl_ast_expr_int_get_val(
__isl_keep isl_ast_expr *expr);
__isl_give isl_val *isl_ast_expr_get_val(
__isl_keep isl_ast_expr *expr);Return the integer represented by the AST expression. isl_ast_expr_get_val is an alternative name for isl_ast_expr_int_get_val.
#include <isl/ast.h>
isl_bool isl_ast_expr_is_equal(
__isl_keep isl_ast_expr *expr1,
__isl_keep isl_ast_expr *expr2);Check if two isl_ast_exprs are equal to each other.
AST nodes can be copied and freed using the following functions.
#include <isl/ast.h>
__isl_give isl_ast_node *isl_ast_node_copy(
__isl_keep isl_ast_node *node);
__isl_null isl_ast_node *isl_ast_node_free(
__isl_take isl_ast_node *node);AST expressions can be copied and freed using the following functions.
#include <isl/ast.h>
__isl_give isl_ast_expr *isl_ast_expr_copy(
__isl_keep isl_ast_expr *expr);
__isl_null isl_ast_expr *isl_ast_expr_free(
__isl_take isl_ast_expr *expr);New AST expressions can be created either directly or within the context of an isl_ast_build.
#include <isl/ast.h>
__isl_give isl_ast_expr *isl_ast_expr_from_val(
__isl_take isl_val *v);
__isl_give isl_ast_expr *isl_ast_expr_from_id(
__isl_take isl_id *id);
__isl_give isl_ast_expr *isl_ast_expr_neg(
__isl_take isl_ast_expr *expr);
__isl_give isl_ast_expr *isl_ast_expr_address_of(
__isl_take isl_ast_expr *expr);
__isl_give isl_ast_expr *isl_ast_expr_add(
__isl_take isl_ast_expr *expr1,
__isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_sub(
__isl_take isl_ast_expr *expr1,
__isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_mul(
__isl_take isl_ast_expr *expr1,
__isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_div(
__isl_take isl_ast_expr *expr1,
__isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_pdiv_q(
__isl_take isl_ast_expr *expr1,
__isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_pdiv_r(
__isl_take isl_ast_expr *expr1,
__isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_and(
__isl_take isl_ast_expr *expr1,
__isl_take isl_ast_expr *expr2)
__isl_give isl_ast_expr *isl_ast_expr_and_then(
__isl_take isl_ast_expr *expr1,
__isl_take isl_ast_expr *expr2)
__isl_give isl_ast_expr *isl_ast_expr_or(
__isl_take isl_ast_expr *expr1,
__isl_take isl_ast_expr *expr2)
__isl_give isl_ast_expr *isl_ast_expr_or_else(
__isl_take isl_ast_expr *expr1,
__isl_take isl_ast_expr *expr2)
__isl_give isl_ast_expr *isl_ast_expr_eq(
__isl_take isl_ast_expr *expr1,
__isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_le(
__isl_take isl_ast_expr *expr1,
__isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_lt(
__isl_take isl_ast_expr *expr1,
__isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_ge(
__isl_take isl_ast_expr *expr1,
__isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_gt(
__isl_take isl_ast_expr *expr1,
__isl_take isl_ast_expr *expr2);
__isl_give isl_ast_expr *isl_ast_expr_access(
__isl_take isl_ast_expr *array,
__isl_take isl_ast_expr_list *indices);
__isl_give isl_ast_expr *isl_ast_expr_call(
__isl_take isl_ast_expr *function,
__isl_take isl_ast_expr_list *arguments);The function isl_ast_expr_address_of can be applied to an isl_ast_expr of type isl_ast_expr_op_access only. It is meant to represent the address of the isl_ast_expr_access. The second argument of the functions isl_ast_expr_pdiv_q and isl_ast_expr_pdiv_r should always evaluate to a positive number. The function isl_ast_expr_and_then as well as isl_ast_expr_or_else are short-circuit versions of isl_ast_expr_and and isl_ast_expr_or, respectively.
#include <isl/ast_build.h>
__isl_give isl_ast_expr *isl_ast_build_expr_from_set(
__isl_keep isl_ast_build *build,
__isl_take isl_set *set);
__isl_give isl_ast_expr *isl_ast_build_expr_from_pw_aff(
__isl_keep isl_ast_build *build,
__isl_take isl_pw_aff *pa);
__isl_give isl_ast_expr *
isl_ast_build_access_from_pw_multi_aff(
__isl_keep isl_ast_build *build,
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_ast_expr *
isl_ast_build_access_from_multi_pw_aff(
__isl_keep isl_ast_build *build,
__isl_take isl_multi_pw_aff *mpa);
__isl_give isl_ast_expr *
isl_ast_build_call_from_pw_multi_aff(
__isl_keep isl_ast_build *build,
__isl_take isl_pw_multi_aff *pma);
__isl_give isl_ast_expr *
isl_ast_build_call_from_multi_pw_aff(
__isl_keep isl_ast_build *build,
__isl_take isl_multi_pw_aff *mpa);The set set and the domains of pa, mpa and pma should correspond to the schedule space of build. The tuple id of mpa or pma is used as the array being accessed or the function being called. If the accessed space is a nested relation, then it is taken to represent an access of the member specified by the range of this nested relation of the structure specified by the domain of the nested relation.
The following functions can be used to modify an isl_ast_expr.
#include <isl/ast.h>
__isl_give isl_ast_expr *isl_ast_expr_set_op_arg(
__isl_take isl_ast_expr *expr, int pos,
__isl_take isl_ast_expr *arg);Replace the argument of expr at position pos by arg.
#include <isl/ast.h>
__isl_give isl_ast_expr *isl_ast_expr_substitute_ids(
__isl_take isl_ast_expr *expr,
__isl_take isl_id_to_ast_expr *id2expr);The function isl_ast_expr_substitute_ids replaces the subexpressions of expr of type isl_ast_expr_id by the corresponding expression in id2expr, if there is any.
The following function can be used to modify the descendants of a specific node in an AST using a depth-first post-order traversal of those descendants (including the node itself).
#include <isl/ast.h>
__isl_give isl_ast_node *
isl_ast_node_map_descendant_bottom_up(
__isl_take isl_ast_node *node,
__isl_give isl_ast_node *(*fn)(
__isl_take isl_ast_node *node,
void *user), void *user);User specified data can be attached to an isl_ast_node and obtained from the same isl_ast_node using the following functions.
#include <isl/ast.h>
__isl_give isl_ast_node *isl_ast_node_set_annotation(
__isl_take isl_ast_node *node,
__isl_take isl_id *annotation);
__isl_give isl_id *isl_ast_node_get_annotation(
__isl_keep isl_ast_node *node);Basic printing can be performed using the following functions.
#include <isl/ast.h>
__isl_give isl_printer *isl_printer_print_ast_expr(
__isl_take isl_printer *p,
__isl_keep isl_ast_expr *expr);
__isl_give isl_printer *isl_printer_print_ast_node(
__isl_take isl_printer *p,
__isl_keep isl_ast_node *node);
__isl_give char *isl_ast_expr_to_str(
__isl_keep isl_ast_expr *expr);
__isl_give char *isl_ast_node_to_str(
__isl_keep isl_ast_node *node);
__isl_give char *isl_ast_expr_to_C_str(
__isl_keep isl_ast_expr *expr);
__isl_give char *isl_ast_node_to_C_str(
__isl_keep isl_ast_node *node);The functions isl_ast_expr_to_C_str and isl_ast_node_to_C_str are convenience functions that return a string representation of the input in C format.
More advanced printing can be performed using the following functions.
#include <isl/ast.h>
__isl_give isl_printer *
isl_ast_expr_op_type_set_print_name(
__isl_take isl_printer *p,
enum isl_ast_expr_op_type type,
__isl_keep const char *name);
__isl_give isl_printer *isl_ast_op_type_set_print_name(
__isl_take isl_printer *p,
enum isl_ast_expr_op_type type,
__isl_keep const char *name);
isl_stat isl_options_set_ast_print_macro_once(
isl_ctx *ctx, int val);
int isl_options_get_ast_print_macro_once(isl_ctx *ctx);
__isl_give isl_printer *isl_ast_expr_op_type_print_macro(
enum isl_ast_expr_op_type type,
__isl_take isl_printer *p);
__isl_give isl_printer *isl_ast_op_type_print_macro(
enum isl_ast_expr_op_type type,
__isl_take isl_printer *p);
__isl_give isl_printer *isl_ast_expr_print_macros(
__isl_keep isl_ast_expr *expr,
__isl_take isl_printer *p);
__isl_give isl_printer *isl_ast_node_print_macros(
__isl_keep isl_ast_node *node,
__isl_take isl_printer *p);
__isl_give isl_printer *isl_ast_node_print(
__isl_keep isl_ast_node *node,
__isl_take isl_printer *p,
__isl_take isl_ast_print_options *options);
__isl_give isl_printer *isl_ast_node_for_print(
__isl_keep isl_ast_node *node,
__isl_take isl_printer *p,
__isl_take isl_ast_print_options *options);
__isl_give isl_printer *isl_ast_node_if_print(
__isl_keep isl_ast_node *node,
__isl_take isl_printer *p,
__isl_take isl_ast_print_options *options);While printing an isl_ast_node in ISL_FORMAT_C, isl may print out an AST that makes use of macros such as floord, min and max. The names of these macros may be modified by a call to isl_ast_expr_op_type_set_print_name. The user-specified names are associated to the printer object. isl_ast_op_type_set_print_name is an alternative name for isl_ast_expr_op_type_set_print_name. isl_ast_expr_op_type_print_macro prints out the macro corresponding to a specific isl_ast_expr_op_type. If the print-macro-once option is set, then a given macro definition is only printed once to any given printer object. isl_ast_op_type_print_macro is an alternative name for isl_ast_expr_op_type_print_macro. isl_ast_expr_print_macros scans the isl_ast_expr for subexpressions where these macros would be used and prints out the required macro definitions. Essentially, isl_ast_expr_print_macros calls isl_ast_expr_foreach_ast_expr_op_type with isl_ast_expr_op_type_print_macro as function argument. isl_ast_node_print_macros does the same for expressions in its isl_ast_node argument. isl_ast_node_print, isl_ast_node_for_print and isl_ast_node_if_print print an isl_ast_node in ISL_FORMAT_C, but allow for some extra control through an isl_ast_print_options object. This object can be created using the following functions.
#include <isl/ast.h>
__isl_give isl_ast_print_options *
isl_ast_print_options_alloc(isl_ctx *ctx);
__isl_give isl_ast_print_options *
isl_ast_print_options_copy(
__isl_keep isl_ast_print_options *options);
__isl_null isl_ast_print_options *
isl_ast_print_options_free(
__isl_take isl_ast_print_options *options);
__isl_give isl_ast_print_options *
isl_ast_print_options_set_print_user(
__isl_take isl_ast_print_options *options,
__isl_give isl_printer *(*print_user)(
__isl_take isl_printer *p,
__isl_take isl_ast_print_options *options,
__isl_keep isl_ast_node *node, void *user),
void *user);
__isl_give isl_ast_print_options *
isl_ast_print_options_set_print_for(
__isl_take isl_ast_print_options *options,
__isl_give isl_printer *(*print_for)(
__isl_take isl_printer *p,
__isl_take isl_ast_print_options *options,
__isl_keep isl_ast_node *node, void *user),
void *user);The callback set by isl_ast_print_options_set_print_user is called whenever a node of type isl_ast_node_user needs to be printed. The callback set by isl_ast_print_options_set_print_for is called whenever a node of type isl_ast_node_for needs to be printed. Note that isl_ast_node_for_print will not call the callback set by isl_ast_print_options_set_print_for on the node on which isl_ast_node_for_print is called, but only on nested nodes of type isl_ast_node_for. It is therefore safe to call isl_ast_node_for_print from within the callback set by isl_ast_print_options_set_print_for.
The following option determines the type to be used for iterators while printing the AST.
isl_stat isl_options_set_ast_iterator_type(
isl_ctx *ctx, const char *val);
const char *isl_options_get_ast_iterator_type(
isl_ctx *ctx);The AST printer only prints body nodes of if and for nodes as blocks if these blocks cannot be safely omitted. For example, a for node with one body node will not be surrounded with braces in ISL_FORMAT_C. A block will always be printed by setting the following option.
isl_stat isl_options_set_ast_always_print_block(isl_ctx *ctx,
int val);
int isl_options_get_ast_always_print_block(isl_ctx *ctx);Explicit block nodes that appear inside the AST are always printed as blocks. If the block node appears as the outermost node, then it is only printed if the following option is set.
isl_stat isl_options_set_ast_print_outermost_block(
isl_ctx *ctx, int val);
int isl_options_get_ast_print_outermost_block(
isl_ctx *ctx);#include <isl/ast_build.h>
isl_stat isl_options_set_ast_build_atomic_upper_bound(
isl_ctx *ctx, int val);
int isl_options_get_ast_build_atomic_upper_bound(
isl_ctx *ctx);
isl_stat isl_options_set_ast_build_prefer_pdiv(isl_ctx *ctx,
int val);
int isl_options_get_ast_build_prefer_pdiv(isl_ctx *ctx);
isl_stat isl_options_set_ast_build_detect_min_max(
isl_ctx *ctx, int val);
int isl_options_get_ast_build_detect_min_max(
isl_ctx *ctx);
isl_stat isl_options_set_ast_build_exploit_nested_bounds(
isl_ctx *ctx, int val);
int isl_options_get_ast_build_exploit_nested_bounds(
isl_ctx *ctx);
isl_stat isl_options_set_ast_build_group_coscheduled(
isl_ctx *ctx, int val);
int isl_options_get_ast_build_group_coscheduled(
isl_ctx *ctx);
isl_stat isl_options_set_ast_build_separation_bounds(
isl_ctx *ctx, int val);
int isl_options_get_ast_build_separation_bounds(
isl_ctx *ctx);
isl_stat isl_options_set_ast_build_scale_strides(
isl_ctx *ctx, int val);
int isl_options_get_ast_build_scale_strides(
isl_ctx *ctx);
isl_stat isl_options_set_ast_build_allow_else(isl_ctx *ctx,
int val);
int isl_options_get_ast_build_allow_else(isl_ctx *ctx);
isl_stat isl_options_set_ast_build_allow_or(isl_ctx *ctx,
int val);
int isl_options_get_ast_build_allow_or(isl_ctx *ctx);ast_build_atomic_upper_bound
Generate loop upper bounds that consist of the current loop iterator, an operator and an expression not involving the iterator. If this option is not set, then the current loop iterator may appear several times in the upper bound. For example, when this option is turned off, AST generation for the schedule
[n] -> { A[i] -> [i] : 0 <= i <= 100, n }produces
for (int c0 = 0; c0 <= 100 && n >= c0; c0 += 1)
A(c0);When the option is turned on, the following AST is generated
for (int c0 = 0; c0 <= min(100, n); c0 += 1)
A(c0);ast_build_prefer_pdiv
If this option is turned off, then the AST generation will produce ASTs that may only contain isl_ast_expr_op_fdiv_q operators, but no isl_ast_expr_op_pdiv_q or isl_ast_expr_op_pdiv_r operators. If this option is turned on, then isl will try to convert some of the isl_ast_expr_op_fdiv_q operators to (expressions containing) isl_ast_expr_op_pdiv_q or isl_ast_expr_op_pdiv_r operators.
ast_build_detect_min_max
If this option is turned on, then isl will try and detect min or max-expressions when building AST expressions from piecewise affine expressions.
ast_build_exploit_nested_bounds
Simplify conditions based on bounds of nested for loops. In particular, remove conditions that are implied by the fact that one or more nested loops have at least one iteration, meaning that the upper bound is at least as large as the lower bound. For example, when this option is turned off, AST generation for the schedule
[N,M] -> { A[i,j] -> [i,j] : 0 <= i <= N and
0 <= j <= M }produces
if (M >= 0)
for (int c0 = 0; c0 <= N; c0 += 1)
for (int c1 = 0; c1 <= M; c1 += 1)
A(c0, c1);When the option is turned on, the following AST is generated
for (int c0 = 0; c0 <= N; c0 += 1)
for (int c1 = 0; c1 <= M; c1 += 1)
A(c0, c1);ast_build_group_coscheduled
If two domain elements are assigned the same schedule point, then they may be executed in any order and they may even appear in different loops. If this options is set, then the AST generator will make sure that coscheduled domain elements do not appear in separate parts of the AST. This is useful in case of nested AST generation if the outer AST generation is given only part of a schedule and the inner AST generation should handle the domains that are coscheduled by this initial part of the schedule together. For example if an AST is generated for a schedule
{ A[i] -> [0]; B[i] -> [0] }then the isl_ast_build_set_create_leaf callback described below may get called twice, once for each domain. Setting this option ensures that the callback is only called once on both domains together.
ast_build_separation_bounds
This option specifies which bounds to use during separation. If this option is set to ISL_AST_BUILD_SEPARATION_BOUNDS_IMPLICIT then all (possibly implicit) bounds on the current dimension will be used during separation. If this option is set to ISL_AST_BUILD_SEPARATION_BOUNDS_EXPLICIT then only those bounds that are explicitly available will be used during separation.
ast_build_scale_strides
This option specifies whether the AST generator is allowed to scale down iterators of strided loops.
ast_build_allow_else
This option specifies whether the AST generator is allowed to construct if statements with else branches.
ast_build_allow_or
This option specifies whether the AST generator is allowed to construct if conditions with disjunctions.
In case of AST construction from a schedule tree, the options that control how an AST is created from the individual schedule dimensions are stored in the band nodes of the tree (see "Schedule Trees").
In particular, a schedule dimension can be handled in four different ways, atomic, separate, unroll or the default. This loop AST generation type can be set using isl_schedule_node_band_member_set_ast_loop_type. Alternatively, the first three can be selected by including a one-dimensional element with as value the position of the schedule dimension within the band and as name one of atomic, separate or unroll in the options set by isl_schedule_node_band_set_ast_build_options. Only one of these three may be specified for any given schedule dimension within a band node. If none of these is specified, then the default is used. The meaning of the options is as follows.
atomicWhen this option is specified, the AST generator will make sure that a given domain space only appears in a single loop at the specified level.
For example, for the schedule tree
domain: "{ a[i] : 0 <= i < 10; b[i] : 0 <= i < 10 }"
child:
schedule: "[{ a[i] -> [i]; b[i] -> [i+1] }]"
options: "{ atomic[x] }"the following AST will be generated
for (int c0 = 0; c0 <= 10; c0 += 1) {
if (c0 >= 1)
b(c0 - 1);
if (c0 <= 9)
a(c0);
}On the other hand, for the schedule tree
domain: "{ a[i] : 0 <= i < 10; b[i] : 0 <= i < 10 }"
child:
schedule: "[{ a[i] -> [i]; b[i] -> [i+1] }]"
options: "{ separate[x] }"the following AST will be generated
{
a(0);
for (int c0 = 1; c0 <= 9; c0 += 1) {
b(c0 - 1);
a(c0);
}
b(9);
}If neither atomic nor separate is specified, then the AST generator may produce either of these two results or some intermediate form.
separateWhen this option is specified, the AST generator will split the domain of the specified schedule dimension into pieces with a fixed set of statements for which instances need to be executed by the iterations in the schedule domain part. This option tends to avoid the generation of guards inside the corresponding loops. See also the atomic option.
unrollWhen this option is specified, the AST generator will completely unroll the corresponding schedule dimension. It is the responsibility of the user to ensure that such unrolling is possible. To obtain a partial unrolling, the user should apply an additional strip-mining to the schedule and fully unroll the inner schedule dimension.
The isolate option is a bit more involved. It allows the user to isolate a range of schedule dimension values from smaller and greater values. Additionally, the user may specify a different atomic/separate/unroll choice for the isolated part and the remaining parts. The typical use case of the isolate option is to isolate full tiles from partial tiles. The part that needs to be isolated may depend on outer schedule dimensions. The option therefore needs to be able to reference those outer schedule dimensions. In particular, the space of the isolate option is that of a wrapped map with as domain the flat product of all outer band nodes and as range the space of the current band node. The atomic/separate/unroll choice for the isolated part is determined by an option that lives in an unnamed wrapped space with as domain a zero-dimensional isolate space and as range the regular atomic, separate or unroll space. This option may also be set directly using isl_schedule_node_band_member_set_isolate_ast_loop_type. The atomic/separate/unroll choice for the remaining part is determined by the regular atomic, separate or unroll option. Since the isolate option references outer schedule dimensions, its use in a band node causes any tree containing the node to be considered anchored.
As an example, consider the isolation of full tiles from partial tiles in a tiling of a triangular domain. The original schedule is as follows.
domain: "{ A[i,j] : 0 <= i,j and i + j <= 100 }"
child:
schedule: "[{ A[i,j] -> [floor(i/10)] }, \
{ A[i,j] -> [floor(j/10)] }, \
{ A[i,j] -> [i] }, { A[i,j] -> [j] }]"The output is
for (int c0 = 0; c0 <= 10; c0 += 1)
for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
for (int c2 = 10 * c0;
c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
for (int c3 = 10 * c1;
c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
A(c2, c3);Isolating the full tiles, we have the following input
domain: "{ A[i,j] : 0 <= i,j and i + j <= 100 }"
child:
schedule: "[{ A[i,j] -> [floor(i/10)] }, \
{ A[i,j] -> [floor(j/10)] }, \
{ A[i,j] -> [i] }, { A[i,j] -> [j] }]"
options: "{ isolate[[] -> [a,b,c,d]] : 0 <= 10a,10b and \
10a+9+10b+9 <= 100 }"and output
{
for (int c0 = 0; c0 <= 8; c0 += 1) {
for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
for (int c2 = 10 * c0;
c2 <= 10 * c0 + 9; c2 += 1)
for (int c3 = 10 * c1;
c3 <= 10 * c1 + 9; c3 += 1)
A(c2, c3);
for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
for (int c2 = 10 * c0;
c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
for (int c3 = 10 * c1;
c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
A(c2, c3);
}
for (int c0 = 9; c0 <= 10; c0 += 1)
for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
for (int c2 = 10 * c0;
c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
for (int c3 = 10 * c1;
c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
A(c2, c3);
}We may then additionally unroll the innermost loop of the isolated part
domain: "{ A[i,j] : 0 <= i,j and i + j <= 100 }"
child:
schedule: "[{ A[i,j] -> [floor(i/10)] }, \
{ A[i,j] -> [floor(j/10)] }, \
{ A[i,j] -> [i] }, { A[i,j] -> [j] }]"
options: "{ isolate[[] -> [a,b,c,d]] : 0 <= 10a,10b and \
10a+9+10b+9 <= 100; [isolate[] -> unroll[3]] }"to obtain
{
for (int c0 = 0; c0 <= 8; c0 += 1) {
for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
for (int c2 = 10 * c0; c2 <= 10 * c0 + 9; c2 += 1) {
A(c2, 10 * c1);
A(c2, 10 * c1 + 1);
A(c2, 10 * c1 + 2);
A(c2, 10 * c1 + 3);
A(c2, 10 * c1 + 4);
A(c2, 10 * c1 + 5);
A(c2, 10 * c1 + 6);
A(c2, 10 * c1 + 7);
A(c2, 10 * c1 + 8);
A(c2, 10 * c1 + 9);
}
for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
for (int c2 = 10 * c0;
c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
for (int c3 = 10 * c1;
c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
A(c2, c3);
}
for (int c0 = 9; c0 <= 10; c0 += 1)
for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
for (int c2 = 10 * c0;
c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
for (int c3 = 10 * c1;
c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
A(c2, c3);
}In case of AST construction using isl_ast_build_node_from_schedule_map, the options that control how an AST is created from the individual schedule dimensions are stored in the isl_ast_build. They can be set using the following function.
#include <isl/ast_build.h>
__isl_give isl_ast_build *
isl_ast_build_set_options(
__isl_take isl_ast_build *build,
__isl_take isl_union_map *options);The options are encoded in an isl_union_map. The domain of this union relation refers to the schedule domain, i.e., the range of the schedule passed to isl_ast_build_node_from_schedule_map. In the case of nested AST generation (see "Nested AST Generation"), the domain of options should refer to the extra piece of the schedule. That is, it should be equal to the range of the wrapped relation in the range of the schedule. The range of the options can consist of elements in one or more spaces, the names of which determine the effect of the option. The values of the range typically also refer to the schedule dimension to which the option applies, with value 0 representing the outermost schedule dimension. In case of nested AST generation (see "Nested AST Generation"), these values refer to the position of the schedule dimension within the innermost AST generation. The constraints on the domain elements of the option should only refer to this dimension and earlier dimensions. We consider the following spaces.
separation_classThis option has been deprecated. Use the isolate option on schedule trees instead.
This space is a wrapped relation between two one dimensional spaces. The input space represents the schedule dimension to which the option applies and the output space represents the separation class. While constructing a loop corresponding to the specified schedule dimension(s), the AST generator will try to generate separate loops for domain elements that are assigned different classes. If only some of the elements are assigned a class, then those elements that are not assigned any class will be treated as belonging to a class that is separate from the explicitly assigned classes. The typical use case for this option is to separate full tiles from partial tiles. The other options, described below, are applied after the separation into classes.
As an example, consider the separation into full and partial tiles of a tiling of a triangular domain. Take, for example, the domain
{ A[i,j] : 0 <= i,j and i + j <= 100 }and a tiling into tiles of 10 by 10. The input to the AST generator is then the schedule
{ A[i,j] -> [([i/10]),[j/10],i,j] : 0 <= i,j and
i + j <= 100 }Without any options, the following AST is generated
for (int c0 = 0; c0 <= 10; c0 += 1)
for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
for (int c2 = 10 * c0;
c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
c2 += 1)
for (int c3 = 10 * c1;
c3 <= min(10 * c1 + 9, -c2 + 100);
c3 += 1)
A(c2, c3);Separation into full and partial tiles can be obtained by assigning a class, say 0, to the full tiles. The full tiles are represented by those values of the first and second schedule dimensions for which there are values of the third and fourth dimensions to cover an entire tile. That is, we need to specify the following option
{ [a,b,c,d] -> separation_class[[0]->[0]] :
exists b': 0 <= 10a,10b' and
10a+9+10b'+9 <= 100;
[a,b,c,d] -> separation_class[[1]->[0]] :
0 <= 10a,10b and 10a+9+10b+9 <= 100 }which simplifies to
{ [a, b, c, d] -> separation_class[[1] -> [0]] :
a >= 0 and b >= 0 and b <= 8 - a;
[a, b, c, d] -> separation_class[[0] -> [0]] :
a >= 0 and a <= 8 }With this option, the generated AST is as follows
{
for (int c0 = 0; c0 <= 8; c0 += 1) {
for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
for (int c2 = 10 * c0;
c2 <= 10 * c0 + 9; c2 += 1)
for (int c3 = 10 * c1;
c3 <= 10 * c1 + 9; c3 += 1)
A(c2, c3);
for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
for (int c2 = 10 * c0;
c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
c2 += 1)
for (int c3 = 10 * c1;
c3 <= min(-c2 + 100, 10 * c1 + 9);
c3 += 1)
A(c2, c3);
}
for (int c0 = 9; c0 <= 10; c0 += 1)
for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
for (int c2 = 10 * c0;
c2 <= min(-10 * c1 + 100, 10 * c0 + 9);
c2 += 1)
for (int c3 = 10 * c1;
c3 <= min(10 * c1 + 9, -c2 + 100);
c3 += 1)
A(c2, c3);
}separateThis is a single-dimensional space representing the schedule dimension(s) to which ``separation'' should be applied. Separation tries to split a loop into several pieces if this can avoid the generation of guards inside the loop. See also the atomic option.
atomicThis is a single-dimensional space representing the schedule dimension(s) for which the domains should be considered ``atomic''. That is, the AST generator will make sure that any given domain space will only appear in a single loop at the specified level.
Consider the following schedule
{ a[i] -> [i] : 0 <= i < 10;
b[i] -> [i+1] : 0 <= i < 10 }If the following option is specified
{ [i] -> separate[x] }then the following AST will be generated
{
a(0);
for (int c0 = 1; c0 <= 9; c0 += 1) {
a(c0);
b(c0 - 1);
}
b(9);
}If, on the other hand, the following option is specified
{ [i] -> atomic[x] }then the following AST will be generated
for (int c0 = 0; c0 <= 10; c0 += 1) {
if (c0 <= 9)
a(c0);
if (c0 >= 1)
b(c0 - 1);
}If neither atomic nor separate is specified, then the AST generator may produce either of these two results or some intermediate form.
unrollThis is a single-dimensional space representing the schedule dimension(s) that should be completely unrolled. To obtain a partial unrolling, the user should apply an additional strip-mining to the schedule and fully unroll the inner loop.
Besides specifying the constraints on the parameters, an isl_ast_build object can be used to control various aspects of the AST generation process. In case of AST construction using isl_ast_build_node_from_schedule_map, the most prominent way of control is through ``options'', as explained above.
Additional control is available through the following functions.
#include <isl/ast_build.h>
__isl_give isl_ast_build *
isl_ast_build_set_iterators(
__isl_take isl_ast_build *build,
__isl_take isl_id_list *iterators);The function isl_ast_build_set_iterators allows the user to specify a list of iterator isl_ids to be used as iterators. If the input schedule is injective, then the number of elements in this list should be as large as the dimension of the schedule space, but no direct correspondence should be assumed between dimensions and elements. If the input schedule is not injective, then an additional number of isl_ids equal to the largest dimension of the input domains may be required. If the number of provided isl_ids is insufficient, then additional names are automatically generated.
#include <isl/ast_build.h>
__isl_give isl_ast_build *
isl_ast_build_set_create_leaf(
__isl_take isl_ast_build *build,
__isl_give isl_ast_node *(*fn)(
__isl_take isl_ast_build *build,
void *user), void *user);The isl_ast_build_set_create_leaf function allows for the specification of a callback that should be called whenever the AST generator arrives at an element of the schedule domain. The callback should return an AST node that should be inserted at the corresponding position of the AST. The default action (when the callback is not set) is to continue generating parts of the AST to scan all the domain elements associated to the schedule domain element and to insert user nodes, ``calling'' the domain element, for each of them. The build argument contains the current state of the isl_ast_build. To ease nested AST generation (see "Nested AST Generation"), all control information that is specific to the current AST generation such as the options and the callbacks has been removed from this isl_ast_build. The callback would typically return the result of a nested AST generation or a user defined node created using the following function.
#include <isl/ast.h>
__isl_give isl_ast_node *isl_ast_node_user_from_expr(
__isl_take isl_ast_expr *expr);
__isl_give isl_ast_node *isl_ast_node_alloc_user(
__isl_take isl_ast_expr *expr);isl_ast_node_alloc_user is an alternative name for isl_ast_node_user_from_expr.
In some cases, a single user defined node is not enough, in which case the following function can be used to create a block node from multiple AST nodes.
#include <isl/ast.h>
__isl_give isl_ast_node *isl_ast_node_block_from_children(
__isl_take isl_ast_node_list *list);
#include <isl/ast_build.h>
__isl_give isl_ast_build *
isl_ast_build_set_at_each_domain(
__isl_take isl_ast_build *build,
__isl_give isl_ast_node *(*fn)(
__isl_take isl_ast_node *node,
__isl_keep isl_ast_build *build,
void *user), void *user);
__isl_give isl_ast_build *
isl_ast_build_set_before_each_for(
__isl_take isl_ast_build *build,
__isl_give isl_id *(*fn)(
__isl_keep isl_ast_build *build,
void *user), void *user);
__isl_give isl_ast_build *
isl_ast_build_set_after_each_for(
__isl_take isl_ast_build *build,
__isl_give isl_ast_node *(*fn)(
__isl_take isl_ast_node *node,
__isl_keep isl_ast_build *build,
void *user), void *user);
__isl_give isl_ast_build *
isl_ast_build_set_before_each_mark(
__isl_take isl_ast_build *build,
isl_stat (*fn)(__isl_keep isl_id *mark,
__isl_keep isl_ast_build *build,
void *user), void *user);
__isl_give isl_ast_build *
isl_ast_build_set_after_each_mark(
__isl_take isl_ast_build *build,
__isl_give isl_ast_node *(*fn)(
__isl_take isl_ast_node *node,
__isl_keep isl_ast_build *build,
void *user), void *user);The callback set by isl_ast_build_set_at_each_domain will be called for each domain AST node. The callbacks set by isl_ast_build_set_before_each_for and isl_ast_build_set_after_each_for will be called for each for AST node. The first will be called in depth-first pre-order, while the second will be called in depth-first post-order. Since isl_ast_build_set_before_each_for is called before the for node is actually constructed, it is only passed an isl_ast_build. The returned isl_id will be added as an annotation (using isl_ast_node_set_annotation) to the constructed for node. In particular, if the user has also specified an after_each_for callback, then the annotation can be retrieved from the node passed to that callback using isl_ast_node_get_annotation. The callbacks set by isl_ast_build_set_before_each_mark and isl_ast_build_set_after_each_mark will be called for each mark AST node that is created, i.e., for each mark schedule node in the input schedule tree. The first will be called in depth-first pre-order, while the second will be called in depth-first post-order. Since the callback set by isl_ast_build_set_before_each_mark is called before the mark AST node is actually constructed, it is passed the identifier of the mark node. All callbacks should NULL (or isl_stat_error) on failure. The given isl_ast_build can be used to create new isl_ast_expr objects using isl_ast_build_expr_from_pw_aff or isl_ast_build_call_from_pw_multi_aff.
isl allows the user to create an AST within the context of another AST. These nested ASTs are created using the same isl_ast_build_node_from_schedule_map function that is used to create the outer AST. The build argument should be an isl_ast_build passed to a callback set by isl_ast_build_set_create_leaf. The space of the range of the schedule argument should refer to this build. In particular, the space should be a wrapped relation and the domain of this wrapped relation should be the same as that of the range of the schedule returned by isl_ast_build_get_schedule below. In practice, the new schedule is typically created by calling isl_union_map_range_product on the old schedule and some extra piece of the schedule. The space of the schedule domain is also available from the isl_ast_build.
#include <isl/ast_build.h>
__isl_give isl_union_map *isl_ast_build_get_schedule(
__isl_keep isl_ast_build *build);
__isl_give isl_space *isl_ast_build_get_schedule_space(
__isl_keep isl_ast_build *build);
__isl_give isl_ast_build *isl_ast_build_restrict(
__isl_take isl_ast_build *build,
__isl_take isl_set *set);The isl_ast_build_get_schedule function returns a (partial) schedule for the domains elements for which part of the AST still needs to be generated in the current build. In particular, the domain elements are mapped to those iterations of the loops enclosing the current point of the AST generation inside which the domain elements are executed. No direct correspondence between the input schedule and this schedule should be assumed. The space obtained from isl_ast_build_get_schedule_space can be used to create a set for isl_ast_build_restrict to intersect with the current build. In particular, the set passed to isl_ast_build_restrict can have additional parameters. The ids of the set dimensions in the space returned by isl_ast_build_get_schedule_space correspond to the iterators of the already generated loops. The user should not rely on the ids of the output dimensions of the relations in the union relation returned by isl_ast_build_get_schedule having any particular value.
Although isl is mainly meant to be used as a library, it also contains some basic applications that use some of the functionality of isl. For applications that take one or more polytopes or polyhedra as input, this input may be specified in either the "isl format" or the "PolyLib format".
isl_polyhedron_sampleisl_polyhedron_sample takes a polyhedron as input and prints an integer element of the polyhedron, if there is any. The first column in the output is the denominator and is always equal to 1. If the polyhedron contains no integer points, then a vector of length zero is printed.
isl_pipisl_pip takes the same input as the example program from the piplib distribution, i.e., a set of constraints on the parameters, a line containing only -1 and finally a set of constraints on a parametric polyhedron. The coefficients of the parameters appear in the last columns (but before the final constant column). The output is the lexicographic minimum of the parametric polyhedron. As isl currently does not have its own output format, the output is just a dump of the internal state.
isl_polyhedron_minimizeisl_polyhedron_minimize computes the minimum of some linear or affine objective function over the integer points in a polyhedron. If an affine objective function is given, then the constant should appear in the last column.
isl_polytope_scanGiven a polytope, isl_polytope_scan prints all integer points in the polytope.
isl_flowGiven an isl_union_access_info object as input, isl_flow prints out the corresponding dependences, as computed by isl_union_access_info_compute_flow.
isl_codegenGiven either a schedule tree or a sequence consisting of a schedule map, a context set and an options relation, isl_codegen prints out an AST that scans the domain elements of the schedule in the order of their image(s) taking into account the constraints in the context set.
isl_scheduleGiven an isl_schedule_constraints object as input, isl_schedule prints out a schedule that satisfies the given constraints.