llvm/polly/lib/External/isl/isl_fold.c

/*
 * Copyright 2010      INRIA Saclay
 *
 * Use of this software is governed by the MIT license
 *
 * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
 * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
 * 91893 Orsay, France 
 */

#include <isl_map_private.h>
#include <isl_union_map_private.h>
#include <isl_polynomial_private.h>
#include <isl_point_private.h>
#include <isl_space_private.h>
#include <isl_lp_private.h>
#include <isl_seq.h>
#include <isl_mat_private.h>
#include <isl_val_private.h>
#include <isl_vec_private.h>
#include <isl_config.h>

#undef EL_BASE
#define EL_BASE

#include <isl_list_templ.c>

enum isl_fold isl_fold_type_negate(enum isl_fold type)
{}

/* Construct a new reduction with the given type, domain space and
 * list of polynomials.
 */
static __isl_give isl_qpolynomial_fold *qpolynomial_fold_alloc(
	enum isl_fold type, __isl_take isl_space *space,
	__isl_take isl_qpolynomial_list *list)
{}

isl_ctx *isl_qpolynomial_fold_get_ctx(__isl_keep isl_qpolynomial_fold *fold)
{}

/* Return the domain space of "fold".
 */
static __isl_keep isl_space *isl_qpolynomial_fold_peek_domain_space(
	__isl_keep isl_qpolynomial_fold *fold)
{}

__isl_give isl_space *isl_qpolynomial_fold_get_domain_space(
	__isl_keep isl_qpolynomial_fold *fold)
{}

/* Return the space of the domain of "fold".
 * This may be either a copy or the space itself
 * if there is only one reference to "fold".
 * This allows the space to be modified inplace
 * if both the expression and its space have only a single reference.
 * The caller is not allowed to modify "fold" between this call and
 * a subsequent call to isl_qpolynomial_fold_restore_domain_space.
 * The only exception is that isl_qpolynomial_fold_free can be called instead.
 */
static __isl_give isl_space *isl_qpolynomial_fold_take_domain_space(
	__isl_keep isl_qpolynomial_fold *fold)
{}

/* Set the space of the domain of "fold" to "space",
 * where the space of "fold" may be missing
 * due to a preceding call to isl_qpolynomial_fold_take_domain_space.
 * However, in this case, "fold" only has a single reference and
 * then the call to isl_qpolynomial_fold_cow has no effect.
 */
static
__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_restore_domain_space(
	__isl_keep isl_qpolynomial_fold *fold, __isl_take isl_space *space)
{}

__isl_give isl_space *isl_qpolynomial_fold_get_space(
	__isl_keep isl_qpolynomial_fold *fold)
{}

/* Return the list of polynomials in the reduction "fold".
 */
__isl_keep isl_qpolynomial_list *isl_qpolynomial_fold_peek_list(
	__isl_keep isl_qpolynomial_fold *fold)
{}

/* Return a copy of the list of polynomials in the reduction "fold".
 */
static __isl_give isl_qpolynomial_list *isl_qpolynomial_fold_get_list(
	__isl_keep isl_qpolynomial_fold *fold)
{}

/* Return the list of polynomials of "fold".
 * This may be either a copy or the list itself
 * if there is only one reference to "fold".
 * This allows the list to be modified inplace
 * if both the expression and its list have only a single reference.
 * The caller is not allowed to modify "fold" between this call and
 * a subsequent call to isl_qpolynomial_fold_restore_list.
 * The only exception is that isl_qpolynomial_fold_free can be called instead.
 */
static __isl_give isl_qpolynomial_list *isl_qpolynomial_fold_take_list(
	__isl_keep isl_qpolynomial_fold *fold)
{}

/* Set the space of the list of polynomials of "fold" to "space",
 * where the list of polynomials of "fold" may be missing
 * due to a preceding call to isl_qpolynomial_fold_take_list.
 * However, in this case, "fold" only has a single reference and
 * then the call to isl_qpolynomial_fold_cow has no effect.
 */
static __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_restore_list(
	__isl_keep isl_qpolynomial_fold *fold,
	__isl_take isl_qpolynomial_list *list)
{}

/* isl_qpolynomial_list_map callback that calls
 * isl_qpolynomial_reset_domain_space on "qp".
 */
static __isl_give isl_qpolynomial *reset_domain_space(
	__isl_take isl_qpolynomial *qp, void *user)
{}

/* Replace the domain space of "fold" by "space".
 *
 * Replace the domain space itself and that of all polynomials
 * in the list.
 */
__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_reset_domain_space(
	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_space *space)
{}

/* Reset the space of "fold".  This function is called from isl_pw_templ.c
 * and doesn't know if the space of an element object is represented
 * directly or through its domain.  It therefore passes along both.
 */
__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_reset_space_and_domain(
	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_space *space,
	__isl_take isl_space *domain)
{}

/* Internal data structure for isl_qpolynomial_fold_*_dims
 * representing their arguments.
 */
struct isl_fold_dims_data {};

/* isl_qpolynomial_list_every callback that checks whether "qp"
 * does not involve any dimensions in the given range.
 */
static isl_bool not_involved(__isl_keep isl_qpolynomial *qp, void *user)
{}

/* Does "fold" involve any dimensions in the given range.
 *
 * It involves any of those dimensions if it is not the case
 * that every polynomial in the reduction does not involve
 * any of the dimensions.
 */
static isl_bool isl_qpolynomial_fold_involves_dims(
	__isl_keep isl_qpolynomial_fold *fold,
	enum isl_dim_type type, unsigned first, unsigned n)
{}

/* Internal data structure for isl_qpolynomial_fold_set_dim_name
 * representing its arguments.
 */
struct isl_fold_set_dim_name_data {};

/* isl_qpolynomial_list_map callback for calling
 * isl_qpolynomial_set_dim_name on "qp".
 */
static __isl_give isl_qpolynomial *set_dim_name(__isl_take isl_qpolynomial *qp,
	void *user)
{}

/* Given a dimension type for an isl_qpolynomial_fold,
 * return the corresponding type for the domain.
 */
static enum isl_dim_type domain_type(enum isl_dim_type type)
{}

__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_set_dim_name(
	__isl_take isl_qpolynomial_fold *fold,
	enum isl_dim_type type, unsigned pos, const char *s)
{}

/* isl_qpolynomial_list_map callback for calling
 * isl_qpolynomial_drop_dims on "qp".
 */
static __isl_give isl_qpolynomial *drop_dims(__isl_take isl_qpolynomial *qp,
	void *user)
{}

__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_drop_dims(
	__isl_take isl_qpolynomial_fold *fold,
	enum isl_dim_type type, unsigned first, unsigned n)
{}

/* isl_qpolynomial_list_map callback for calling
 * isl_qpolynomial_insert_dims on "qp".
 */
static __isl_give isl_qpolynomial *insert_dims(__isl_take isl_qpolynomial *qp,
	void *user)
{}

__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_insert_dims(
	__isl_take isl_qpolynomial_fold *fold,
	enum isl_dim_type type, unsigned first, unsigned n)
{}

/* Determine the sign of the constant quasipolynomial "qp".
 *
 * Return
 *	-1 if qp <= 0
 *	 1 if qp >= 0
 *	 0 if unknown
 *
 * For qp == 0, we can return either -1 or 1.  In practice, we return 1.
 * For qp == NaN, the sign is undefined, so we return 0.
 */
static int isl_qpolynomial_cst_sign(__isl_keep isl_qpolynomial *qp)
{}

static int isl_qpolynomial_aff_sign(__isl_keep isl_set *set,
	__isl_keep isl_qpolynomial *qp)
{}

/* Determine, if possible, the sign of the quasipolynomial "qp" on
 * the domain "set".
 *
 * If qp is a constant, then the problem is trivial.
 * If qp is linear, then we check if the minimum of the corresponding
 * affine constraint is non-negative or if the maximum is non-positive.
 *
 * Otherwise, we check if the outermost variable "v" has a lower bound "l"
 * in "set".  If so, we write qp(v,v') as
 *
 *	q(v,v') * (v - l) + r(v')
 *
 * if q(v,v') and r(v') have the same known sign, then the original
 * quasipolynomial has the same sign as well.
 *
 * Return
 *	-1 if qp <= 0
 *	 1 if qp >= 0
 *	 0 if unknown
 */
static int isl_qpolynomial_sign(__isl_keep isl_set *set,
	__isl_keep isl_qpolynomial *qp)
{}

/* Check that "fold1" and "fold2" have the same type.
 */
static isl_stat isl_qpolynomial_fold_check_equal_type(
	__isl_keep isl_qpolynomial_fold *fold1,
	__isl_keep isl_qpolynomial_fold *fold2)
{}

/* Check that "fold1" and "fold2" have the same (domain) space.
 */
static isl_stat isl_qpolynomial_fold_check_equal_space(
	__isl_keep isl_qpolynomial_fold *fold1,
	__isl_keep isl_qpolynomial_fold *fold2)
{}

/* Combine "list1" and "list2" into a single list, eliminating
 * those elements of one list that are already covered by the other
 * list on "set".
 *
 * "better" is the sign that the difference qp1 - qp2 needs to have for qp1
 * to be covered by qp2.
 */
static __isl_give isl_qpolynomial_list *merge_lists(__isl_keep isl_set *set,
	__isl_take isl_qpolynomial_list *list1,
	__isl_take isl_qpolynomial_list *list2, int better)
{}

/* Combine "fold1" and "fold2" into a single reduction, eliminating
 * those elements of one reduction that are already covered by the other
 * reduction on "set".
 *
 * If "fold1" or "fold2" is an empty reduction, then return
 * the other reduction.
 * If "fold1" or "fold2" is a NaN, then return this NaN.
 */
__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_fold_on_domain(
	__isl_keep isl_set *set,
	__isl_take isl_qpolynomial_fold *fold1,
	__isl_take isl_qpolynomial_fold *fold2)
{}

/* isl_qpolynomial_list_map callback for adding "qp2" to "qp".
 */
static __isl_give isl_qpolynomial *add_qpolynomial(
	__isl_take isl_qpolynomial *qp, void *user)
{}

__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_add_qpolynomial(
	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_qpolynomial *qp)
{}

__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_add_on_domain(
	__isl_keep isl_set *dom,
	__isl_take isl_qpolynomial_fold *fold1,
	__isl_take isl_qpolynomial_fold *fold2)
{}

/* isl_qpolynomial_list_map callback for calling
 * isl_qpolynomial_substitute_equalities on "qp" and "eq".
 */
static __isl_give isl_qpolynomial *substitute_equalities(
	__isl_take isl_qpolynomial *qp, void *user)
{}

__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_substitute_equalities(
	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_basic_set *eq)
{}

/* isl_qpolynomial_list_map callback for calling
 * isl_qpolynomial_substitute_equalities on "qp" and "context".
 */
static __isl_give isl_qpolynomial *gist(__isl_take isl_qpolynomial *qp,
	void *user)
{}

__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist(
	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_set *context)
{}

__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist_params(
	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_set *context)
{}

/* Return a zero (i.e., empty) isl_qpolynomial_fold in the given space.
 *
 * This is a helper function for isl_pw_*_as_* that ensures a uniform
 * interface over all piecewise types.
 */
static __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_zero_in_space(
	__isl_take isl_space *space, enum isl_fold type)
{}

#define isl_qpolynomial_fold_involves_nan

#define HAS_TYPE

#undef PW
#define PW
#undef BASE
#define BASE
#undef EL_IS_ZERO
#define EL_IS_ZERO
#undef ZERO
#define ZERO
#undef IS_ZERO
#define IS_ZERO
#undef FIELD
#define FIELD
#undef DEFAULT_IS_ZERO
#define DEFAULT_IS_ZERO

#include <isl_pw_templ.c>
#include <isl_pw_add_disjoint_templ.c>
#include <isl_pw_eval.c>
#include <isl_pw_fix_templ.c>
#include <isl_pw_from_range_templ.c>
#include <isl_pw_insert_dims_templ.c>
#include <isl_pw_lift_templ.c>
#include <isl_pw_morph_templ.c>
#include <isl_pw_move_dims_templ.c>
#include <isl_pw_opt_templ.c>

#undef BASE
#define BASE

#include <isl_union_single.c>
#include <isl_union_eval.c>

/* Construct a new reduction of the given type and space
 * with an empty list of polynomials.
 */
__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_empty(enum isl_fold type,
	__isl_take isl_space *space)
{}

/* Construct a new reduction of the given type and
 * a single given polynomial.
 */
__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_alloc(
	enum isl_fold type, __isl_take isl_qpolynomial *qp)
{}

__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_copy(
	__isl_keep isl_qpolynomial_fold *fold)
{}

__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_dup(
	__isl_keep isl_qpolynomial_fold *fold)
{}

__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_cow(
	__isl_take isl_qpolynomial_fold *fold)
{}

__isl_null isl_qpolynomial_fold *isl_qpolynomial_fold_free(
	__isl_take isl_qpolynomial_fold *fold)
{}

isl_bool isl_qpolynomial_fold_is_empty(__isl_keep isl_qpolynomial_fold *fold)
{}

/* Does "fold" represent max(NaN) or min(NaN)?
 */
isl_bool isl_qpolynomial_fold_is_nan(__isl_keep isl_qpolynomial_fold *fold)
{}

__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_fold(
	__isl_take isl_qpolynomial_fold *fold1,
	__isl_take isl_qpolynomial_fold *fold2)
{}

__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_fold(
	__isl_take isl_pw_qpolynomial_fold *pw1,
	__isl_take isl_pw_qpolynomial_fold *pw2)
{}

__isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_fold_pw_qpolynomial_fold(
	__isl_take isl_union_pw_qpolynomial_fold *u,
	__isl_take isl_pw_qpolynomial_fold *part)
{}

static isl_stat fold_part(__isl_take isl_pw_qpolynomial_fold *part, void *user)
{}

__isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_fold(
	__isl_take isl_union_pw_qpolynomial_fold *u1,
	__isl_take isl_union_pw_qpolynomial_fold *u2)
{}

__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_from_pw_qpolynomial(
	enum isl_fold type, __isl_take isl_pw_qpolynomial *pwqp)
{}

__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_add(
	__isl_take isl_pw_qpolynomial_fold *pwf1,
	__isl_take isl_pw_qpolynomial_fold *pwf2)
{}

/* Compare two quasi-polynomial reductions.
 *
 * Return -1 if "fold1" is "smaller" than "fold2", 1 if "fold1" is "greater"
 * than "fold2" and 0 if they are equal.
 */
int isl_qpolynomial_fold_plain_cmp(__isl_keep isl_qpolynomial_fold *fold1,
	__isl_keep isl_qpolynomial_fold *fold2)
{}

/* Are the lists "list1" and "list2", both consisting of "n" elements
 * obviously equal to each other?
 */
static isl_bool isl_qpolynomial_list_plain_is_equal(unsigned n,
	isl_qpolynomial_list *list1, isl_qpolynomial_list *list2)
{}

/* Wrapper around isl_qpolynomial_plain_cmp for use
 * as a isl_qpolynomial_list_sort callback.
 */
static int qpolynomial_cmp(__isl_keep isl_qpolynomial *a,
	__isl_keep isl_qpolynomial *b, void *user)
{}

isl_bool isl_qpolynomial_fold_plain_is_equal(
	__isl_keep isl_qpolynomial_fold *fold1,
	__isl_keep isl_qpolynomial_fold *fold2)
{}

__isl_give isl_val *isl_qpolynomial_fold_eval(
	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_point *pnt)
{}

size_t isl_pw_qpolynomial_fold_size(__isl_keep isl_pw_qpolynomial_fold *pwf)
{}

__isl_give isl_val *isl_qpolynomial_fold_opt_on_domain(
	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_set *set, int max)
{}

/* Check whether for each quasi-polynomial in "fold2" there is
 * a quasi-polynomial in "fold1" that dominates it on "set".
 */
static isl_bool qpolynomial_fold_covers_on_domain(__isl_keep isl_set *set,
	__isl_keep isl_qpolynomial_fold *fold1,
	__isl_keep isl_qpolynomial_fold *fold2)
{}

/* Check whether "pwf1" dominated "pwf2", i.e., the domain of "pwf1" contains
 * that of "pwf2" and on each cell, the corresponding fold from pwf1 dominates
 * that of pwf2.
 */
isl_bool isl_pw_qpolynomial_fold_covers(
	__isl_keep isl_pw_qpolynomial_fold *pwf1,
	__isl_keep isl_pw_qpolynomial_fold *pwf2)
{}

/* isl_qpolynomial_list_map callback that calls
 * isl_qpolynomial_morph_domain on "qp".
 */
static __isl_give isl_qpolynomial *morph_domain(
	__isl_take isl_qpolynomial *qp, void *user)
{}

__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_morph_domain(
	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_morph *morph)
{}

enum isl_fold isl_qpolynomial_fold_get_type(__isl_keep isl_qpolynomial_fold *fold)
{}

/* Return the type of this piecewise quasipolynomial reduction.
 */
enum isl_fold isl_pw_qpolynomial_fold_get_type(
	__isl_keep isl_pw_qpolynomial_fold *pwf)
{}

enum isl_fold isl_union_pw_qpolynomial_fold_get_type(
	__isl_keep isl_union_pw_qpolynomial_fold *upwf)
{}

/* isl_qpolynomial_list_map callback that calls
 * isl_qpolynomial_lift on "qp".
 */
static __isl_give isl_qpolynomial *lift(__isl_take isl_qpolynomial *qp,
	void *user)
{}

__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_lift(
	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_space *space)
{}

isl_stat isl_qpolynomial_fold_foreach_qpolynomial(
	__isl_keep isl_qpolynomial_fold *fold,
	isl_stat (*fn)(__isl_take isl_qpolynomial *qp, void *user), void *user)
{}

/* Internal data structure for isl_qpolynomial_fold_move_dims
 * representing its arguments.
 */
struct isl_fold_move_dims_data {};

/* isl_qpolynomial_list_map callback for calling
 * isl_qpolynomial_move_dims on "qp".
 */
static __isl_give isl_qpolynomial *move_dims(__isl_take isl_qpolynomial *qp,
	void *user)
{}

__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_move_dims(
	__isl_take isl_qpolynomial_fold *fold,
	enum isl_dim_type dst_type, unsigned dst_pos,
	enum isl_dim_type src_type, unsigned src_pos, unsigned n)
{}

/* Internal data structure for isl_qpolynomial_fold_substitute
 * representing its arguments.
 */
struct isl_fold_substitute {};

/* isl_qpolynomial_list_map callback for calling
 * isl_qpolynomial_substitute on "qp".
 */
static __isl_give isl_qpolynomial *substitute(__isl_take isl_qpolynomial *qp,
	void *user)
{}

/* For each 0 <= i < "n", replace variable "first" + i of type "type"
 * in fold->qp[k] by subs[i].
 */
__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_substitute(
	__isl_take isl_qpolynomial_fold *fold,
	enum isl_dim_type type, unsigned first, unsigned n,
	__isl_keep isl_qpolynomial **subs)
{}

static isl_stat add_pwqp(__isl_take isl_pw_qpolynomial *pwqp, void *user)
{}

__isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_add_union_pw_qpolynomial(
	__isl_take isl_union_pw_qpolynomial_fold *upwf,
	__isl_take isl_union_pw_qpolynomial *upwqp)
{}

static isl_bool join_compatible(__isl_keep isl_space *space1,
	__isl_keep isl_space *space2)
{}

/* Compute the intersection of the range of the map and the domain
 * of the piecewise quasipolynomial reduction and then compute a bound
 * on the associated quasipolynomial reduction over all elements
 * in this intersection.
 *
 * We first introduce some unconstrained dimensions in the
 * piecewise quasipolynomial, intersect the resulting domain
 * with the wrapped map and the compute the sum.
 */
__isl_give isl_pw_qpolynomial_fold *isl_map_apply_pw_qpolynomial_fold(
	__isl_take isl_map *map, __isl_take isl_pw_qpolynomial_fold *pwf,
	isl_bool *tight)
{}

__isl_give isl_pw_qpolynomial_fold *isl_set_apply_pw_qpolynomial_fold(
	__isl_take isl_set *set, __isl_take isl_pw_qpolynomial_fold *pwf,
	isl_bool *tight)
{}

struct isl_apply_fold_data {};

static isl_stat pw_qpolynomial_fold_apply(
	__isl_take isl_pw_qpolynomial_fold *pwf, void *user)
{}

static isl_stat map_apply(__isl_take isl_map *map, void *user)
{}

__isl_give isl_union_pw_qpolynomial_fold *isl_union_map_apply_union_pw_qpolynomial_fold(
	__isl_take isl_union_map *umap,
	__isl_take isl_union_pw_qpolynomial_fold *upwf, isl_bool *tight)
{}

__isl_give isl_union_pw_qpolynomial_fold *isl_union_set_apply_union_pw_qpolynomial_fold(
	__isl_take isl_union_set *uset,
	__isl_take isl_union_pw_qpolynomial_fold *upwf, isl_bool *tight)
{}

/* isl_qpolynomial_list_map callback for calling
 * isl_qpolynomial_realign_domain on "qp".
 */
static __isl_give isl_qpolynomial *realign_domain(
	__isl_take isl_qpolynomial *qp, void *user)
{}

/* Reorder the dimension of "fold" according to the given reordering.
 */
__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_realign_domain(
	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_reordering *r)
{}

/* isl_qpolynomial_list_map callback for calling
 * isl_qpolynomial_mul_isl_int on "qp".
 */
static __isl_give isl_qpolynomial *mul_int(__isl_take isl_qpolynomial *qp,
	void *user)
{}

__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_mul_isl_int(
	__isl_take isl_qpolynomial_fold *fold, isl_int v)
{}

__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_scale(
	__isl_take isl_qpolynomial_fold *fold, isl_int v)
{}

/* isl_qpolynomial_list_map callback for calling
 * isl_qpolynomial_scale_val on "qp".
 */
static __isl_give isl_qpolynomial *scale_val(__isl_take isl_qpolynomial *qp,
	void *user)
{}

/* Multiply "fold" by "v".
 */
__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_scale_val(
	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_val *v)
{}

/* Divide "fold" by "v".
 */
__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_scale_down_val(
	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_val *v)
{}