add isl_map_flat_domain_product
[platform/upstream/isl.git] / doc / user.pod
index a7e34cb..45e6a98 100644 (file)
@@ -68,10 +68,9 @@ the accesses for which no source could be found instead of
 the iterations where those accesses occur.
 
 =item * The functions C<isl_basic_map_identity> and
-C<isl_map_identity> now take the dimension specification
-of a B<map> as input.  An old call
-C<isl_map_identity(dim)> can be rewritten to
-C<isl_map_identity(isl_dim_map_from_set(dim))>.
+C<isl_map_identity> now take a B<map> space as input.  An old call
+C<isl_map_identity(space)> can be rewritten to
+C<isl_map_identity(isl_space_map_from_set(space))>.
 
 =item * The function C<isl_map_power> no longer takes
 a parameter position as input.  Instead, the exponent
@@ -87,6 +86,24 @@ is now expressed as the domain of the resulting relation.
 C<ISL_FORMAT_ISL> output has changed.
 Use C<ISL_FORMAT_C> to obtain the old output.
 
+=item * The C<*_fast_*> functions have been renamed to C<*_plain_*>.
+Some of the old names have been kept for backward compatibility,
+but they will be removed in the future.
+
+=back
+
+=head3 Changes since isl-0.07
+
+=over
+
+=item * The function C<isl_pw_aff_max> has been renamed to
+C<isl_pw_aff_union_max>.
+
+=item * The C<isl_dim> type has been renamed to C<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.
+
 =back
 
 =head1 Installation
@@ -354,10 +371,10 @@ can be described as a conjunction of affine constraints, while
 C<isl_set> and C<isl_map> represent unions of
 C<isl_basic_set>s and C<isl_basic_map>s, respectively.
 However, all C<isl_basic_set>s or C<isl_basic_map>s in the union need
-to have the same dimension.  C<isl_union_set>s and C<isl_union_map>s
-represent unions of C<isl_set>s or C<isl_map>s of I<different> dimensions,
-where dimensions with different space names
-(see L<Dimension Specifications>) are considered different as well.
+to live in the same space.  C<isl_union_set>s and C<isl_union_map>s
+represent unions of C<isl_set>s or C<isl_map>s in I<different> spaces,
+where spaces are considered different if they have a different number
+of dimensions and/or different names (see L<"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.
@@ -374,7 +391,7 @@ 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 documents functions are
+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
@@ -402,7 +419,7 @@ returning an C<__isl_give> pointer.
 If the user passes in a C<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 the other C<__isl_take> arguments
+make sure that all the other C<__isl_take> arguments
 are released.
 
 =item C<__isl_keep>
@@ -415,28 +432,54 @@ a C<NULL> value for an C<__isl_take> argument.
 
 =back
 
-=head2 Dimension Specifications
+=head2 Identifiers
+
+Identifiers are used to identify both individual dimensions
+and tuples of dimensions.  They consist of a name and an optional
+pointer.  Identifiers with the same name but different pointer values
+are considered to be distinct.
+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_copy(isl_id *id);
+       void *isl_id_free(__isl_take isl_id *id);
+
+       isl_ctx *isl_id_get_ctx(__isl_keep 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);
+
+Note that C<isl_id_get_name> returns a pointer to some internal
+data structure, so the result can only be used while the
+corresponding C<isl_id> is alive.
+
+=head2 Spaces
 
 Whenever a new set or relation is created from scratch,
-its dimension needs to be specified using an C<isl_dim>.
+the space in which it lives needs to be specified using an C<isl_space>.
 
-       #include <isl/dim.h>
-       __isl_give isl_dim *isl_dim_alloc(isl_ctx *ctx,
+       #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_dim *isl_dim_set_alloc(isl_ctx *ctx,
+       __isl_give isl_space *isl_space_set_alloc(isl_ctx *ctx,
                unsigned nparam, unsigned dim);
-       __isl_give isl_dim *isl_dim_copy(__isl_keep isl_dim *dim);
-       void isl_dim_free(__isl_take isl_dim *dim);
-       unsigned isl_dim_size(__isl_keep isl_dim *dim,
+       __isl_give isl_space *isl_space_copy(__isl_keep isl_space *space);
+       void isl_space_free(__isl_take isl_space *space);
+       unsigned isl_space_dim(__isl_keep isl_space *space,
                enum isl_dim_type type);
 
-The dimension specification used for creating a set
-needs to be created using C<isl_dim_set_alloc>, while
+The space used for creating a set
+needs to be created using C<isl_space_set_alloc>, while
 that for creating a relation
-needs to be created using C<isl_dim_alloc>.
-C<isl_dim_size> can be used
+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
-a dimension specification, where type may be
+a space, where type may be
 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>.
@@ -445,86 +488,113 @@ 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 L<Creating New Sets and Relations> or
-L<Creating New (Piecewise) Quasipolynomials>) based on the dimension
-specification of the original object.
+L<Creating New (Piecewise) Quasipolynomials>) based on the space
+of the original object.
 
        #include <isl/set.h>
-       __isl_give isl_dim *isl_basic_set_get_dim(
+       __isl_give isl_space *isl_basic_set_get_space(
                __isl_keep isl_basic_set *bset);
-       __isl_give isl_dim *isl_set_get_dim(__isl_keep isl_set *set);
+       __isl_give isl_space *isl_set_get_space(__isl_keep isl_set *set);
 
        #include <isl/union_set.h>
-       __isl_give isl_dim *isl_union_set_get_dim(
+       __isl_give isl_space *isl_union_set_get_space(
                __isl_keep isl_union_set *uset);
 
        #include <isl/map.h>
-       __isl_give isl_dim *isl_basic_map_get_dim(
+       __isl_give isl_space *isl_basic_map_get_space(
                __isl_keep isl_basic_map *bmap);
-       __isl_give isl_dim *isl_map_get_dim(__isl_keep isl_map *map);
+       __isl_give isl_space *isl_map_get_space(__isl_keep isl_map *map);
 
        #include <isl/union_map.h>
-       __isl_give isl_dim *isl_union_map_get_dim(
+       __isl_give isl_space *isl_union_map_get_space(
                __isl_keep isl_union_map *umap);
 
        #include <isl/constraint.h>
-       __isl_give isl_dim *isl_constraint_get_dim(
+       __isl_give isl_space *isl_constraint_get_space(
                __isl_keep isl_constraint *constraint);
 
        #include <isl/polynomial.h>
-       __isl_give isl_dim *isl_qpolynomial_get_dim(
+       __isl_give isl_space *isl_qpolynomial_get_space(
                __isl_keep isl_qpolynomial *qp);
-       __isl_give isl_dim *isl_qpolynomial_fold_get_dim(
+       __isl_give isl_space *isl_qpolynomial_fold_get_space(
                __isl_keep isl_qpolynomial_fold *fold);
-       __isl_give isl_dim *isl_pw_qpolynomial_get_dim(
+       __isl_give isl_space *isl_pw_qpolynomial_get_space(
                __isl_keep isl_pw_qpolynomial *pwqp);
-       __isl_give isl_dim *isl_union_pw_qpolynomial_get_dim(
+       __isl_give isl_space *isl_union_pw_qpolynomial_get_space(
                __isl_keep isl_union_pw_qpolynomial *upwqp);
-       __isl_give isl_dim *isl_union_pw_qpolynomial_fold_get_dim(
+       __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_dim *isl_aff_get_dim(
+       __isl_give isl_space *isl_aff_get_space(
                __isl_keep isl_aff *aff);
+       __isl_give isl_space *isl_pw_aff_get_space(
+               __isl_keep isl_pw_aff *pwaff);
 
        #include <isl/point.h>
-       __isl_give isl_dim *isl_point_get_dim(
+       __isl_give isl_space *isl_point_get_space(
                __isl_keep isl_point *pnt);
 
-The names of the individual dimensions may be set or read off
+The identifiers or names of the individual dimensions may be set or read off
 using the following functions.
 
-       #include <isl/dim.h>
-       __isl_give isl_dim *isl_dim_set_name(__isl_take isl_dim *dim,
+       #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);
+       int 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_keep const char *isl_dim_get_name(__isl_keep isl_dim *dim,
+       __isl_keep const char *isl_space_get_dim_name(__isl_keep isl_space *space,
                                 enum isl_dim_type type, unsigned pos);
 
-Note that C<isl_dim_get_name> returns a pointer to some internal
+Note that C<isl_space_get_name> returns a pointer to some internal
 data structure, so the result can only be used while the
-corresponding C<isl_dim> is alive.
+corresponding C<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 C<isl_union_set> and/or C<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
+Pairs of C<isl_set>, C<isl_map>, C<isl_union_set> and/or C<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.
 
-The names of entire spaces may be set or read off
+Given the identifier 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);
+
+The identifiers or names of entire spaces may be set or read off
 using the following functions.
 
-       #include <isl/dim.h>
-       __isl_give isl_dim *isl_dim_set_tuple_name(
-               __isl_take isl_dim *dim,
+       #include <isl/space.h>
+       __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);
+       int isl_space_has_tuple_id(__isl_keep isl_space *space,
+               enum isl_dim_type type);
+       __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);
-       const char *isl_dim_get_tuple_name(__isl_keep isl_dim *dim,
+       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>
-or C<isl_dim_set>.  As with C<isl_dim_get_name>,
-the C<isl_dim_get_tuple_name> function returns a pointer to some internal
+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.
 Binary operations require the corresponding spaces of their arguments
 to have the same name.
@@ -532,48 +602,53 @@ to have the same name.
 Spaces can be nested.  In particular, the domain of a set or
 the domain or range of a relation can be a nested relation.
 The following functions can be used to construct and deconstruct
-such nested dimension specifications.
-
-       #include <isl/dim.h>
-       int isl_dim_is_wrapping(__isl_keep isl_dim *dim);
-       __isl_give isl_dim *isl_dim_wrap(__isl_take isl_dim *dim);
-       __isl_give isl_dim *isl_dim_unwrap(__isl_take isl_dim *dim);
-
-The input to C<isl_dim_is_wrapping> and C<isl_dim_unwrap> should
-be the dimension specification of a set, while that of
-C<isl_dim_wrap> should be the dimension specification of a relation.
-Conversely, the output of C<isl_dim_unwrap> is the dimension specification
-of a relation, while that of C<isl_dim_wrap> is the dimension specification
-of a set.
-
-Dimension specifications can be created from other dimension
-specifications using the following functions.
-
-       __isl_give isl_dim *isl_dim_domain(__isl_take isl_dim *dim);
-       __isl_give isl_dim *isl_dim_from_domain(__isl_take isl_dim *dim);
-       __isl_give isl_dim *isl_dim_range(__isl_take isl_dim *dim);
-       __isl_give isl_dim *isl_dim_from_range(__isl_take isl_dim *dim);
-       __isl_give isl_dim *isl_dim_reverse(__isl_take isl_dim *dim);
-       __isl_give isl_dim *isl_dim_join(__isl_take isl_dim *left,
-               __isl_take isl_dim *right);
-       __isl_give isl_dim *isl_dim_align_params(
-               __isl_take isl_dim *dim1, __isl_take isl_dim *dim2)
-       __isl_give isl_dim *isl_dim_insert(__isl_take isl_dim *dim,
+such nested spaces.
+
+       #include <isl/space.h>
+       int isl_space_is_wrapping(__isl_keep isl_space *space);
+       __isl_give isl_space *isl_space_wrap(__isl_take isl_space *space);
+       __isl_give isl_space *isl_space_unwrap(__isl_take isl_space *space);
+
+The input to C<isl_space_is_wrapping> and C<isl_space_unwrap> should
+be the space of a set, while that of
+C<isl_space_wrap> should be the space of a relation.
+Conversely, the output of C<isl_space_unwrap> is the space
+of a relation, while that of C<isl_space_wrap> is the space of a set.
+
+Spaces can be created from other spaces
+using the following functions.
+
+       __isl_give isl_space *isl_space_domain(__isl_take isl_space *space);
+       __isl_give isl_space *isl_space_from_domain(__isl_take isl_space *space);
+       __isl_give isl_space *isl_space_range(__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_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_align_params(
+               __isl_take isl_space *space1, __isl_take isl_space *space2)
+       __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_dim *isl_dim_add(__isl_take isl_dim *dim,
+       __isl_give isl_space *isl_space_add_dims(__isl_take isl_space *space,
                enum isl_dim_type type, unsigned n);
-       __isl_give isl_dim *isl_dim_drop(__isl_take isl_dim *dim,
+       __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_dim *isl_dim_map_from_set(
-               __isl_take isl_dim *dim);
-       __isl_give isl_dim *isl_dim_zip(__isl_take isl_dim *dim);
+       __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);
+       __isl_give isl_space *isl_space_map_from_set(
+               __isl_take isl_space *space);
+       __isl_give isl_space *isl_space_zip(__isl_take isl_space *space);
 
 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
+A local space is essentially a space with
 zero or more existentially quantified variables.
 The local space of a basic set or relation can be obtained
 using the following functions.
@@ -586,11 +661,11 @@ using the following functions.
        __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
+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_dim(
-               __isl_take isl_dim *dim);
+       __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.
 
@@ -605,7 +680,7 @@ 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_dim *isl_local_space_get_dim(
+       __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_keep isl_local_space *ls, int pos);
@@ -709,7 +784,7 @@ dimensions is zero.
        __isl_give isl_basic_map *isl_basic_map_read_from_str(
                isl_ctx *ctx, const char *str, int nparam);
        __isl_give isl_map *isl_map_read_from_file(
-               struct isl_ctx *ctx, FILE *input, int nparam);
+               isl_ctx *ctx, FILE *input, int nparam);
        __isl_give isl_map *isl_map_read_from_str(isl_ctx *ctx,
                const char *str, int nparam);
 
@@ -717,13 +792,13 @@ dimensions is zero.
        __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(
-               struct isl_ctx *ctx, const char *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(
-               struct isl_ctx *ctx, const char *str);
+               isl_ctx *ctx, const char *str);
 
 The input format is autodetected and may be either the C<PolyLib> format
 or the C<isl> format.
@@ -816,31 +891,31 @@ C<isl> has functions for creating some standard sets and relations.
 =item * Empty sets and relations
 
        __isl_give isl_basic_set *isl_basic_set_empty(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
        __isl_give isl_basic_map *isl_basic_map_empty(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
        __isl_give isl_set *isl_set_empty(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
        __isl_give isl_map *isl_map_empty(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
        __isl_give isl_union_set *isl_union_set_empty(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
        __isl_give isl_union_map *isl_union_map_empty(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
 
-For C<isl_union_set>s and C<isl_union_map>s, the dimensions specification
+For C<isl_union_set>s and C<isl_union_map>s, the space
 is only used to specify the parameters.
 
 =item * Universe sets and relations
 
        __isl_give isl_basic_set *isl_basic_set_universe(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
        __isl_give isl_basic_map *isl_basic_map_universe(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
        __isl_give isl_set *isl_set_universe(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
        __isl_give isl_map *isl_map_universe(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
        __isl_give isl_union_set *isl_union_set_universe(
                __isl_take isl_union_set *uset);
        __isl_give isl_union_map *isl_union_map_universe(
@@ -851,50 +926,50 @@ 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_dim *dim);
+               __isl_take isl_space *space);
        __isl_give isl_basic_map *isl_basic_map_nat_universe(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
        __isl_give isl_set *isl_set_nat_universe(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
        __isl_give isl_map *isl_map_nat_universe(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
 
 =item * Identity relations
 
        __isl_give isl_basic_map *isl_basic_map_identity(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
        __isl_give isl_map *isl_map_identity(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
 
-The number of input and output dimensions in C<dim> needs
+The number of input and output dimensions in C<space> needs
 to be the same.
 
 =item * Lexicographic order
 
        __isl_give isl_map *isl_map_lex_lt(
-               __isl_take isl_dim *set_dim);
+               __isl_take isl_space *set_space);
        __isl_give isl_map *isl_map_lex_le(
-               __isl_take isl_dim *set_dim);
+               __isl_take isl_space *set_space);
        __isl_give isl_map *isl_map_lex_gt(
-               __isl_take isl_dim *set_dim);
+               __isl_take isl_space *set_space);
        __isl_give isl_map *isl_map_lex_ge(
-               __isl_take isl_dim *set_dim);
+               __isl_take isl_space *set_space);
        __isl_give isl_map *isl_map_lex_lt_first(
-               __isl_take isl_dim *dim, unsigned n);
+               __isl_take isl_space *space, unsigned n);
        __isl_give isl_map *isl_map_lex_le_first(
-               __isl_take isl_dim *dim, unsigned n);
+               __isl_take isl_space *space, unsigned n);
        __isl_give isl_map *isl_map_lex_gt_first(
-               __isl_take isl_dim *dim, unsigned n);
+               __isl_take isl_space *space, unsigned n);
        __isl_give isl_map *isl_map_lex_ge_first(
-               __isl_take isl_dim *dim, unsigned n);
+               __isl_take isl_space *space, unsigned n);
 
-The first four functions take a dimension specification for a B<set>
+The first four functions take a space for a B<set>
 and return relations that express that the elements in the domain
 are lexicographically less
 (C<isl_map_lex_lt>), less or equal (C<isl_map_lex_le>),
 greater (C<isl_map_lex_gt>) or greater or equal (C<isl_map_lex_ge>)
 than the elements in the range.
-The last four functions take a dimension specification for a map
+The last four functions take a space for a map
 and return relations that express that the first C<n> dimensions
 in the domain are lexicographically less
 (C<isl_map_lex_lt_first>), less or equal (C<isl_map_lex_le_first>),
@@ -919,6 +994,15 @@ using the following functions.
        __isl_give isl_union_set *isl_union_set_from_set(
                __isl_take isl_set *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.
+
+       __isl_give isl_set *isl_set_from_union_set(
+               __isl_take isl_union_set *uset);
+       __isl_give isl_map *isl_map_from_union_map(
+               __isl_take isl_union_map *umap);
+
 Sets and relations can be copied and freed again using the following
 functions.
 
@@ -934,28 +1018,34 @@ functions.
                __isl_keep isl_union_map *umap);
        void isl_basic_set_free(__isl_take isl_basic_set *bset);
        void isl_set_free(__isl_take isl_set *set);
-       void isl_union_set_free(__isl_take isl_union_set *uset);
+       void *isl_union_set_free(__isl_take isl_union_set *uset);
        void isl_basic_map_free(__isl_take isl_basic_map *bmap);
        void isl_map_free(__isl_take isl_map *map);
-       void isl_union_map_free(__isl_take isl_union_map *umap);
+       void *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 (basic) sets and relations using the following functions.
+added to (or removed from) (basic) sets and relations
+using the following functions.
 
        #include <isl/constraint.h>
        __isl_give isl_constraint *isl_equality_alloc(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
        __isl_give isl_constraint *isl_inequality_alloc(
-               __isl_take isl_dim *dim);
-       void isl_constraint_set_constant(
-               __isl_keep isl_constraint *constraint, isl_int v);
-       void isl_constraint_set_coefficient(
-               __isl_keep isl_constraint *constraint,
+               __isl_take isl_space *space);
+       __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_take isl_constraint *constraint, int v);
+       __isl_give isl_constraint *isl_constraint_set_coefficient(
+               __isl_take isl_constraint *constraint,
                enum isl_dim_type type, int pos, isl_int 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_basic_map *isl_basic_map_add_constraint(
                __isl_take isl_basic_map *bmap,
                __isl_take isl_constraint *constraint);
@@ -968,34 +1058,37 @@ added to (basic) sets and relations using the following functions.
        __isl_give isl_set *isl_set_add_constraint(
                __isl_take isl_set *set,
                __isl_take isl_constraint *constraint);
+       __isl_give isl_basic_set *isl_basic_set_drop_constraint(
+               __isl_take isl_basic_set *bset,
+               __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.
 
        isl_int v;
-       struct isl_dim *dim;
-       struct isl_constraint *c;
-       struct isl_basic_set *bset;
+       isl_space *space;
+       isl_constraint *c;
+       isl_basic_set *bset;
 
        isl_int_init(v);
-       dim = isl_dim_set_alloc(ctx, 0, 2);
-       bset = isl_basic_set_universe(isl_dim_copy(dim));
+       space = isl_space_set_alloc(ctx, 0, 2);
+       bset = isl_basic_set_universe(isl_space_copy(space));
 
-       c = isl_equality_alloc(isl_dim_copy(dim));
+       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);
        bset = isl_basic_set_add_constraint(bset, c);
 
-       c = isl_inequality_alloc(isl_dim_copy(dim));
+       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);
        bset = isl_basic_set_add_constraint(bset, c);
 
-       c = isl_inequality_alloc(dim);
+       c = isl_inequality_alloc(space);
        isl_int_set_si(v, 42);
        isl_constraint_set_constant(c, v);
        isl_int_set_si(v, -1);
@@ -1008,7 +1101,7 @@ between 10 and 42, you would use the following code.
 
 Or, alternatively,
 
-       struct isl_basic_set *bset;
+       isl_basic_set *bset;
        bset = isl_basic_set_read_from_str(ctx,
                "{[i] : exists (a : i = 2a and i >= 10 and i <= 42)}", -1);
 
@@ -1016,13 +1109,13 @@ 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_dim *dim,
+               __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_dim *dim,
+               __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,
@@ -1043,7 +1136,7 @@ or a list of affine expressions (See L<"Piecewise Quasi Affine Expressions">).
        __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_dim *domain_dim,
+               __isl_take isl_space *domain_space,
                __isl_take isl_aff_list *list);
 
 The C<domain_dim> argument describes the domain of the resulting
@@ -1111,15 +1204,14 @@ from
        int isl_union_set_n_set(__isl_keep isl_union_set *uset);
        int isl_union_map_n_map(__isl_keep isl_union_map *umap);
 
-To extract the set or map from a union with a given dimension
-specification, use
+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_dim *dim);
+               __isl_take isl_space *space);
        __isl_give isl_map *isl_union_map_extract_map(
                __isl_keep isl_union_map *umap,
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
 
 To iterate over all the basic sets or maps in a set or map, use
 
@@ -1157,7 +1249,7 @@ To iterate over the constraints of a basic set or map, use
                __isl_keep isl_basic_map *bmap,
                int (*fn)(__isl_take isl_constraint *c, void *user),
                void *user);
-       void isl_constraint_free(struct isl_constraint *c);
+       void *isl_constraint_free(__isl_take isl_constraint *c);
 
 Again, the callback function C<fn> should return 0 if successful and
 -1 if an error occurs.  In the latter case, or if any other error
@@ -1224,8 +1316,60 @@ different kinds of variables appear in the resulting matrix
 and should be a permutation of C<isl_dim_cst>, C<isl_dim_param>,
 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div>.
 
-The names of the domain and range spaces of a set or relation can be
-read off or set using the following functions.
+The number of parameters, input, output or set dimensions can
+be obtained using the following functions.
+
+       unsigned isl_basic_set_dim(__isl_keep isl_basic_set *bset,
+               enum isl_dim_type type);
+       unsigned isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
+               enum isl_dim_type type);
+       unsigned isl_set_dim(__isl_keep isl_set *set,
+               enum isl_dim_type type);
+       unsigned isl_map_dim(__isl_keep isl_map *map,
+               enum isl_dim_type type);
+
+To check whether the description of a set or relation depends
+on one or more given dimensions, it is not necessary to iterate over all
+constraints.  Instead the following functions can be used.
+
+       int isl_basic_set_involves_dims(
+               __isl_keep isl_basic_set *bset,
+               enum isl_dim_type type, unsigned first, unsigned n);
+       int isl_set_involves_dims(__isl_keep isl_set *set,
+               enum isl_dim_type type, unsigned first, unsigned n);
+       int isl_basic_map_involves_dims(
+               __isl_keep isl_basic_map *bmap,
+               enum isl_dim_type type, unsigned first, unsigned n);
+       int isl_map_involves_dims(__isl_keep isl_map *map,
+               enum isl_dim_type type, unsigned first, unsigned n);
+
+Similarly, the following functions can be used to check whether
+a given dimension is involved in any lower or upper bound.
+
+       int isl_set_dim_has_lower_bound(__isl_keep isl_set *set,
+               enum isl_dim_type type, unsigned pos);
+       int isl_set_dim_has_upper_bound(__isl_keep isl_set *set,
+               enum isl_dim_type type, unsigned pos);
+
+The identifiers or names of the domain and range spaces of a set
+or relation can be read off or set using the following functions.
+
+       __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);
+       int 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_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);
+       int isl_map_has_tuple_id(__isl_keep isl_map *map,
+               enum isl_dim_type type);
+       __isl_give isl_id *isl_map_get_tuple_id(
+               __isl_keep isl_map *map, enum isl_dim_type type);
 
        const char *isl_basic_set_get_tuple_name(
                __isl_keep isl_basic_set *bset);
@@ -1240,10 +1384,32 @@ read off or set using the following functions.
                __isl_keep isl_map *map,
                enum isl_dim_type type);
 
-As with C<isl_dim_get_tuple_name>, the value returned points to
+As with C<isl_space_get_tuple_name>, the value returned points to
 an internal data structure.
-The names of individual dimensions can be read off using
-the following functions.
+The identifiers, positions or names of individual dimensions can be
+read off using the following functions.
+
+       __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);
+       int 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);
+       __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);
+       int 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);
+
+       int isl_set_find_dim_by_id(__isl_keep isl_set *set,
+               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);
 
        const char *isl_constraint_get_dim_name(
                __isl_keep isl_constraint *constraint,
@@ -1261,8 +1427,10 @@ the following functions.
                __isl_keep isl_map *map,
                enum isl_dim_type type, unsigned pos);
 
-These functions are mostly useful to obtain the names
-of the parameters.
+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.
 
 =head2 Properties
 
@@ -1313,6 +1481,19 @@ is already known to be empty.
        int isl_map_is_bijective(__isl_keep isl_map *map);
        int isl_union_map_is_bijective(__isl_keep isl_union_map *umap);
 
+=item * Position
+
+       int isl_basic_map_plain_is_fixed(
+               __isl_keep isl_basic_map *bmap,
+               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);
+
+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 * Wrapping
 
 The following functions check whether the domain of the given
@@ -1486,6 +1667,23 @@ without removing the dimensions.
 Intersect the set or relation with the hyperplane where the given
 dimension has the fixed given value.
 
+       __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_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.
+
 =item * Identity
 
        __isl_give isl_map *isl_set_identity(
@@ -1629,20 +1827,24 @@ per space.
        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_min(__isl_keep isl_set *set,
+               __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>
+Compute the minimum or 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 * 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);
 
-Compute the maximum of the given set dimension as a function of the
+Compute the minimum or maximum of the given set dimension as a function of the
 parameters, but independently of the other set dimensions.
 For lexicographic optimization, see L<"Lexicographic Optimization">.
 
@@ -1740,10 +1942,14 @@ then the name of the space is also removed.
                __isl_take isl_basic_set *bset);
        __isl_give isl_set *isl_set_flatten(
                __isl_take isl_set *set);
+       __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(
@@ -1786,10 +1992,10 @@ interchange the range of the domain with the domain of the range.
 
        __isl_give isl_set *isl_set_align_params(
                __isl_take isl_set *set,
-               __isl_take isl_dim *model);
+               __isl_take isl_space *model);
        __isl_give isl_map *isl_map_align_params(
                __isl_take isl_map *map,
-               __isl_take isl_dim *model);
+               __isl_take isl_space *model);
 
 Change the order of the parameters of the given set or relation
 such that the first parameters match those of C<model>.
@@ -1804,6 +2010,12 @@ All parameters need to be named.
        __isl_give isl_map *isl_map_add_dims(
                __isl_take isl_map *map,
                enum isl_dim_type type, 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_map *isl_map_insert_dims(
+               __isl_take isl_map *map,
+               enum isl_dim_type type, unsigned 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
@@ -1829,6 +2041,9 @@ the same (number of) parameters.
        __isl_give isl_basic_set *isl_basic_set_intersect(
                __isl_take isl_basic_set *bset1,
                __isl_take isl_basic_set *bset2);
+       __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);
@@ -1844,6 +2059,9 @@ the same (number of) parameters.
        __isl_give isl_basic_map *isl_basic_map_intersect(
                __isl_take isl_basic_map *bmap1,
                __isl_take isl_basic_map *bmap2);
+       __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);
@@ -1937,9 +2155,15 @@ the same (number of) parameters.
        __isl_give isl_union_set *isl_union_set_product(
                __isl_take isl_union_set *uset1,
                __isl_take isl_union_set *uset2);
+       __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_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);
@@ -1968,6 +2192,9 @@ instead.
        __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);
@@ -2106,11 +2333,13 @@ In case of union relations, the optimum is computed per space.
 =head2 Lists
 
 Lists are defined over several element types, including
-C<isl_aff>, C<isl_basic_set> and C<isl_set>.
+C<isl_aff>, C<isl_pw_aff>, 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_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(
@@ -2118,20 +2347,24 @@ Lists can be created, copied and freed using the following functions.
        __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);
+       __isl_give isl_set_list *isl_set_list_concat(
+               __isl_take isl_set_list *list1,
+               __isl_take isl_set_list *list2);
+       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.
+C<n> elements.  C<isl_set_list_from_set> creates a list with a single
+element.
 
 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);
-       __isl_give struct isl_set *isl_set_list_get_set(
+       __isl_give isl_set *isl_set_list_get_set(
                __isl_keep isl_set_list *list, int index);
        int isl_set_list_foreach(__isl_keep isl_set_list *list,
-               int (*fn)(__isl_take struct isl_set *el, void *user),
+               int (*fn)(__isl_take isl_set *el, void *user),
                void *user);
 
 Lists can be printed using
@@ -2146,7 +2379,7 @@ Lists can be printed using
 Matrices can be created, copied and freed using the following functions.
 
        #include <isl/mat.h>
-       __isl_give isl_mat *isl_mat_alloc(struct isl_ctx *ctx,
+       __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);
        void isl_mat_free(__isl_take isl_mat *mat);
@@ -2187,17 +2420,24 @@ The zero quasi affine expression can be created using
        __isl_give isl_aff *isl_aff_zero(
                __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);
+
 An empty piecewise quasi affine expression (one with no cells)
 or a piecewise quasi affine expression with a single cell can
 be created using the following functions.
 
        #include <isl/aff.h>
        __isl_give isl_pw_aff *isl_pw_aff_empty(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
        __isl_give isl_pw_aff *isl_pw_aff_alloc(
                __isl_take isl_set *set, __isl_take isl_aff *aff);
+       __isl_give isl_pw_aff *isl_pw_aff_from_aff(
+               __isl_take isl_aff *aff);
 
-Quasi affine expressions can be copied and free using
+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);
@@ -2216,6 +2456,13 @@ a non-zero coefficient for the specified dimension.
                __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
@@ -2244,6 +2491,19 @@ The expression can be inspected using
        __isl_give isl_div *isl_aff_get_div(
                __isl_keep isl_aff *aff, int pos);
 
+       int isl_pw_aff_foreach_piece(__isl_keep isl_pw_aff *pwaff,
+               int (*fn)(__isl_take isl_set *set,
+                         __isl_take isl_aff *aff,
+                         void *user), void *user);
+
+       int isl_aff_is_cst(__isl_keep isl_aff *aff);
+       int isl_pw_aff_is_cst(__isl_keep isl_pw_aff *pwaff);
+
+       int isl_aff_involves_dims(__isl_keep isl_aff *aff,
+               enum isl_dim_type type, unsigned first, unsigned n);
+       int isl_pw_aff_involves_dims(__isl_keep isl_pw_aff *pwaff,
+               enum isl_dim_type type, unsigned first, unsigned n);
+
        isl_ctx *isl_pw_aff_get_ctx(__isl_keep isl_pw_aff *pwaff);
        unsigned isl_pw_aff_dim(__isl_keep isl_pw_aff *pwaff,
                enum isl_dim_type type);
@@ -2252,6 +2512,9 @@ The expression can be inspected using
 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,
+               __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);
@@ -2272,10 +2535,32 @@ It can be modified using
                __isl_take isl_aff *aff, isl_int v);
        __isl_give isl_aff *isl_aff_add_constant_si(
                __isl_take isl_aff *aff, int v);
+       __isl_give isl_aff *isl_aff_add_coefficient(
+               __isl_take isl_aff *aff,
+               enum isl_dim_type type, int pos, 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);
 
+       __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_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_aff *isl_aff_add_dims(
+               __isl_take isl_aff *aff,
+               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_aff *isl_aff_drop_dims(
+               __isl_take isl_aff *aff,
+               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);
+
 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
@@ -2297,21 +2582,53 @@ Operations include
        __isl_give isl_pw_aff *isl_pw_aff_add(
                __isl_take isl_pw_aff *pwaff1,
                __isl_take isl_pw_aff *pwaff2);
+       __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_aff *isl_aff_sub(__isl_take isl_aff *aff1,
                __isl_take isl_aff *aff2);
+       __isl_give isl_pw_aff *isl_pw_aff_sub(
+               __isl_take isl_pw_aff *pwaff1,
+               __isl_take isl_pw_aff *pwaff2);
        __isl_give isl_aff *isl_aff_neg(__isl_take isl_aff *aff);
+       __isl_give isl_pw_aff *isl_pw_aff_neg(
+               __isl_take isl_pw_aff *pwaff);
        __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_pw_aff *isl_pw_aff_floor(
+               __isl_take isl_pw_aff *pwaff);
+       __isl_give isl_aff *isl_aff_mod(__isl_take isl_aff *aff,
+               isl_int mod);
+       __isl_give isl_pw_aff *isl_pw_aff_mod(
+               __isl_take isl_pw_aff *pwaff, isl_int mod);
        __isl_give isl_aff *isl_aff_scale(__isl_take isl_aff *aff,
                isl_int f);
+       __isl_give isl_pw_aff *isl_pw_aff_scale(
+               __isl_take isl_pw_aff *pwaff, isl_int f);
        __isl_give isl_aff *isl_aff_scale_down(__isl_take isl_aff *aff,
                isl_int f);
        __isl_give isl_aff *isl_aff_scale_down_ui(
                __isl_take isl_aff *aff, unsigned f);
+       __isl_give isl_pw_aff *isl_pw_aff_scale_down(
+               __isl_take isl_pw_aff *pwaff, isl_int f);
+
+       __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);
 
        __isl_give isl_pw_aff *isl_pw_aff_coalesce(
                __isl_take isl_pw_aff *pwqp);
 
+       __isl_give isl_pw_aff *isl_pw_aff_align_params(
+               __isl_take isl_pw_aff *pwaff,
+               __isl_take isl_space *model);
+
        __isl_give isl_aff *isl_aff_gist(__isl_take isl_aff *aff,
                __isl_take isl_set *context);
        __isl_give isl_pw_aff *isl_pw_aff_gist(
@@ -2321,19 +2638,99 @@ Operations include
        __isl_give isl_set *isl_pw_aff_domain(
                __isl_take isl_pw_aff *pwaff);
 
+       __isl_give isl_aff *isl_aff_mul(__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);
+
+When multiplying two affine expressions, at least one of the two needs
+to be a constant.
+
+       #include <isl/aff.h>
+       __isl_give isl_basic_set *isl_aff_le_basic_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_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_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 C<isl_aff_ge_basic_set> returns a basic set
 containing those elements in the shared space
 of C<aff1> and C<aff2> where C<aff1> is greater than or equal to C<aff2>.
+The function C<isl_aff_ge_set> returns a set
+containing those elements in the shared domain
+of C<pwaff1> and C<pwaff2> where C<pwaff1> is greater than or equal to C<pwaff2>.
+The functions operating on C<isl_pw_aff_list> apply the corresponding
+C<isl_pw_aff> function to each pair of elements in the two lists.
 
        #include <isl/aff.h>
-       __isl_give isl_pw_aff *isl_pw_aff_max(
+       __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);
+
+The function C<isl_pw_aff_nonneg_set> returns a set
+containing those elements in the domain
+of C<pwaff> where C<pwaff> is non-negative.
+
+       #include <isl/aff.h>
+       __isl_give isl_pw_aff *isl_pw_aff_cond(
+               __isl_take isl_set *cond,
+               __isl_take isl_pw_aff *pwaff_true,
+               __isl_take isl_pw_aff *pwaff_false);
+
+The function C<isl_pw_aff_cond> performs a conditional operator
+and returns an expression that is equal to C<pwaff_true>
+for elements in C<cond> and equal to C<pwaff_false> for elements
+not in C<cond>.
+
+       #include <isl/aff.h>
+       __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 C<isl_pw_aff_max> computes a piecewise quasi-affine
+The function C<isl_pw_aff_union_max> computes a piecewise quasi-affine
 expression with a domain that is the union of those of C<pwaff1> and
 C<pwaff2> and such that on each cell, the quasi-affine expression is
 the maximum of those of C<pwaff1> and C<pwaff2>.  If only one of
@@ -2357,7 +2754,7 @@ 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_dim *dim);
+       __isl_give isl_point *isl_point_zero(__isl_take isl_space *space);
 
 The coordinates of a point can be inspected, set and changed
 using
@@ -2502,22 +2899,22 @@ operations such as addition and multiplication
 on the resulting quasipolynomials
 
        __isl_give isl_qpolynomial *isl_qpolynomial_zero(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *dim);
        __isl_give isl_qpolynomial *isl_qpolynomial_one(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *dim);
        __isl_give isl_qpolynomial *isl_qpolynomial_infty(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *dim);
        __isl_give isl_qpolynomial *isl_qpolynomial_neginfty(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *dim);
        __isl_give isl_qpolynomial *isl_qpolynomial_nan(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *dim);
        __isl_give isl_qpolynomial *isl_qpolynomial_rat_cst(
-               __isl_take isl_dim *dim,
+               __isl_take isl_space *dim,
                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_dim *dim,
+               __isl_take isl_space *dim,
                enum isl_dim_type type, unsigned pos);
        __isl_give isl_qpolynomial *isl_qpolynomial_from_aff(
                __isl_take isl_aff *aff);
@@ -2528,13 +2925,17 @@ Multiple of these single cell piecewise quasipolynomials can
 be combined to create more complicated piecewise quasipolynomials.
 
        __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_zero(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
        __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_alloc(
                __isl_take isl_set *set,
                __isl_take isl_qpolynomial *qp);
+       __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_from_qpolynomial(
+               __isl_take isl_qpolynomial *qp);
+       __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_from_pw_aff(
+               __isl_take isl_pw_aff *pwaff);
 
        __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_zero(
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
        __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 *isl_union_pw_qpolynomial_add_pw_qpolynomial(
@@ -2546,7 +2947,7 @@ functions.
 
        __isl_give isl_qpolynomial *isl_qpolynomial_copy(
                __isl_keep isl_qpolynomial *qp);
-       void isl_qpolynomial_free(__isl_take isl_qpolynomial *qp);
+       void *isl_qpolynomial_free(__isl_take isl_qpolynomial *qp);
 
        __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_copy(
                __isl_keep isl_pw_qpolynomial *pwqp);
@@ -2568,13 +2969,12 @@ piecewise quasipolynomial, use the following function
                int (*fn)(__isl_take isl_pw_qpolynomial *pwqp, void *user),
                void *user);
 
-To extract the piecewise quasipolynomial from a union with a given dimension
-specification, use
+To extract the piecewise quasipolynomial in a given space from a union, use
 
        __isl_give isl_pw_qpolynomial *
        isl_union_pw_qpolynomial_extract_pw_qpolynomial(
                __isl_keep isl_union_pw_qpolynomial *upwqp,
-               __isl_take isl_dim *dim);
+               __isl_take isl_space *space);
 
 To iterate over the cells in a piecewise quasipolynomial,
 use either of the following two functions
@@ -2677,6 +3077,8 @@ are returned in C<*n> and C<*d>, respectively.
        __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_mul(
                __isl_take isl_pw_qpolynomial *pwqp1,
                __isl_take isl_pw_qpolynomial *pwqp2);
+       __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_pow(
+               __isl_take isl_pw_qpolynomial *pwqp, unsigned exponent);
 
        __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add(
                __isl_take isl_union_pw_qpolynomial *upwqp1,
@@ -2710,7 +3112,7 @@ are returned in C<*n> and C<*d>, respectively.
 
        __isl_give isl_qpolynomial *isl_qpolynomial_align_params(
                __isl_take isl_qpolynomial *qp,
-               __isl_take isl_dim *model);
+               __isl_take isl_space *model);
 
        __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_coalesce(
                __isl_take isl_union_pw_qpolynomial *upwqp);
@@ -3154,22 +3556,6 @@ A representation of the band can be printed using
                __isl_take isl_printer *p,
                __isl_keep isl_band *band);
 
-Alternatively, the schedule mapping
-can also be obtained in pieces using the following functions.
-
-       int isl_schedule_n_band(__isl_keep isl_schedule *sched);
-       __isl_give isl_union_map *isl_schedule_get_band(
-               __isl_keep isl_schedule *sched, unsigned band);
-
-C<isl_schedule_n_band> returns the maximal number of bands.
-C<isl_schedule_get_band> returns a union of mappings from a domain to
-the band of consecutive schedule dimensions with the given sequence
-number for that domain.  Bands with the same sequence number but for
-different domains may be completely unrelated.
-Within a band, the corresponding coordinates of the distance vectors
-are all non-negative, assuming that the coordinates for all previous
-bands are all zero.
-
 =head2 Parametric Vertex Enumeration
 
 The parametric vertex enumeration described in this section