doc: fix typo
[platform/upstream/isl.git] / doc / user.pod
index dea020b..1815c17 100644 (file)
@@ -363,8 +363,14 @@ Specific integer values can be created using the following functions.
                long i);
        __isl_give isl_val *isl_val_int_from_ui(isl_ctx *ctx,
                unsigned long u);
+       __isl_give isl_val *isl_val_int_from_chunks(isl_ctx *ctx,
+               size_t n, size_t size, const void *chunks);
 
-They can be copied and freed using the following functions.
+The function C<isl_val_int_from_chunks> constructs an C<isl_val>
+from the C<n> I<digits>, each consisting of C<size> bytes, stored at C<chunks>.
+The least significant digit is assumed to be stored first.
+
+Value objects can be copied and freed using the following functions.
 
        #include <isl/val.h>
        __isl_give isl_val *isl_val_copy(__isl_keep isl_val *v);
@@ -377,9 +383,20 @@ They can be inspected using the following functions.
        long isl_val_get_num_si(__isl_keep isl_val *v);
        long isl_val_get_den_si(__isl_keep isl_val *v);
        double isl_val_get_d(__isl_keep isl_val *v);
-
-Note that C<isl_val_get_num_si>, C<isl_val_get_den_si> and
-C<isl_val_get_d> can only be applied to rational values.
+       size_t isl_val_n_abs_num_chunks(__isl_keep isl_val *v,
+               size_t size);
+       int isl_val_get_abs_num_chunks(__isl_keep isl_val *v,
+               size_t size, void *chunks);
+
+C<isl_val_n_abs_num_chunks> returns the number of I<digits>
+of C<size> bytes needed to store the absolute value of the
+numerator of C<v>.
+C<isl_val_get_abs_num_chunks> stores these digits at C<chunks>,
+which is assumed to have been preallocated by the caller.
+The least significant digit is stored first.
+Note that C<isl_val_get_num_si>, C<isl_val_get_den_si>,
+C<isl_val_get_d>, C<isl_val_n_abs_num_chunks>
+and C<isl_val_get_abs_num_chunks> can only be applied to rational values.
 
 An C<isl_val> can be modified using the following function.
 
@@ -520,16 +537,27 @@ C<GMP> values using the following functions.
        int isl_val_get_num_gmp(__isl_keep isl_val *v, mpz_t z);
        int isl_val_get_den_gmp(__isl_keep isl_val *v, mpz_t z);
 
+=head3 Conversion from C<isl_int>
+
+The following functions are only temporarily available to ease
+the transition from C<isl_int> to C<isl_val>.  They will be removed
+in the next release.
+
+       #include <isl/val_int.h>
+       __isl_give isl_val *isl_val_int_from_isl_int(isl_ctx *ctx,
+               isl_int n);
+       int isl_val_get_num_isl_int(__isl_keep isl_val *v,
+               isl_int *n);
+
 =head2 Integers (obsolescent)
 
-All operations on integers, mainly the coefficients
-of the constraints describing the sets and relations,
-are performed in exact integer arithmetic using C<GMP>.
-However, to allow future versions of C<isl> to optionally
-support fixed integer arithmetic, all calls to C<GMP>
-are wrapped inside C<isl> specific macros.
-The basic type is C<isl_int> and the operations below
-are available on this type.
+In previous versions of C<isl>, integers were represented
+in the external interface using the C<isl_int> type.
+This type has now been superseded by C<isl_val>.
+The C<isl_int> type will be removed from the external interface
+in future releases.  New code should not use C<isl_int>.
+
+The operations below are currently available on C<isl_int>s.
 The meanings of these operations are essentially the same
 as their C<GMP> C<mpz_> counterparts.
 As always with C<GMP> types, C<isl_int>s need to be
@@ -1793,9 +1821,14 @@ the following functions.
                enum isl_dim_type type, unsigned pos);
        void isl_constraint_get_constant(
                __isl_keep isl_constraint *constraint, isl_int *v);
+       __isl_give isl_val *isl_constraint_get_constant_val(
+               __isl_keep isl_constraint *constraint);
        void isl_constraint_get_coefficient(
                __isl_keep isl_constraint *constraint,
                enum isl_dim_type type, int pos, isl_int *v);
+       __isl_give isl_val *isl_constraint_get_coefficient_val(
+               __isl_keep isl_constraint *constraint,
+               enum isl_dim_type type, int pos);
        int isl_constraint_involves_dims(
                __isl_keep isl_constraint *constraint,
                enum isl_dim_type type, unsigned first, unsigned n);
@@ -2055,6 +2088,36 @@ 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>.
 
+       __isl_give isl_val *
+       isl_basic_map_plain_get_val_if_fixed(
+               __isl_keep isl_basic_map *bmap,
+               enum isl_dim_type type, unsigned pos);
+       __isl_give isl_val *isl_set_plain_get_val_if_fixed(
+               __isl_keep isl_set *set,
+               enum isl_dim_type type, unsigned pos);
+       __isl_give isl_val *isl_map_plain_get_val_if_fixed(
+               __isl_keep isl_map *map,
+               enum isl_dim_type type, unsigned pos);
+
+If the set or relation obviously lies on a hyperplane where the given dimension
+has a fixed value, then return that value.
+Otherwise return NaN.
+
+=item * Stride
+
+       int isl_set_dim_residue_class_val(
+               __isl_keep isl_set *set,
+               int pos, __isl_give isl_val **modulo,
+               __isl_give isl_val **residue);
+
+Check if the values of the given set dimension are equal to a fixed
+value modulo some integer value.  If so, assign the modulo to C<*modulo>
+and the fixed value to C<*residue>.  If the given dimension attains only
+a single value, then assign C<0> to C<*modulo> and the fixed value to
+C<*residue>.
+If the dimension does not attain only a single value and if no modulo
+can be found then assign C<1> to C<*modulo> and C<1> to C<*residue>.
+
 =item * Space
 
 To check whether a set is a parameter domain, use this function:
@@ -2278,19 +2341,35 @@ without removing the dimensions.
        __isl_give isl_basic_set *isl_basic_set_fix_si(
                __isl_take isl_basic_set *bset,
                enum isl_dim_type type, unsigned pos, int value);
+       __isl_give isl_basic_set *isl_basic_set_fix_val(
+               __isl_take isl_basic_set *bset,
+               enum isl_dim_type type, unsigned pos,
+               __isl_take isl_val *v);
        __isl_give isl_set *isl_set_fix(__isl_take isl_set *set,
                enum isl_dim_type type, unsigned pos,
                isl_int value);
        __isl_give isl_set *isl_set_fix_si(__isl_take isl_set *set,
                enum isl_dim_type type, unsigned pos, int value);
+       __isl_give isl_set *isl_set_fix_val(
+               __isl_take isl_set *set,
+               enum isl_dim_type type, unsigned pos,
+               __isl_take isl_val *v);
        __isl_give isl_basic_map *isl_basic_map_fix_si(
                __isl_take isl_basic_map *bmap,
                enum isl_dim_type type, unsigned pos, int value);
+       __isl_give isl_basic_map *isl_basic_map_fix_val(
+               __isl_take isl_basic_map *bmap,
+               enum isl_dim_type type, unsigned pos,
+               __isl_take isl_val *v);
        __isl_give isl_map *isl_map_fix(__isl_take isl_map *map,
                enum isl_dim_type type, unsigned pos,
                isl_int value);
        __isl_give isl_map *isl_map_fix_si(__isl_take isl_map *map,
                enum isl_dim_type type, unsigned pos, int value);
+       __isl_give isl_map *isl_map_fix_val(
+               __isl_take isl_map *map,
+               enum isl_dim_type type, unsigned pos,
+               __isl_take isl_val *v);
 
 Intersect the set or relation with the hyperplane where the given
 dimension has the fixed given value.
@@ -2308,6 +2387,10 @@ dimension has the fixed given value.
        __isl_give isl_set *isl_set_lower_bound_si(
                __isl_take isl_set *set,
                enum isl_dim_type type, unsigned pos, int value);
+       __isl_give isl_set *isl_set_lower_bound_val(
+               __isl_take isl_set *set,
+               enum isl_dim_type type, unsigned pos,
+               __isl_take isl_val *value);
        __isl_give isl_map *isl_map_lower_bound_si(
                __isl_take isl_map *map,
                enum isl_dim_type type, unsigned pos, int value);
@@ -2318,12 +2401,16 @@ dimension has the fixed given value.
        __isl_give isl_set *isl_set_upper_bound_si(
                __isl_take isl_set *set,
                enum isl_dim_type type, unsigned pos, int value);
+       __isl_give isl_set *isl_set_upper_bound_val(
+               __isl_take isl_set *set,
+               enum isl_dim_type type, unsigned pos,
+               __isl_take isl_val *value);
        __isl_give isl_map *isl_map_upper_bound_si(
                __isl_take isl_map *map,
                enum isl_dim_type type, unsigned pos, int value);
 
 Intersect the set or relation with the half-space where the given
-dimension has a value bounded by the fixed given value.
+dimension has a value bounded by the fixed given integer value.
 
        __isl_give isl_set *isl_set_equate(__isl_take isl_set *set,
                enum isl_dim_type type1, int pos1,
@@ -2571,15 +2658,28 @@ a singleton subset of the input.  Otherwise, return an empty set.
        enum isl_lp_result isl_basic_set_max(
                __isl_keep isl_basic_set *bset,
                __isl_keep isl_aff *obj, isl_int *opt)
+       __isl_give isl_val *isl_basic_set_max_val(
+               __isl_keep isl_basic_set *bset,
+               __isl_keep isl_aff *obj);
        enum isl_lp_result isl_set_min(__isl_keep isl_set *set,
                __isl_keep isl_aff *obj, isl_int *opt);
+       __isl_give isl_val *isl_set_min_val(
+               __isl_keep isl_set *set,
+               __isl_keep isl_aff *obj);
        enum isl_lp_result isl_set_max(__isl_keep isl_set *set,
                __isl_keep isl_aff *obj, isl_int *opt);
+       __isl_give isl_val *isl_set_max_val(
+               __isl_keep isl_set *set,
+               __isl_keep isl_aff *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>.
+C<isl_lp_ok>, C<isl_lp_unbounded> or C<isl_lp_empty>, in case of
+an C<isl_lp_result>.  If the result is an C<isl_val> then
+the result is C<NULL> in case of an error, the optimal value in case
+there is one, negative infinity or infinity if the problem is unbounded and
+NaN if the problem is empty.
 
 =item * Parametric optimization
 
@@ -2625,8 +2725,15 @@ dualization algorithms or skip the elimination step.
 
        __isl_give isl_map *isl_map_fixed_power(
                __isl_take isl_map *map, isl_int exp);
+       __isl_give isl_map *isl_map_fixed_power_val(
+               __isl_take isl_map *map,
+               __isl_take isl_val *exp);
        __isl_give isl_union_map *isl_union_map_fixed_power(
                __isl_take isl_union_map *umap, isl_int exp);
+       __isl_give isl_union_map *
+       isl_union_map_fixed_power_val(
+               __isl_take isl_union_map *umap,
+               __isl_take isl_val *exp);
 
 Compute the given power of C<map>, where C<exp> is assumed to be non-zero.
 If the exponent C<exp> is negative, then the -C<exp> th power of the inverse
@@ -3432,6 +3539,12 @@ Operations include
        __isl_give isl_multi_val *isl_multi_val_mod_val(
                __isl_take isl_multi_val *mv,
                __isl_take isl_val *v);
+       __isl_give isl_multi_val *isl_multi_val_scale_val(
+               __isl_take isl_multi_val *mv,
+               __isl_take isl_val *v);
+       __isl_give isl_multi_val *isl_multi_val_scale_multi_val(
+               __isl_take isl_multi_val *mv1,
+               __isl_take isl_multi_val *mv2);
 
 =head2 Vectors
 
@@ -3465,6 +3578,8 @@ The elements can be changed and inspected using the following functions.
                int v);
        __isl_give isl_vec *isl_vec_set_val(
                __isl_take isl_vec *vec, __isl_take isl_val *v);
+       int isl_vec_cmp_element(__isl_keep isl_vec *vec1,
+               __isl_keep isl_vec *vec2, int pos);
        __isl_give isl_vec *isl_vec_fdiv_r(__isl_take isl_vec *vec,
                isl_int m);
 
@@ -3618,10 +3733,17 @@ The expression can be inspected using
                enum isl_dim_type type);
        int isl_aff_get_constant(__isl_keep isl_aff *aff,
                isl_int *v);
+       __isl_give isl_val *isl_aff_get_constant_val(
+               __isl_keep isl_aff *aff);
        int isl_aff_get_coefficient(__isl_keep isl_aff *aff,
                enum isl_dim_type type, int pos, isl_int *v);
+       __isl_give isl_val *isl_aff_get_coefficient_val(
+               __isl_keep isl_aff *aff,
+               enum isl_dim_type type, int pos);
        int isl_aff_get_denominator(__isl_keep isl_aff *aff,
                isl_int *v);
+       __isl_give isl_val *isl_aff_get_denominator_val(
+               __isl_keep isl_aff *aff);
        __isl_give isl_aff *isl_aff_get_div(
                __isl_keep isl_aff *aff, int pos);
 
@@ -3664,12 +3786,18 @@ It can be modified using
                __isl_take isl_aff *aff, isl_int v);
        __isl_give isl_aff *isl_aff_set_constant_si(
                __isl_take isl_aff *aff, int v);
+       __isl_give isl_aff *isl_aff_set_constant_val(
+               __isl_take isl_aff *aff, __isl_take isl_val *v);
        __isl_give isl_aff *isl_aff_set_coefficient(
                __isl_take isl_aff *aff,
                enum isl_dim_type type, int pos, isl_int v);
        __isl_give isl_aff *isl_aff_set_coefficient_si(
                __isl_take isl_aff *aff,
                enum isl_dim_type type, int pos, int v);
+       __isl_give isl_aff *isl_aff_set_coefficient_val(
+               __isl_take isl_aff *aff,
+               enum isl_dim_type type, int pos,
+               __isl_take isl_val *v);
        __isl_give isl_aff *isl_aff_set_denominator(
                __isl_take isl_aff *aff, isl_int v);
 
@@ -3677,6 +3805,8 @@ 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_constant_val(
+               __isl_take isl_aff *aff, __isl_take isl_val *v);
        __isl_give isl_aff *isl_aff_add_constant_num(
                __isl_take isl_aff *aff, isl_int v);
        __isl_give isl_aff *isl_aff_add_constant_num_si(
@@ -3687,6 +3817,10 @@ It can be modified using
        __isl_give isl_aff *isl_aff_add_coefficient_si(
                __isl_take isl_aff *aff,
                enum isl_dim_type type, int pos, int v);
+       __isl_give isl_aff *isl_aff_add_coefficient_val(
+               __isl_take isl_aff *aff,
+               enum isl_dim_type type, int pos,
+               __isl_take isl_val *v);
 
        __isl_give isl_aff *isl_aff_insert_dims(
                __isl_take isl_aff *aff,
@@ -3707,9 +3841,13 @@ It can be modified using
                __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
+Note that C<isl_aff_set_constant>, C<isl_aff_set_constant_si>,
+C<isl_aff_set_coefficient> and C<isl_aff_set_coefficient_si>
 set the I<numerator> of the constant or coefficient, while
-C<add_constant> and C<add_coefficient> add an integer value to
+C<isl_aff_set_constant_val> and C<isl_aff_set_coefficient_val> set
+the constant or coefficient as a whole.
+The C<add_constant> and C<add_coefficient> functions add an integer
+or rational value to
 the possibly rational constant or coefficient.
 The C<add_constant_num> functions add an integer value to
 the numerator.
@@ -3755,18 +3893,32 @@ Operations include
                __isl_take isl_pw_aff *pwaff);
        __isl_give isl_aff *isl_aff_mod(__isl_take isl_aff *aff,
                isl_int mod);
+       __isl_give isl_aff *isl_aff_mod_val(__isl_take isl_aff *aff,
+               __isl_take isl_val *mod);
        __isl_give isl_pw_aff *isl_pw_aff_mod(
                __isl_take isl_pw_aff *pwaff, isl_int mod);
+       __isl_give isl_pw_aff *isl_pw_aff_mod_val(
+               __isl_take isl_pw_aff *pa,
+               __isl_take isl_val *mod);
        __isl_give isl_aff *isl_aff_scale(__isl_take isl_aff *aff,
                isl_int f);
+       __isl_give isl_aff *isl_aff_scale_val(__isl_take isl_aff *aff,
+               __isl_take isl_val *v);
        __isl_give isl_pw_aff *isl_pw_aff_scale(
                __isl_take isl_pw_aff *pwaff, isl_int f);
+       __isl_give isl_pw_aff *isl_pw_aff_scale_val(
+               __isl_take isl_pw_aff *pa, __isl_take isl_val *v);
        __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_aff *isl_aff_scale_down_val(
+               __isl_take isl_aff *aff, __isl_take isl_val *v);
        __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_scale_down_val(
+               __isl_take isl_pw_aff *pa,
+               __isl_take isl_val *f);
 
        __isl_give isl_pw_aff *isl_pw_aff_list_min(
                __isl_take isl_pw_aff_list *list);
@@ -4224,18 +4376,33 @@ C<isl_multi_aff_sub> subtracts the second argument from the first.
        __isl_give isl_multi_aff *isl_multi_aff_scale(
                __isl_take isl_multi_aff *maff,
                isl_int f);
-       __isl_give isl_multi_aff *isl_multi_aff_scale_vec(
+       __isl_give isl_multi_aff *isl_multi_aff_scale_val(
                __isl_take isl_multi_aff *ma,
-               __isl_take isl_vec *v);
-       __isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_vec(
+               __isl_take isl_val *v);
+       __isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_val(
+               __isl_take isl_pw_multi_aff *pma,
+               __isl_take isl_val *v);
+       __isl_give isl_multi_pw_aff *isl_multi_pw_aff_scale_val(
+               __isl_take isl_multi_pw_aff *mpa,
+               __isl_take isl_val *v);
+       __isl_give isl_multi_aff *isl_multi_aff_scale_multi_val(
+               __isl_take isl_multi_aff *ma,
+               __isl_take isl_multi_val *mv);
+       __isl_give isl_pw_multi_aff *
+       isl_pw_multi_aff_scale_multi_val(
                __isl_take isl_pw_multi_aff *pma,
-               __isl_take isl_vec *v);
-       __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_scale_vec(
+               __isl_take isl_multi_val *mv);
+       __isl_give isl_multi_pw_aff *
+       isl_multi_pw_aff_scale_multi_val(
+               __isl_take isl_multi_pw_aff *mpa,
+               __isl_take isl_multi_val *mv);
+       __isl_give isl_union_pw_multi_aff *
+       isl_union_pw_multi_aff_scale_multi_val(
                __isl_take isl_union_pw_multi_aff *upma,
-               __isl_take isl_vec *v);
+               __isl_take isl_multi_val *mv);
 
-C<isl_multi_aff_scale_vec> scales the first elements of C<ma>
-by the corresponding elements of C<v>.
+C<isl_multi_aff_scale_multi_val> scales the elements of C<ma>
+by the corresponding elements of C<mv>.
 
        __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_params(
                __isl_take isl_pw_multi_aff *pma,
@@ -4562,6 +4729,9 @@ on the resulting quasipolynomials
        __isl_give isl_qpolynomial *isl_qpolynomial_rat_cst_on_domain(
                __isl_take isl_space *domain,
                const isl_int n, const isl_int d);
+       __isl_give isl_qpolynomial *isl_qpolynomial_val_on_domain(
+               __isl_take isl_space *domain,
+               __isl_take isl_val *val);
        __isl_give isl_qpolynomial *isl_qpolynomial_var_on_domain(
                __isl_take isl_space *domain,
                enum isl_dim_type type, unsigned pos);
@@ -4656,6 +4826,11 @@ will not have any existentially quantified variables, but that
 the dimensions of the sets may be different for different
 invocations of C<fn>.
 
+The constant term of a quasipolynomial can be extracted using
+
+       __isl_give isl_val *isl_qpolynomial_get_constant_val(
+               __isl_keep isl_qpolynomial *qp);
+
 To iterate over all terms in a quasipolynomial,
 use
 
@@ -4673,6 +4848,8 @@ these functions
                isl_int *n);
        void isl_term_get_den(__isl_keep isl_term *term,
                isl_int *d);
+       __isl_give isl_val *isl_term_get_coefficient_val(
+               __isl_keep isl_term *term);
        int isl_term_get_exp(__isl_keep isl_term *term,
                enum isl_dim_type type, unsigned pos);
        __isl_give isl_aff *isl_term_get_div(
@@ -4709,6 +4886,9 @@ obviously equal, use
 
        __isl_give isl_qpolynomial *isl_qpolynomial_scale(
                __isl_take isl_qpolynomial *qp, isl_int v);
+       __isl_give isl_qpolynomial *isl_qpolynomial_scale_val(
+               __isl_take isl_qpolynomial *qp,
+               __isl_take isl_val *v);
        __isl_give isl_qpolynomial *isl_qpolynomial_neg(
                __isl_take isl_qpolynomial *qp);
        __isl_give isl_qpolynomial *isl_qpolynomial_add(
@@ -4723,6 +4903,14 @@ obviously equal, use
        __isl_give isl_qpolynomial *isl_qpolynomial_pow(
                __isl_take isl_qpolynomial *qp, unsigned exponent);
 
+       __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_fix_val(
+               __isl_take isl_pw_qpolynomial *pwqp,
+               enum isl_dim_type type, unsigned n,
+               __isl_take isl_val *v);
+       __isl_give isl_pw_qpolynomial *
+       isl_pw_qpolynomial_scale_val(
+               __isl_take isl_pw_qpolynomial *pwqp,
+               __isl_take isl_val *v);
        __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add(
                __isl_take isl_pw_qpolynomial *pwqp1,
                __isl_take isl_pw_qpolynomial *pwqp2);
@@ -4740,6 +4928,10 @@ obviously equal, use
        __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_scale_val(
+               __isl_take isl_union_pw_qpolynomial *upwqp,
+               __isl_take isl_val *v);
        __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add(
                __isl_take isl_union_pw_qpolynomial *upwqp1,
                __isl_take isl_union_pw_qpolynomial *upwqp2);
@@ -4945,6 +5137,17 @@ obviously equal, use
 
        __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_scale(
                __isl_take isl_qpolynomial_fold *fold, isl_int v);
+       __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_scale_val(
+               __isl_take isl_qpolynomial_fold *fold,
+               __isl_take isl_val *v);
+       __isl_give isl_pw_qpolynomial_fold *
+       isl_pw_qpolynomial_fold_scale_val(
+               __isl_take isl_pw_qpolynomial_fold *pwf,
+               __isl_take isl_val *v);
+       __isl_give isl_union_pw_qpolynomial_fold *
+       isl_union_pw_qpolynomial_fold_scale_val(
+               __isl_take isl_union_pw_qpolynomial_fold *upwf,
+               __isl_take isl_val *v);
 
        __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_add(
                __isl_take isl_pw_qpolynomial_fold *pwf1,
@@ -5837,10 +6040,13 @@ Return the identifier represented by the AST expression.
        #include <isl/ast.h>
        int isl_ast_expr_get_int(__isl_keep isl_ast_expr *expr,
                isl_int *v);
+       __isl_give isl_val *isl_ast_expr_get_val(
+               __isl_keep isl_ast_expr *expr);
 
 Return the integer represented by the AST expression.
-Note that the integer is returned through the C<v> argument.
-The return value of the function itself indicates whether the
+Note that the integer is returned by C<isl_ast_expr_get_int>
+through the C<v> argument.
+The return value of this function itself indicates whether the
 operation was performed successfully.
 
 =head3 Manipulating and printing the AST
@@ -5863,6 +6069,8 @@ New AST expressions can be created either directly or within
 the context of an C<isl_ast_build>.
 
        #include <isl/ast.h>
+       __isl_give isl_ast_expr *isl_ast_expr_from_val(
+               __isl_take isl_val *v);
        __isl_give isl_ast_expr *isl_ast_expr_from_id(
                __isl_take isl_id *id);
        __isl_give isl_ast_expr *isl_ast_expr_neg(