=back
+=head3 Changes since isl-0.06
+
+=over
+
+=item * The format of C<isl_printer_print_qpolynomial>'s
+C<ISL_FORMAT_ISL> output has changed.
+Use C<ISL_FORMAT_C> to obtain the old output.
+
+=back
+
=head1 Installation
The source of C<isl> can be obtained either as a tarball
__isl_give isl_dim *isl_union_map_get_dim(
__isl_keep isl_union_map *umap);
+ #include <isl/constraint.h>
+ __isl_give isl_dim *isl_constraint_get_dim(
+ __isl_keep isl_constraint *constraint);
+
#include <isl/polynomial.h>
__isl_give isl_dim *isl_qpolynomial_get_dim(
__isl_keep isl_qpolynomial *qp);
__isl_give isl_dim *isl_union_pw_qpolynomial_fold_get_dim(
__isl_keep isl_union_pw_qpolynomial_fold *upwf);
+ #include <isl/aff.h>
+ __isl_give isl_dim *isl_aff_get_dim(
+ __isl_keep isl_aff *aff);
+
The names of the individual dimensions may be set or read off
using the following functions.
Note that if dimensions are added or removed from a space, then
the name and the internal structure are lost.
+=head2 Local Spaces
+
+A local space is essentially a dimension specification with
+zero or more existentially quantified variables.
+The local space of a basic set or relation can be obtained
+using the following functions.
+
+ #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);
+
+A new local space can be created from a dimension specification using
+
+ #include <isl/local_space.h>
+ __isl_give isl_local_space *isl_local_space_from_dim(
+ __isl_take isl_dim *dim);
+
+They can be inspected, copied and freed using the following functions.
+
+ #include <isl/local_space.h>
+ isl_ctx *isl_local_space_get_ctx(
+ __isl_keep isl_local_space *ls);
+ int isl_local_space_dim(__isl_keep isl_local_space *ls,
+ enum isl_dim_type type);
+ const char *isl_local_space_get_dim_name(
+ __isl_keep isl_local_space *ls,
+ enum isl_dim_type type, unsigned pos);
+ __isl_give isl_dim *isl_local_space_get_dim(
+ __isl_keep isl_local_space *ls);
+ __isl_give isl_div *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);
+ void *isl_local_space_free(__isl_take isl_local_space *ls);
+
=head2 Input and Output
C<isl> supports its own input/output format, which is similar
__isl_take isl_dim *dim);
__isl_give isl_map *isl_map_universe(
__isl_take isl_dim *dim);
+ __isl_give isl_union_set *isl_union_set_universe(
+ __isl_take isl_union_set *uset);
+ __isl_give isl_union_map *isl_union_map_universe(
+ __isl_take isl_union_map *umap);
The sets and relations constructed by the functions above
contain all integer values, while those constructed by the
inequality constraints and then projecting out the
existentially quantified variables, if any.
Constraints can be constructed, manipulated and
-added to basic sets and relations using the following functions.
+added to (basic) sets and relations using the following functions.
#include <isl/constraint.h>
__isl_give isl_constraint *isl_equality_alloc(
__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 would use the following code.
void isl_constraint_get_coefficient(
__isl_keep isl_constraint *constraint,
enum isl_dim_type type, int pos, isl_int *v);
+ int isl_constraint_involves_dims(
+ __isl_keep isl_constraint *constraint,
+ enum isl_dim_type type, unsigned first, unsigned n);
The explicit representations of the existentially quantified
variables can be inspected using the following functions.
__isl_give isl_div *isl_constraint_div(
__isl_keep isl_constraint *constraint, int pos);
+ isl_ctx *isl_div_get_ctx(__isl_keep isl_div *div);
void isl_div_get_constant(__isl_keep isl_div *div,
isl_int *v);
void isl_div_get_denominator(__isl_keep isl_div *div,
=item * Emptiness
The following functions test whether the given set or relation
-contains any integer points. The ``fast'' variants do not perform
+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.
- int isl_basic_set_fast_is_empty(__isl_keep isl_basic_set *bset);
+ int isl_basic_set_plain_is_empty(__isl_keep isl_basic_set *bset);
int isl_basic_set_is_empty(__isl_keep isl_basic_set *bset);
+ int isl_set_plain_is_empty(__isl_keep isl_set *set);
int isl_set_is_empty(__isl_keep isl_set *set);
int isl_union_set_is_empty(__isl_keep isl_union_set *uset);
- int isl_basic_map_fast_is_empty(__isl_keep isl_basic_map *bmap);
+ int isl_basic_map_plain_is_empty(__isl_keep isl_basic_map *bmap);
int isl_basic_map_is_empty(__isl_keep isl_basic_map *bmap);
- int isl_map_fast_is_empty(__isl_keep isl_map *map);
+ int isl_map_plain_is_empty(__isl_keep isl_map *map);
int isl_map_is_empty(__isl_keep isl_map *map);
int isl_union_map_is_empty(__isl_keep isl_union_map *umap);
int isl_basic_set_is_universe(__isl_keep isl_basic_set *bset);
int isl_basic_map_is_universe(__isl_keep isl_basic_map *bmap);
- int isl_set_fast_is_universe(__isl_keep isl_set *set);
+ int isl_set_plain_is_universe(__isl_keep isl_set *set);
=item * Single-valuedness
=item * Injectivity
+ int isl_map_plain_is_injective(__isl_keep isl_map *map);
int isl_map_is_injective(__isl_keep isl_map *map);
- int isl_union_map_is_injective(__isl_keep isl_union_map *umap);
+ int isl_union_map_plain_is_injective(
+ __isl_keep isl_union_map *umap);
+ int isl_union_map_is_injective(
+ __isl_keep isl_union_map *umap);
=item * Bijectivity
=item * Equality
- int isl_set_fast_is_equal(__isl_keep isl_set *set1,
+ int isl_set_plain_is_equal(__isl_keep isl_set *set1,
__isl_keep isl_set *set2);
int isl_set_is_equal(__isl_keep isl_set *set1,
__isl_keep isl_set *set2);
__isl_keep isl_basic_map *bmap2);
int isl_map_is_equal(__isl_keep isl_map *map1,
__isl_keep isl_map *map2);
- int isl_map_fast_is_equal(__isl_keep isl_map *map1,
+ int isl_map_plain_is_equal(__isl_keep isl_map *map1,
__isl_keep isl_map *map2);
int isl_union_map_is_equal(
__isl_keep isl_union_map *umap1,
=item * Disjointness
- int isl_set_fast_is_disjoint(__isl_keep isl_set *set1,
+ int isl_set_plain_is_disjoint(__isl_keep isl_set *set1,
__isl_keep isl_set *set2);
=item * Subset
The functions above construct a (basic, regular or union) relation
that maps (a wrapped version of) the input relation to its domain or range.
+=item * Elimination
+
+ __isl_give isl_set *isl_set_eliminate(
+ __isl_take isl_set *set, enum isl_dim_type type,
+ unsigned first, unsigned n);
+
+Eliminate the coefficients for the given dimensions from the constraints,
+without removing the dimensions.
+
=item * Identity
__isl_give isl_map *isl_set_identity(
Simplify the representation of a set or relation by detecting implicit
equalities.
+=item * Removing redundant constraints
+
+ __isl_give isl_basic_set *isl_basic_set_remove_redundancies(
+ __isl_take isl_basic_set *bset);
+ __isl_give isl_basic_map *isl_basic_map_remove_redundancies(
+ __isl_take isl_basic_map *bmap);
+
=item * Convex hull
__isl_give isl_basic_set *isl_set_convex_hull(
In case of union sets and relations, the polyhedral hull is computed
per space.
+=item * Optimization
+
+ #include <isl/ilp.h>
+ enum isl_lp_result isl_basic_set_max(
+ __isl_keep isl_basic_set *bset,
+ __isl_keep isl_aff *obj, isl_int *opt)
+ enum isl_lp_result isl_set_max(__isl_keep isl_set *set,
+ __isl_keep isl_aff *obj, isl_int *opt);
+
+Compute the maximum of the integer affine expression C<obj>
+over the points in C<set>, returning the result in C<opt>.
+The return value may be one of C<isl_lp_error>,
+C<isl_lp_ok>, C<isl_lp_unbounded> or C<isl_lp_empty>.
+
=item * Dual
The following functions compute either the set of (rational) coefficient
Given a relation with nested relations for domain and range,
interchange the range of the domain with the domain of the range.
+=item * Aligning parameters
+
+ __isl_give isl_set *isl_set_align_params(
+ __isl_take isl_set *set,
+ __isl_take isl_dim *model);
+ __isl_give isl_map *isl_map_align_params(
+ __isl_take isl_map *map,
+ __isl_take isl_dim *model);
+
+Change the order of the parameters of the given set or relation
+such that the first parameters match those of C<model>.
+This may involve the introduction of extra parameters.
+All parameters need to be named.
+
=item * Dimension manipulation
__isl_give isl_set *isl_set_add_dims(
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 above functions can be useful
-to add new parameters.
+to add new parameters, assuming
+C<isl_set_align_params> and C<isl_map_align_params>
+are not sufficient.
=back
__isl_give isl_union_map *isl_union_map_lexmax(
__isl_take isl_union_map *umap);
+=head2 Lists
+
+Lists are defined over several element types, including
+C<isl_basic_set> and C<isl_set>.
+Here we take lists of C<isl_set>s as an example.
+Lists can be created, copied and freed using the following functions.
+
+ #include <isl/list.h>
+ __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_add(
+ __isl_take isl_set_list *list,
+ __isl_take isl_set *el);
+ void isl_set_list_free(__isl_take isl_set_list *list);
+
+C<isl_set_list_alloc> creates an empty list with a capacity for
+C<n> elements.
+
+Lists can be inspected using the following functions.
+
+ #include <isl/list.h>
+ isl_ctx *isl_set_list_get_ctx(__isl_keep isl_set_list *list);
+ int isl_set_list_n_set(__isl_keep isl_set_list *list);
+ int isl_set_list_foreach(__isl_keep isl_set_list *list,
+ int (*fn)(__isl_take struct isl_set *el, void *user),
+ void *user);
+
=head2 Matrices
Matrices can be created, copied and freed using the following functions.
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_ctx *isl_mat_get_ctx(__isl_keep isl_mat *mat);
int isl_mat_rows(__isl_keep isl_mat *mat);
int isl_mat_cols(__isl_keep isl_mat *mat);
int isl_mat_get_element(__isl_keep isl_mat *mat,
__isl_give isl_mat *isl_mat_right_kernel(__isl_take isl_mat *mat);
+=head2 Quasi Affine Expressions
+
+The zero quasi affine expression can be created using
+
+ __isl_give isl_aff *isl_aff_zero(
+ __isl_take isl_local_space *ls);
+
+Quasi affine expressions can be copied and free using
+
+ #include <isl/aff.h>
+ __isl_give isl_aff *isl_aff_copy(__isl_keep isl_aff *aff);
+ void *isl_aff_free(__isl_take isl_aff *aff);
+
+A (rational) bound on a dimension can be extracted from an C<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);
+
+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 expression can be inspected using
+
+ #include <isl/aff.h>
+ isl_ctx *isl_aff_get_ctx(__isl_keep isl_aff *aff);
+ int isl_aff_dim(__isl_keep isl_aff *aff,
+ enum isl_dim_type type);
+ __isl_give isl_local_space *isl_aff_get_local_space(
+ __isl_keep isl_aff *aff);
+ const char *isl_aff_get_dim_name(__isl_keep isl_aff *aff,
+ enum isl_dim_type type, unsigned pos);
+ int isl_aff_get_constant(__isl_keep isl_aff *aff,
+ isl_int *v);
+ int isl_aff_get_coefficient(__isl_keep isl_aff *aff,
+ enum isl_dim_type type, int pos, isl_int *v);
+ int isl_aff_get_denominator(__isl_keep isl_aff *aff,
+ isl_int *v);
+ __isl_give isl_div *isl_aff_get_div(
+ __isl_keep isl_aff *aff, int pos);
+
+It can be modified using
+
+ #include <isl/aff.h>
+ __isl_give isl_aff *isl_aff_set_constant(
+ __isl_take isl_aff *aff, isl_int v);
+ __isl_give isl_aff *isl_aff_set_constant_si(
+ __isl_take isl_aff *aff, int v);
+ __isl_give isl_aff *isl_aff_set_coefficient(
+ __isl_take isl_aff *aff,
+ enum isl_dim_type type, int pos, isl_int 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_denominator(
+ __isl_take isl_aff *aff, isl_int v);
+
+ __isl_give isl_aff *isl_aff_add_constant(
+ __isl_take isl_aff *aff, isl_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);
+
+Note that the C<set_constant> and C<set_coefficient> functions
+set the I<numerator> of the constant or coefficient, while
+C<add_constant> and C<add_coefficient> add an integer value to
+the possibly rational constant or coefficient.
+
+Operations include
+
+ #include <isl/aff.h>
+ __isl_give isl_aff *isl_aff_add(__isl_take isl_aff *aff1,
+ __isl_take isl_aff *aff2);
+ __isl_give isl_aff *isl_aff_sub(__isl_take isl_aff *aff1,
+ __isl_take isl_aff *aff2);
+ __isl_give isl_aff *isl_aff_neg(__isl_take isl_aff *aff);
+ __isl_give isl_aff *isl_aff_ceil(__isl_take isl_aff *aff);
+ __isl_give isl_aff *isl_aff_scale(__isl_take isl_aff *aff,
+ isl_int f);
+ __isl_give isl_aff *isl_aff_scale_down(__isl_take isl_aff *aff,
+ isl_int f);
+
+An expression can be printed using
+
+ #include <isl/aff.h>
+ __isl_give isl_printer *isl_printer_print_aff(
+ __isl_take isl_printer *p, __isl_keep isl_aff *aff);
+
=head2 Points
Points are elements of a set. They can be used to construct
__isl_give isl_qpolynomial *isl_qpolynomial_var(
__isl_take isl_dim *dim,
enum isl_dim_type type, unsigned pos);
+ __isl_give isl_qpolynomial *isl_qpolynomial_from_aff(
+ __isl_take isl_aff *aff);
The zero piecewise quasipolynomial or a piecewise quasipolynomial
with a single cell can be created using the following functions.
__isl_take isl_union_pw_qpolynomial *upwpq,
__isl_take isl_union_set *uset);
+ __isl_give isl_qpolynomial *isl_qpolynomial_align_params(
+ __isl_take isl_qpolynomial *qp,
+ __isl_take isl_dim *model);
+
__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_coalesce(
__isl_take isl_union_pw_qpolynomial *upwqp);
+ __isl_give isl_qpolynomial *isl_qpolynomial_gist(
+ __isl_take isl_qpolynomial *qp,
+ __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);
Given a polytope, C<isl_polytope_scan> prints
all integer points in the polytope.
-
-=head1 C<isl-polylib>
-
-The C<isl-polylib> library provides the following functions for converting
-between C<isl> objects and C<PolyLib> objects.
-The library is distributed separately for licensing reasons.
-
- #include <isl_set_polylib.h>
- __isl_give isl_basic_set *isl_basic_set_new_from_polylib(
- Polyhedron *P, __isl_take isl_dim *dim);
- Polyhedron *isl_basic_set_to_polylib(
- __isl_keep isl_basic_set *bset);
- __isl_give isl_set *isl_set_new_from_polylib(Polyhedron *D,
- __isl_take isl_dim *dim);
- Polyhedron *isl_set_to_polylib(__isl_keep isl_set *set);
-
- #include <isl_map_polylib.h>
- __isl_give isl_basic_map *isl_basic_map_new_from_polylib(
- Polyhedron *P, __isl_take isl_dim *dim);
- __isl_give isl_map *isl_map_new_from_polylib(Polyhedron *D,
- __isl_take isl_dim *dim);
- Polyhedron *isl_basic_map_to_polylib(
- __isl_keep isl_basic_map *bmap);
- Polyhedron *isl_map_to_polylib(__isl_keep isl_map *map);