projects / platform / upstream / isl.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
add isl_local_space_lifting
[platform/upstream/isl.git] / doc / user.pod
diff --git a/doc/user.pod b/doc/user.pod
index 45e6a98..59d086d 100644 (file)
--- a/doc/user.pod
+++ b/doc/user.pod
@@ -104,6 +104,51 @@ along with the associated functions.
 Some of the old names have been kept for backward compatibility,
 but they will be removed in the future.
 
 Some of the old names have been kept for backward compatibility,
 but they will be removed in the future.
 
+=item * 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 C<isl_space_params_alloc> or from other spaces using
+C<isl_space_params>.
+
+=item * The space in which C<isl_aff>, C<isl_pw_aff>, C<isl_qpolynomial>,
+C<isl_pw_qpolynomial>, C<isl_qpolynomial_fold> and C<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 C<isl_aff> are now considered to be of type
+C<isl_dim_in> instead of C<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.
+
+=item * The functions C<isl_equality_alloc> and C<isl_inequality_alloc>
+now take an C<isl_local_space> instead of an C<isl_space>.
+An C<isl_local_space> can be created from an C<isl_space>
+using C<isl_local_space_from_space>.
+
+=item * The C<isl_div> type has been removed.  Functions that used
+to return an C<isl_div> now return an C<isl_aff>.
+Note that the space of an C<isl_aff> is that of relation.
+When replacing a call to C<isl_div_get_coefficient> by a call to
+C<isl_aff_get_coefficient> any C<isl_dim_set> argument needs
+to be replaced by C<isl_dim_in>.
+A call to C<isl_aff_from_div> can be replaced by a call
+to C<isl_aff_floor>.
+A call to C<isl_qpolynomial_div(div)> call be replaced by
+the nested call
+
+       isl_qpolynomial_from_aff(isl_aff_floor(div))
+
+The function C<isl_constraint_div> has also been renamed
+to C<isl_constraint_get_div>.
+
+=item * The C<nparam> argument has been removed from
+C<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.
+
 =back
 
 =head1 Installation
 =back
 
 =head1 Installation
@@ -466,6 +511,8 @@ the space in which it lives needs to be specified using an C<isl_space>.
        #include <isl/space.h>
        __isl_give isl_space *isl_space_alloc(isl_ctx *ctx,
                unsigned nparam, unsigned n_in, unsigned n_out);
        #include <isl/space.h>
        __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_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);
@@ -473,9 +520,11 @@ the space in which it lives needs to be specified using an C<isl_space>.
        unsigned isl_space_dim(__isl_keep isl_space *space,
                enum isl_dim_type type);
 
        unsigned isl_space_dim(__isl_keep isl_space *space,
                enum isl_dim_type type);
 
-The space used for creating a set
+The space used for creating a parameter domain
+needs to be created using C<isl_space_params_alloc>.
+For other sets, the space
 needs to be created using C<isl_space_set_alloc>, while
 needs to be created using C<isl_space_set_alloc>, while
-that for creating a relation
+for a relation, the space
 needs to be created using C<isl_space_alloc>.
 C<isl_space_dim> can be used
 to find out the number of dimensions of each type in
 needs to be created using C<isl_space_alloc>.
 C<isl_space_dim> can be used
 to find out the number of dimensions of each type in
@@ -484,6 +533,13 @@ C<isl_dim_param>, C<isl_dim_in> (only for relations),
 C<isl_dim_out> (only for relations), C<isl_dim_set>
 (only for sets) or C<isl_dim_all>.
 
 C<isl_dim_out> (only for relations), C<isl_dim_set>
 (only for sets) or C<isl_dim_all>.
 
+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>
+       int isl_space_is_params(__isl_keep isl_space *space);
+       int isl_space_is_set(__isl_keep isl_space *space);
+
 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
 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
@@ -514,22 +570,40 @@ of the original object.
                __isl_keep isl_constraint *constraint);
 
        #include <isl/polynomial.h>
                __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_space(
                __isl_keep isl_qpolynomial_fold *fold);
        __isl_give isl_space *isl_qpolynomial_get_space(
                __isl_keep isl_qpolynomial *qp);
        __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_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/aff.h>
        __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/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_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_pw_aff_get_space(
                __isl_keep isl_pw_aff *pwaff);
+       __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);
 
        #include <isl/point.h>
        __isl_give isl_space *isl_point_get_space(
 
        #include <isl/point.h>
        __isl_give isl_space *isl_point_get_space(
@@ -566,12 +640,14 @@ 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.
 
 in which case the result will have as parameters the union of the parameters of
 the arguments.
 
-Given the identifier of a dimension (typically a parameter),
+Given the identifier or name of a dimension (typically a parameter),
 its position can be obtained from the following function.
 
        #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);
 its position can be obtained from the following function.
 
        #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);
 
 The identifiers or names of entire spaces may be set or read off
 using the following functions.
 
 The identifiers or names of entire spaces may be set or read off
 using the following functions.
@@ -592,7 +668,7 @@ using the following functions.
        const char *isl_space_get_tuple_name(__isl_keep isl_space *space,
                enum isl_dim_type type);
 
        const char *isl_space_get_tuple_name(__isl_keep isl_space *space,
                enum isl_dim_type type);
 
-The C<dim> argument needs to be one of C<isl_dim_in>, C<isl_dim_out>
+The C<type> argument needs to be one of C<isl_dim_in>, C<isl_dim_out>
 or C<isl_dim_set>.  As with C<isl_space_get_name>,
 the C<isl_space_get_tuple_name> function returns a pointer to some internal
 data structure.
 or C<isl_dim_set>.  As with C<isl_space_get_name>,
 the C<isl_space_get_tuple_name> function returns a pointer to some internal
 data structure.
@@ -624,6 +700,8 @@ using the following functions.
        __isl_give isl_space *isl_space_from_range(__isl_take isl_space *space);
        __isl_give isl_space *isl_space_params(
                __isl_take isl_space *space);
        __isl_give isl_space *isl_space_from_range(__isl_take isl_space *space);
        __isl_give isl_space *isl_space_params(
                __isl_take isl_space *space);
+       __isl_give isl_space *isl_space_set_from_params(
+               __isl_take isl_space *space);
        __isl_give isl_space *isl_space_reverse(__isl_take isl_space *space);
        __isl_give isl_space *isl_space_join(__isl_take isl_space *left,
                __isl_take isl_space *right);
        __isl_give isl_space *isl_space_reverse(__isl_take isl_space *space);
        __isl_give isl_space *isl_space_join(__isl_take isl_space *left,
                __isl_take isl_space *right);
@@ -667,11 +745,12 @@ A new local space can be created from a space using
        __isl_give isl_local_space *isl_local_space_from_space(
                __isl_take isl_space *space);
 
        __isl_give isl_local_space *isl_local_space_from_space(
                __isl_take isl_space *space);
 
-They can be inspected, copied and freed using the following functions.
+They can be inspected, modified, 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);
 
        #include <isl/local_space.h>
        isl_ctx *isl_local_space_get_ctx(
                __isl_keep isl_local_space *ls);
+       int isl_local_space_is_set(__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(
        int isl_local_space_dim(__isl_keep isl_local_space *ls,
                enum isl_dim_type type);
        const char *isl_local_space_get_dim_name(
@@ -680,9 +759,13 @@ They can be inspected, copied and freed using the following functions.
        __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_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_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_give isl_space *isl_local_space_get_space(
                __isl_keep isl_local_space *ls);
        __isl_give isl_space *isl_local_space_get_space(
                __isl_keep isl_local_space *ls);
-       __isl_give isl_div *isl_local_space_get_div(
+       __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_keep isl_local_space *ls, int pos);
        __isl_give isl_local_space *isl_local_space_copy(
                __isl_keep isl_local_space *ls);
@@ -696,8 +779,13 @@ Two local spaces can be compared using
 Local spaces can be created from other local spaces
 using the following functions.
 
 Local spaces can be created from other local spaces
 using the following functions.
 
+       __isl_give isl_local_space *isl_local_space_domain(
+               __isl_take isl_local_space *ls);
        __isl_give isl_local_space *isl_local_space_from_domain(
                __isl_take isl_local_space *ls);
        __isl_give isl_local_space *isl_local_space_from_domain(
                __isl_take isl_local_space *ls);
+       __isl_give isl_local_space *isl_local_space_intersect(
+               __isl_take isl_local_space *ls1,
+               __isl_take isl_local_space *ls2);
        __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_add_dims(
                __isl_take isl_local_space *ls,
                enum isl_dim_type type, unsigned n);
@@ -770,23 +858,23 @@ dimensions is zero.
 
        #include <isl/set.h>
        __isl_give isl_basic_set *isl_basic_set_read_from_file(
 
        #include <isl/set.h>
        __isl_give isl_basic_set *isl_basic_set_read_from_file(
-               isl_ctx *ctx, FILE *input, int nparam);
+               isl_ctx *ctx, FILE *input);
        __isl_give isl_basic_set *isl_basic_set_read_from_str(
        __isl_give isl_basic_set *isl_basic_set_read_from_str(
-               isl_ctx *ctx, const char *str, int nparam);
+               isl_ctx *ctx, const char *str);
        __isl_give isl_set *isl_set_read_from_file(isl_ctx *ctx,
        __isl_give isl_set *isl_set_read_from_file(isl_ctx *ctx,
-               FILE *input, int nparam);
+               FILE *input);
        __isl_give isl_set *isl_set_read_from_str(isl_ctx *ctx,
        __isl_give isl_set *isl_set_read_from_str(isl_ctx *ctx,
-               const char *str, int nparam);
+               const char *str);
 
        #include <isl/map.h>
        __isl_give isl_basic_map *isl_basic_map_read_from_file(
 
        #include <isl/map.h>
        __isl_give isl_basic_map *isl_basic_map_read_from_file(
-               isl_ctx *ctx, FILE *input, int nparam);
+               isl_ctx *ctx, FILE *input);
        __isl_give isl_basic_map *isl_basic_map_read_from_str(
        __isl_give isl_basic_map *isl_basic_map_read_from_str(
-               isl_ctx *ctx, const char *str, int nparam);
+               isl_ctx *ctx, const char *str);
        __isl_give isl_map *isl_map_read_from_file(
        __isl_give isl_map *isl_map_read_from_file(
-               isl_ctx *ctx, FILE *input, int nparam);
+               isl_ctx *ctx, FILE *input);
        __isl_give isl_map *isl_map_read_from_str(isl_ctx *ctx,
        __isl_give isl_map *isl_map_read_from_str(isl_ctx *ctx,
-               const char *str, int nparam);
+               const char *str);
 
        #include <isl/union_set.h>
        __isl_give isl_union_set *isl_union_set_read_from_file(
 
        #include <isl/union_set.h>
        __isl_give isl_union_set *isl_union_set_read_from_file(
@@ -802,13 +890,6 @@ dimensions is zero.
 
 The input format is autodetected and may be either the C<PolyLib> format
 or the C<isl> format.
 
 The input format is autodetected and may be either the C<PolyLib> format
 or the C<isl> format.
-C<nparam> specifies how many of the final columns in
-the C<PolyLib> format correspond to parameters.
-If input is given in the C<isl> format, then the number
-of parameters needs to be equal to C<nparam>.
-If C<nparam> is negative, then any number of parameters
-is accepted in the C<isl> format and zero parameters
-are assumed in the C<PolyLib> format.
 
 =head3 Output
 
 
 =head3 Output
 
@@ -1003,6 +1084,12 @@ space.
        __isl_give isl_map *isl_map_from_union_map(
                __isl_take isl_union_map *umap);
 
        __isl_give isl_map *isl_map_from_union_map(
                __isl_take isl_union_map *umap);
 
+A zero-dimensional set can be constructed on a given parameter domain
+using the following function.
+
+       __isl_give isl_set *isl_set_from_params(
+               __isl_take isl_set *set);
+
 Sets and relations can be copied and freed again using the following
 functions.
 
 Sets and relations can be copied and freed again using the following
 functions.
 
@@ -1033,9 +1120,9 @@ using the following functions.
 
        #include <isl/constraint.h>
        __isl_give isl_constraint *isl_equality_alloc(
 
        #include <isl/constraint.h>
        __isl_give isl_constraint *isl_equality_alloc(
-               __isl_take isl_space *space);
+               __isl_take isl_local_space *ls);
        __isl_give isl_constraint *isl_inequality_alloc(
        __isl_give isl_constraint *isl_inequality_alloc(
-               __isl_take isl_space *space);
+               __isl_take isl_local_space *ls);
        __isl_give isl_constraint *isl_constraint_set_constant(
                __isl_take isl_constraint *constraint, isl_int v);
        __isl_give isl_constraint *isl_constraint_set_constant_si(
        __isl_give isl_constraint *isl_constraint_set_constant(
                __isl_take isl_constraint *constraint, isl_int v);
        __isl_give isl_constraint *isl_constraint_set_constant_si(
@@ -1065,45 +1152,37 @@ using the following functions.
 For example, to create a set containing the even integers
 between 10 and 42, you would use the following code.
 
 For example, to create a set containing the even integers
 between 10 and 42, you would use the following code.
 
-       isl_int v;
        isl_space *space;
        isl_space *space;
+       isl_local_space *ls;
        isl_constraint *c;
        isl_basic_set *bset;
 
        isl_constraint *c;
        isl_basic_set *bset;
 
-       isl_int_init(v);
        space = isl_space_set_alloc(ctx, 0, 2);
        bset = isl_basic_set_universe(isl_space_copy(space));
        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_equality_alloc(isl_space_copy(space));
-       isl_int_set_si(v, -1);
-       isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-       isl_int_set_si(v, 2);
-       isl_constraint_set_coefficient(c, isl_dim_set, 1, v);
+       c = isl_equality_alloc(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);
 
        bset = isl_basic_set_add_constraint(bset, c);
 
-       c = isl_inequality_alloc(isl_space_copy(space));
-       isl_int_set_si(v, -10);
-       isl_constraint_set_constant(c, v);
-       isl_int_set_si(v, 1);
-       isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
+       c = isl_inequality_alloc(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);
 
        bset = isl_basic_set_add_constraint(bset, c);
 
-       c = isl_inequality_alloc(space);
-       isl_int_set_si(v, 42);
-       isl_constraint_set_constant(c, v);
-       isl_int_set_si(v, -1);
-       isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
+       c = isl_inequality_alloc(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);
 
        bset = isl_basic_set_add_constraint(bset, c);
 
        bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 1);
 
-       isl_int_clear(v);
-
 Or, alternatively,
 
        isl_basic_set *bset;
        bset = isl_basic_set_read_from_str(ctx,
 Or, alternatively,
 
        isl_basic_set *bset;
        bset = isl_basic_set_read_from_str(ctx,
-               "{[i] : exists (a : i = 2a and i >= 10 and i <= 42)}", -1);
+               "{[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.
 
 A basic set or relation can also be constructed from two matrices
 describing the equalities and the inequalities.
@@ -1128,16 +1207,27 @@ C<isl_dim_set> and C<isl_dim_div> for sets and
 of C<isl_dim_cst>, C<isl_dim_param>,
 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div> for relations.
 
 of C<isl_dim_cst>, C<isl_dim_param>,
 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div> for relations.
 
-A (basic) relation can also be constructed from a (piecewise) affine expression
-or a list of affine expressions (See L<"Piecewise Quasi Affine Expressions">).
+A (basic) set or relation can also be constructed from a (piecewise)
+(multiple) affine expression
+or a list of affine expressions
+(See L<"Piecewise Quasi Affine Expressions"> and
+L<"Piecewise Multiple Quasi Affine Expressions">).
 
        __isl_give isl_basic_map *isl_basic_map_from_aff(
                __isl_take isl_aff *aff);
 
        __isl_give isl_basic_map *isl_basic_map_from_aff(
                __isl_take isl_aff *aff);
+       __isl_give isl_set *isl_set_from_pw_aff(
+               __isl_take isl_pw_aff *pwaff);
        __isl_give isl_map *isl_map_from_pw_aff(
                __isl_take isl_pw_aff *pwaff);
        __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_map *isl_map_from_pw_aff(
                __isl_take isl_pw_aff *pwaff);
        __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_set *isl_set_from_pw_multi_aff(
+               __isl_take isl_pw_multi_aff *pma);
+       __isl_give isl_map *isl_map_from_pw_multi_aff(
+               __isl_take isl_pw_multi_aff *pma);
 
 The C<domain_dim> argument describes the domain of the resulting
 basic relation.  It is required because the C<list> may consist
 
 The C<domain_dim> argument describes the domain of the resulting
 basic relation.  It is required because the C<list> may consist
@@ -1274,20 +1364,17 @@ the following functions.
                enum isl_dim_type type, unsigned first, unsigned n);
 
 The explicit representations of the existentially quantified
                enum isl_dim_type type, unsigned first, unsigned n);
 
 The explicit representations of the existentially quantified
-variables can be inspected using the following functions.
-Note that the user is only allowed to use these functions
+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 C<isl_set_compute_divs> or C<isl_map_compute_divs>.
 if the inspected set or map is the result of a call
 to C<isl_set_compute_divs> or C<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
+L<"Piecewise Quasi Affine Expressions">.
 
 
-       __isl_give isl_div *isl_constraint_div(
+       __isl_give isl_aff *isl_constraint_get_div(
                __isl_keep isl_constraint *constraint, int pos);
                __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,
-               isl_int *v);
-       void isl_div_get_coefficient(__isl_keep isl_div *div,
-               enum isl_dim_type type, int pos, isl_int *v);
 
 To obtain the constraints of a basic set or map in matrix
 form, use the following functions.
 
 To obtain the constraints of a basic set or map in matrix
 form, use the following functions.
@@ -1397,6 +1484,9 @@ read off using the following functions.
        __isl_give isl_id *isl_set_get_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);
+       int isl_basic_map_has_dim_id(
+               __isl_keep isl_basic_map *bmap,
+               enum isl_dim_type type, unsigned pos);
        __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_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);
@@ -1410,6 +1500,8 @@ read off using the following functions.
                enum isl_dim_type type, __isl_keep isl_id *id);
        int isl_map_find_dim_by_id(__isl_keep isl_map *map,
                enum isl_dim_type type, __isl_keep isl_id *id);
                enum isl_dim_type type, __isl_keep isl_id *id);
        int isl_map_find_dim_by_id(__isl_keep isl_map *map,
                enum isl_dim_type type, __isl_keep isl_id *id);
+       int isl_map_find_dim_by_name(__isl_keep isl_map *map,
+               enum isl_dim_type type, const char *name);
 
        const char *isl_constraint_get_dim_name(
                __isl_keep isl_constraint *constraint,
 
        const char *isl_constraint_get_dim_name(
                __isl_keep isl_constraint *constraint,
@@ -1487,6 +1579,9 @@ is already known to be empty.
                __isl_keep isl_basic_map *bmap,
                enum isl_dim_type type, unsigned pos,
                isl_int *val);
                __isl_keep isl_basic_map *bmap,
                enum isl_dim_type type, unsigned pos,
                isl_int *val);
+       int isl_set_plain_is_fixed(__isl_keep isl_set *set,
+               enum isl_dim_type type, unsigned pos,
+               isl_int *val);
        int isl_map_plain_is_fixed(__isl_keep isl_map *map,
                enum isl_dim_type type, unsigned pos,
                isl_int *val);
        int isl_map_plain_is_fixed(__isl_keep isl_map *map,
                enum isl_dim_type type, unsigned pos,
                isl_int *val);
@@ -1494,6 +1589,12 @@ is already known to be empty.
 Check if the relation obviously lies on a hyperplane where the given dimension
 has a fixed value and if so, return that value in C<*val>.
 
 Check if the relation obviously lies on a hyperplane where the given dimension
 has a fixed value and if so, return that value in C<*val>.
 
+=item * Space
+
+To check whether a set is a parameter domain, use this function:
+
+       int isl_set_is_params(__isl_keep isl_set *set);
+
 =item * Wrapping
 
 The following functions check whether the domain of the given
 =item * Wrapping
 
 The following functions check whether the domain of the given
@@ -1608,10 +1709,14 @@ i.e., whether both domain and range are nested relations.
                enum isl_dim_type type, unsigned first, unsigned n);
        __isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
                enum isl_dim_type type, unsigned first, unsigned n);
                enum isl_dim_type type, unsigned first, unsigned n);
        __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_basic_set *isl_basic_set_params(
+               __isl_take isl_basic_set *bset);
        __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_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_set_params(__isl_take isl_set *set);
+       __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_give isl_set *isl_map_domain(
                __isl_take isl_map *bmap);
        __isl_give isl_set *isl_map_range(
@@ -1640,6 +1745,10 @@ that maps (a wrapped version of) the input relation to its domain or range.
        __isl_give isl_set *isl_set_eliminate(
                __isl_take isl_set *set, 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);
 
 Eliminate the coefficients for the given dimensions from the constraints,
 without removing the dimensions.
 
 Eliminate the coefficients for the given dimensions from the constraints,
 without removing the dimensions.
@@ -1843,9 +1952,12 @@ C<isl_lp_ok>, C<isl_lp_unbounded> or C<isl_lp_empty>.
                __isl_take isl_set *set, int pos);
        __isl_give isl_pw_aff *isl_set_dim_max(
                __isl_take isl_set *set, int pos);
                __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_max(
+               __isl_take isl_map *map, int pos);
 
 
-Compute the minimum or maximum of the given set dimension as a function of the
-parameters, but independently of the other set dimensions.
+Compute the minimum or maximum of the given set or output dimension
+as a function of the parameters (and input dimensions), but independently
+of the other set or output dimensions.
 For lexicographic optimization, see L<"Lexicographic Optimization">.
 
 =item * Dual
 For lexicographic optimization, see L<"Lexicographic Optimization">.
 
 =item * Dual
@@ -1976,6 +2088,15 @@ existentially quantified variables.
        __isl_give isl_union_set *isl_union_set_lift(
                __isl_take isl_union_set *uset);
 
        __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 C<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);
+
 =item * Internal Product
 
        __isl_give isl_basic_map *isl_basic_map_zip(
 =item * Internal Product
 
        __isl_give isl_basic_map *isl_basic_map_zip(
@@ -2016,6 +2137,26 @@ All parameters need to be named.
        __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_map *isl_map_insert_dims(
                __isl_take isl_map *map,
                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_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_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);
+       __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);
 
 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
 
 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
@@ -2215,6 +2356,9 @@ instead.
                __isl_take isl_basic_set *context);
        __isl_give isl_set *isl_set_gist(__isl_take isl_set *set,
                __isl_take isl_set *context);
                __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);
        __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(
                __isl_take isl_union_set *uset,
                __isl_take isl_union_set *context);
@@ -2223,6 +2367,9 @@ instead.
                __isl_take isl_basic_map *context);
        __isl_give isl_map *isl_map_gist(__isl_take isl_map *map,
                __isl_take isl_map *context);
                __isl_take isl_basic_map *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_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(
                __isl_take isl_union_map *umap,
                __isl_take isl_union_map *context);
@@ -2330,6 +2477,36 @@ In case of union relations, the optimum is computed per space.
        __isl_give isl_union_map *isl_union_map_lexmax(
                __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
+(See L<"Piecewise Multiple Quasi Affine Expressions">),
+but are otherwise equivalent to the corresponding functions
+returning a basic set or relation.
+
+       __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_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_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);
+
 =head2 Lists
 
 Lists are defined over several element types, including
 =head2 Lists
 
 Lists are defined over several element types, including
@@ -2415,15 +2592,13 @@ the original and the kernel (in that order) is the zero matrix.
 
 =head2 Piecewise Quasi Affine Expressions
 
 
 =head2 Piecewise Quasi Affine Expressions
 
-The zero quasi affine expression can be created using
+The zero quasi affine expression on a given domain can be created using
 
 
-       __isl_give isl_aff *isl_aff_zero(
+       __isl_give isl_aff *isl_aff_zero_on_domain(
                __isl_take isl_local_space *ls);
 
                __isl_take isl_local_space *ls);
 
-A quasi affine expression can also be initialized from an C<isl_div>:
-
-       #include <isl/div.h>
-       __isl_give isl_aff *isl_aff_from_div(__isl_take isl_div *div);
+Note that the space in which the resulting object lives is a map space
+with the given space as domain and a one-dimensional range.
 
 An empty piecewise quasi affine expression (one with no cells)
 or a piecewise quasi affine expression with a single cell can
 
 An empty piecewise quasi affine expression (one with no cells)
 or a piecewise quasi affine expression with a single cell can
@@ -2478,17 +2653,25 @@ The expression can be inspected using
        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_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_domain_local_space(
+               __isl_keep isl_aff *aff);
        __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);
        __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);
+       const char *isl_pw_aff_get_dim_name(
+               __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);
        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);
        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_give isl_aff *isl_aff_get_div(
                __isl_keep isl_aff *aff, int pos);
 
        int isl_pw_aff_foreach_piece(__isl_keep isl_pw_aff *pwaff,
                __isl_keep isl_aff *aff, int pos);
 
        int isl_pw_aff_foreach_piece(__isl_keep isl_pw_aff *pwaff,
@@ -2514,10 +2697,17 @@ It can be modified using
        #include <isl/aff.h>
        __isl_give isl_pw_aff *isl_pw_aff_set_tuple_id(
                __isl_take isl_pw_aff *pwaff,
        #include <isl/aff.h>
        __isl_give isl_pw_aff *isl_pw_aff_set_tuple_id(
                __isl_take isl_pw_aff *pwaff,
-               __isl_take isl_id *id);
+               enum isl_dim_type type, __isl_take isl_id *id);
        __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_aff *isl_aff_set_dim_name(
                __isl_take isl_aff *aff, enum isl_dim_type type,
                unsigned pos, const char *s);
+       __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_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_aff *isl_aff_set_constant(
                __isl_take isl_aff *aff, isl_int v);
        __isl_give isl_aff *isl_aff_set_constant_si(
        __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(
@@ -2573,6 +2763,9 @@ or obviously equal to some other affine expression, use
        int isl_aff_plain_is_zero(__isl_keep isl_aff *aff);
        int isl_aff_plain_is_equal(__isl_keep isl_aff *aff1,
                __isl_keep isl_aff *aff2);
        int isl_aff_plain_is_zero(__isl_keep isl_aff *aff);
        int isl_aff_plain_is_equal(__isl_keep isl_aff *aff1,
                __isl_keep isl_aff *aff2);
+       int isl_pw_aff_plain_is_equal(
+               __isl_keep isl_pw_aff *pwaff1,
+               __isl_keep isl_pw_aff *pwaff2);
 
 Operations include
 
 
 Operations include
 
@@ -2637,6 +2830,9 @@ Operations include
 
        __isl_give isl_set *isl_pw_aff_domain(
                __isl_take isl_pw_aff *pwaff);
 
        __isl_give isl_set *isl_pw_aff_domain(
                __isl_take isl_pw_aff *pwaff);
+       __isl_give isl_pw_aff *isl_pw_aff_intersect_domain(
+               __isl_take isl_pw_aff *pa,
+               __isl_take isl_set *set);
 
        __isl_give isl_aff *isl_aff_mul(__isl_take isl_aff *aff1,
                __isl_take isl_aff *aff2);
 
        __isl_give isl_aff *isl_aff_mul(__isl_take isl_aff *aff1,
                __isl_take isl_aff *aff2);
@@ -2737,6 +2933,14 @@ the maximum of those of C<pwaff1> and C<pwaff2>.  If only one of
 C<pwaff1> or C<pwaff2> is defined on a given cell, then the
 associated expression is the defined one.
 
 C<pwaff1> or C<pwaff2> is defined on a given cell, then the
 associated expression is the defined one.
 
+An expression can be read from input using
+
+       #include <isl/aff.h>
+       __isl_give isl_aff *isl_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);
+
 An expression can be printed using
 
        #include <isl/aff.h>
 An expression can be printed using
 
        #include <isl/aff.h>
@@ -2747,6 +2951,146 @@ An expression can be printed using
                __isl_take isl_printer *p,
                __isl_keep isl_pw_aff *pwaff);
 
                __isl_take isl_printer *p,
                __isl_keep isl_pw_aff *pwaff);
 
+=head2 Piecewise Multiple Quasi Affine Expressions
+
+An C<isl_multi_aff> object represents a sequence of
+zero or more affine expressions, all defined on the same domain space.
+
+An C<isl_multi_aff> can be constructed from a C<isl_aff_list> using the
+following function.
+
+       #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);
+
+An empty piecewise multiple quasi affine expression (one with no cells) or
+a piecewise multiple quasi affine expression with a single cell can
+be created using the following functions.
+
+       #include <isl/aff.h>
+       __isl_give isl_pw_multi_aff *isl_pw_multi_aff_empty(
+               __isl_take isl_space *space);
+       __isl_give isl_pw_multi_aff *isl_pw_multi_aff_alloc(
+               __isl_take isl_set *set,
+               __isl_take isl_multi_aff *maff);
+
+A piecewise multiple quasi affine expression can also be initialized
+from an C<isl_set> or C<isl_map>, provided the C<isl_set> is a singleton
+and the C<isl_map> is single-valued.
+
+       __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_set(
+               __isl_take isl_set *set);
+       __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_map(
+               __isl_take isl_map *map);
+
+Multiple quasi affine expressions can be copied and freed using
+
+       #include <isl/aff.h>
+       __isl_give isl_multi_aff *isl_multi_aff_copy(
+               __isl_keep isl_multi_aff *maff);
+       void *isl_multi_aff_free(__isl_take isl_multi_aff *maff);
+
+       __isl_give isl_pw_multi_aff *isl_pw_multi_aff_copy(
+               __isl_keep isl_pw_multi_aff *pma);
+       void *isl_pw_multi_aff_free(
+               __isl_take isl_pw_multi_aff *pma);
+
+The expression can be inspected using
+
+       #include <isl/aff.h>
+       isl_ctx *isl_multi_aff_get_ctx(
+               __isl_keep isl_multi_aff *maff);
+       isl_ctx *isl_pw_multi_aff_get_ctx(
+               __isl_keep isl_pw_multi_aff *pma);
+       unsigned isl_multi_aff_dim(__isl_keep isl_multi_aff *maff,
+               enum isl_dim_type type);
+       unsigned isl_pw_multi_aff_dim(
+               __isl_keep isl_pw_multi_aff *pma,
+               enum isl_dim_type type);
+       __isl_give isl_aff *isl_multi_aff_get_aff(
+               __isl_keep isl_multi_aff *multi, int pos);
+       const char *isl_pw_multi_aff_get_dim_name(
+               __isl_keep isl_pw_multi_aff *pma,
+               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);
+       const char *isl_multi_aff_get_tuple_name(
+               __isl_keep isl_multi_aff *multi,
+               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);
+       int 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_tuple_id(
+               __isl_keep isl_pw_multi_aff *pma,
+               enum isl_dim_type type);
+
+       int isl_pw_multi_aff_foreach_piece(
+               __isl_keep isl_pw_multi_aff *pma,
+               int (*fn)(__isl_take isl_set *set,
+                           __isl_take isl_multi_aff *maff,
+                           void *user), void *user);
+
+It can be modified using
+
+       #include <isl/aff.h>
+       __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_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);
+
+To check whether two multiple affine expressions are
+obviously equal to each other, use
+
+       int isl_multi_aff_plain_is_equal(__isl_keep isl_multi_aff *maff1,
+               __isl_keep isl_multi_aff *maff2);
+       int isl_pw_multi_aff_plain_is_equal(
+               __isl_keep isl_pw_multi_aff *pma1,
+               __isl_keep isl_pw_multi_aff *pma2);
+
+Operations include
+
+       #include <isl/aff.h>
+       __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_multi_aff *isl_pw_multi_aff_add(
+               __isl_take isl_pw_multi_aff *pma1,
+               __isl_take isl_pw_multi_aff *pma2);
+       __isl_give isl_multi_aff *isl_multi_aff_scale(
+               __isl_take isl_multi_aff *maff,
+               isl_int f);
+       __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_multi_aff *isl_multi_aff_gist(
+               __isl_take isl_multi_aff *maff,
+               __isl_take isl_set *context);
+
+An expression can be read from input using
+
+       #include <isl/aff.h>
+       __isl_give isl_multi_aff *isl_multi_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);
+
+An expression can be printed using
+
+       #include <isl/aff.h>
+       __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_multi_aff(
+               __isl_take isl_printer *p,
+               __isl_keep isl_pw_multi_aff *pma);
+
 =head2 Points
 
 Points are elements of a set.  They can be used to construct
 =head2 Points
 
 Points are elements of a set.  They can be used to construct
@@ -2898,27 +3242,29 @@ More complicated quasipolynomials can be created by applying
 operations such as addition and multiplication
 on the resulting quasipolynomials
 
 operations such as addition and multiplication
 on the resulting quasipolynomials
 
-       __isl_give isl_qpolynomial *isl_qpolynomial_zero(
-               __isl_take isl_space *dim);
-       __isl_give isl_qpolynomial *isl_qpolynomial_one(
-               __isl_take isl_space *dim);
-       __isl_give isl_qpolynomial *isl_qpolynomial_infty(
-               __isl_take isl_space *dim);
-       __isl_give isl_qpolynomial *isl_qpolynomial_neginfty(
-               __isl_take isl_space *dim);
-       __isl_give isl_qpolynomial *isl_qpolynomial_nan(
-               __isl_take isl_space *dim);
-       __isl_give isl_qpolynomial *isl_qpolynomial_rat_cst(
-               __isl_take isl_space *dim,
+       __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_rat_cst_on_domain(
+               __isl_take isl_space *domain,
                const isl_int n, const isl_int d);
                const isl_int n, const isl_int d);
-       __isl_give isl_qpolynomial *isl_qpolynomial_div(
-               __isl_take isl_div *div);
-       __isl_give isl_qpolynomial *isl_qpolynomial_var(
-               __isl_take isl_space *dim,
+       __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);
 
                enum isl_dim_type type, unsigned pos);
        __isl_give isl_qpolynomial *isl_qpolynomial_from_aff(
                __isl_take isl_aff *aff);
 
+Note that the space in which a quasipolynomial lives is a map space
+with a one-dimensional range.  The C<domain> argument in some of
+the functions above corresponds to the domain of this map space.
+
 The zero piecewise quasipolynomial or a piecewise quasipolynomial
 with a single cell can be created using the following functions.
 Multiple of these single cell piecewise quasipolynomials can
 The zero piecewise quasipolynomial or a piecewise quasipolynomial
 with a single cell can be created using the following functions.
 Multiple of these single cell piecewise quasipolynomials can
@@ -3022,7 +3368,7 @@ these functions
                isl_int *d);
        int isl_term_get_exp(__isl_keep isl_term *term,
                enum isl_dim_type type, unsigned pos);
                isl_int *d);
        int isl_term_get_exp(__isl_keep isl_term *term,
                enum isl_dim_type type, unsigned pos);
-       __isl_give isl_div *isl_term_get_div(
+       __isl_give isl_aff *isl_term_get_div(
                __isl_keep isl_term *term, unsigned pos);
        void isl_term_free(__isl_take isl_term *term);
 
                __isl_keep isl_term *term, unsigned pos);
        void isl_term_free(__isl_take isl_term *term);
 
@@ -3045,6 +3391,13 @@ If C<qp> is a constant and if C<n> and C<d> are not C<NULL>
 then the numerator and denominator of the constant
 are returned in C<*n> and C<*d>, respectively.
 
 then the numerator and denominator of the constant
 are returned in C<*n> and C<*d>, respectively.
 
+To check whether two union piecewise quasipolynomials are
+obviously equal, use
+
+       int isl_union_pw_qpolynomial_plain_is_equal(
+               __isl_keep isl_union_pw_qpolynomial *upwqp1,
+               __isl_keep isl_union_pw_qpolynomial *upwqp2);
+
 =head3 Operations on (Piecewise) Quasipolynomials
 
        __isl_give isl_qpolynomial *isl_qpolynomial_scale(
 =head3 Operations on (Piecewise) Quasipolynomials
 
        __isl_give isl_qpolynomial *isl_qpolynomial_scale(
@@ -3114,6 +3467,11 @@ are returned in C<*n> and C<*d>, respectively.
                __isl_take isl_qpolynomial *qp,
                __isl_take isl_space *model);
 
                __isl_take isl_qpolynomial *qp,
                __isl_take isl_space *model);
 
+       __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_union_pw_qpolynomial *isl_union_pw_qpolynomial_coalesce(
                __isl_take isl_union_pw_qpolynomial *upwqp);
 
        __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_coalesce(
                __isl_take isl_union_pw_qpolynomial *upwqp);
 
@@ -3250,6 +3608,15 @@ To iterate over all quasipolynomials in a reduction, use
                int (*fn)(__isl_take isl_qpolynomial *qp,
                          void *user), void *user);
 
                int (*fn)(__isl_take isl_qpolynomial *qp,
                          void *user), void *user);
 
+=head3 Properties of Piecewise Quasipolynomial Reductions
+
+To check whether two union piecewise quasipolynomial reductions are
+obviously equal, use
+
+       int isl_union_pw_qpolynomial_fold_plain_is_equal(
+               __isl_keep isl_union_pw_qpolynomial_fold *upwf1,
+               __isl_keep isl_union_pw_qpolynomial_fold *upwf2);
+
 =head3 Operations on Piecewise Quasipolynomial Reductions
 
        __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_scale(
 =head3 Operations on Piecewise Quasipolynomial Reductions
 
        __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_scale(
@@ -3281,6 +3648,9 @@ To iterate over all quasipolynomials in a reduction, use
                __isl_take isl_union_pw_qpolynomial_fold *upwf,
                __isl_take isl_union_set *uset);
 
                __isl_take isl_union_pw_qpolynomial_fold *upwf,
                __isl_take isl_union_set *uset);
 
+       __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_project_domain_on_params(
+               __isl_take isl_pw_qpolynomial_fold *pwf);
+
        __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_coalesce(
                __isl_take isl_pw_qpolynomial_fold *pwf);
 
        __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_coalesce(
                __isl_take isl_pw_qpolynomial_fold *pwf);
 
Domain: System / Uncategorized;