Given a set and a linear space "lin" of dimension n > 0, * project the linear space from the set, compute the convex hull * and then map the set bac

Binary GCD algorithm due to Josef Stein, 1961 */

Apply "aff" to "mupa". The space of "mupa" is equal to the domain of "aff". * In particular, the spaces have been aligned. * The result is defined

Check for next (non-parameter) variable after "var" (first if var == -1) * that is non-integer and therefore requires a cut and return * the index o

Record the absence of solutions for those values of the parameters * that do not satisfy the given inequality with equality. */

Remove common factor of non-constant terms and denominator. */

Remove common factor of non-constant terms and denominator. */

The total number of elements this buffer represents. Equal to * the product of the extents */

Compute the "opposite" of the (numerator of the) argument of a div * with denominator "d". * * In particular, compute * * -aff + (d - 1) */

Plug in "sub" for the variable at position "pos" in "poly". * * If "sub" is an infinite polynomial and if the variable actually * appears in "poly"

Consider the coefficients at "c" as a row vector and replace * them with their product with "T". "T" is assumed to be a square matrix. */

Replace the variables x in the rows q by x' given by x = M x', * with M the matrix mat. * * If the number of new variables is greater than the orig

Compute the preimage of the domain or range of "umap" under the function * represented by "pma". * In other words, plug in "pma" in the domain or ra

Compute the preimage of the domain or range of "umap" under the function * represented by "upma". * In other words, plug in "upma" in the domain or

Print an affine expression "c" * to "p", with the variable names taken from "space" and * the integer division definitions taken from "div". */

Print the disjuncts of a map (or set). * The names of the variables are taken from "space". * "latex" is set if the constraints should be printed in

Print the if node "node". * If "new_line" is set then the if node should be printed on a new line. * If "force_block" is set, then print out the bod

Print the quasi-polynomial reduction "fold" to "p" in C format, * with the variable names taken from the domain space "space". */

Print "expr" as a subexpression of an "op" operation in C format. * If "left" is set, then "expr" is the left-most operand. */

Recursively perform range propagation on the polynomial "poly" * defined over the basic set "bset" and collect the results in "data". */

Return a set containing those elements in the shared domain * of pwaff1 and pwaff2 where pwaff1 is greater than (or equal) to pwaff2. * * We comput

Drop all floors in "qp", turning each integer division [a/m] into * a rational division a/m. If "down" is set, then the integer division * is repla

Return the rational universe basic set in the given space. */

Read a tuple space from "s" derived from the parameter space "space". * Call "read_el" on each element in the tuples. */

Return "bset" and set *T and *T2 to the identity transformation * on "bset" (provided T and T2 are not NULL). */

Mark "edge" as being of type "type". */

Check if "name" starts with one or more of the prefixes in "prefixes", * starting at *first. If so, advance the pointer beyond the prefixes * and r

Sort divs and remove duplicates. */

Align the parameters of the two spaces if needed and then call * isl_space_join. */

Replace the integer division identified by "div" by the polynomial "s". * The integer division is assumed not to appear in the definition * of any o

Add a specific constraint of bmap (or its opposite) to tab. * The position of the constraint is specified by "c", where * the equalities of bmap are

Return a matrix containing the equalities of the tableau * in constraint form. The tableau is assumed to have * an associated bset that has been ke

Check that we can read an isl_multi_val from "str" without errors. */

Return the effect of inequality "ineq" on the tableau "tab", * after relaxing the constant term of "ineq" by one. */

Perform Floyd-Warshall on the given union relation. * The implementation is very similar to that for non-unions. * The main difference is that it is

Check if fn(map, user) returns true for all maps "map" in umap. */

Update "enforced" such that it only involves constraints that are * also enforced by "graft". */

Update group[k] to the group column k belongs to. * When merging two groups, only the group of the current * group leader is changed. Here we chang

Update the inequalities in "bset" based on the information in "row" * and "tab" and free all arguments (other than "bset"). */

Treat "uset" as a union map. * Internally, isl_union_set is defined to isl_union_map, so in practice, * this function performs a redundant cast. */

Initialize the isl_wraps data structure. * If we want to bound the coefficients of the wrapping constraints, * we set wraps->max to the largest coef

Construct a zero sample of the same dimension as bset. * As a special case, if bset is zero-dimensional, this * function creates a zero-dimensional

Read an integer division from "s" and return it as an isl_pw_aff. * * The integer division can be of the form * * [<affine expression>] * floor(<

Check if any points that are adjacent to "sample" also belong to "bset". * If so, add them to "hull" and return the updated hull. * * Before checki

Check if inequality "ineq" from basic set "i" is or can be relaxed to * become a bound on the whole set. If so, add the (relaxed) inequality * to "

Add a (non-parametric) cut to cut away the non-integral sample * value of the given row. * * If the row is given by * * m r = f + \sum_i a_i y_i

Generate a call expression for the single executed * domain element "map" and put a guard around it based its (simplified) * domain. "executed" is

We assume Gaussian elimination has been performed on the equalities. * The equalities can therefore never conflict. * Adding the equalities is curre