Copy row "s" of "src" to row "d" of "dst", applying the expansion * defined by "exp". */

Return the first position of "status" in the list "con" of length "len". * Return -1 if there is no such entry. */

* Generate an identity schedule for the computation. * * This identity schedule is an identity relation created from the iteration * domain. */

Generate code for a single component, after shifting (if any) * has been applied, in case the schedule was specified as a schedule tree. * In partic

* Get the computation with whom this constant is computed. */

Store the sample value of "var" of "tab" rounded up (if sgn > 0) * or down (if sgn < 0) to the nearest integer in *v. */

Return an inequality that expresses that the "parametric constant" * should be non-negative. * This function is only called when the coefficient of

Store the "parametric constant" of row "row" of tableau "tab" in "line", * i.e., the constant term and the coefficients of all variables that * appe

Return a pointer to the node in "graph" that lives in "space". * If the requested node has been compressed, then "space" * corresponds to the compre

Given a matrix "H" is column echelon form, what is the first * zero column? That is how many initial columns are non-zero? * Start looking at colum

Given a possible flow dependence temp_rel[j] between source j and the sink * at level sink_level, remove those elements for which * there is an iter

Given a dependence relation R from "node" to itself, * construct the set of coefficients of valid constraints for elements * in that dependence rela

Given f, return ceil(f). * If f is an integer expression, then just return f. * Otherwise, let f be the expression * * e/m * * then return * *

Look for equalities among the variables shared by context and aff * and the integer divisions of aff, if any. * The equalities are then used to elim

Exploit the equalities in "eq" to simplify the affine expression * and the expressions of the integer divisions in the local space. */

Eliminate dimensions inner to the current dimension. */

Construct an isl_ast_expr that evaluates the conditions defining "set". * The result is simplified in terms of build->domain. * * If "set" is an (o

Return a copy of the set of generated constraints. */

Return the iterator attached to the internal schedule dimension "pos". */

Given that the dimension at position "pos" takes on values * * f + s a * * with a an integer, return f. */

Return the current schedule, as stored in build->executed, in terms * of the external schedule domain. */

Return a set expressing the stride constraint at the current depth. * * In particular, if the current iterator (i) is known to attain values * * f

Does "build" point to a band node? * That is, are we currently handling a band node inside a schedule tree? */

Replace the set of pending constraints by "guard", which is then * no longer considered as pending. * That is, add "guard" to the generated constrai

Replace build->executed by "executed". */

Replace build->options by "options". */

Create an expression representing the sum of "expr1" and "expr2". */

Create an expression representing the negation of "arg". */

Replace the argument at position "pos" of "expr" by "arg". */

Allocate a graft in "build" based on the list of grafts in "sub_build". * "guard" and "enforced" are the guard and enforced constraints * of the all

Extract a common guard from the grafts in "list" that can be hoisted * out of the current level. If no such guard can be found, then return * a uni

Combine the grafts in the list into a single graft. * Return a list containing this single graft. * If the original list is empty, then return an em

Return the condition expression of the given for node. * * If the for node is degenerate, then the condition is not explicitly * stored in the node

Drop "n" dimensions of type "type" starting at "first". * * In principle, this frees up some extra variables as the number * of columns remains con

Remove all constraints from "bmap" that reference any unknown local * variables (directly or indirectly). * * Dropping all constraints on a local v

Are the "n" "coefficients" starting at "first" of the integer division * expressions at position "pos1" in "bmap1" and "pos2" in "bmap2" equal * to

Return the position of the first local variable that does not * have an explicit representation. * Return the total number of local variables if the

Return the number of inequality constraints in the description of "bmap". * Return -1 on error. */

Check if the given basic map is obviously single-valued. * In particular, for each output dimension, check that there is * an equality that defines

Compute the preimage of the domain or range (depending on "type") * of "bmap" under the function represented by "ma". * In other words, plug in "ma"

Given a basic map "bmap" and an affine combination of the variables "f" * with denominator "denom", set *opt / *opt_denom to the minimal * (or maxim

Sort the divs in "bmap". * * We first make sure divs are placed after divs on which they depend. * Then we perform a simple insertion sort based on

Construct a basic set containing the tuples of coefficients of all * valid affine constraints on the given basic set. */

Compute the parametric vertices and the chamber decomposition * of the parametric polytope defined using the same constraints * as "bset". "bset" i

Return a list of constraints that, when combined, are equivalent * to "bset". The input is required to have only known divs. */

Find an integer point in "bset" that minimizes (or maximizes if max is set) * f (if any). * If sol_p is not NULL then the integer point is returned

Free all the data stored in "carry". */

Prepare for performing the next "operation" in the context. * Return 0 if we are allowed to perform this operation and * return -1 if we should abor

Return a copy of the subset of the sink for which no source could be found. */

Given a matrix "div" representing local variables, * is the variable at position "pos" marked as not having * an explicit representation? * Note th

Does "ls" have an explicit representation for all local variables? */

Compute the affine hull of "map". * * We first compute the affine hull of each basic map separately. * Then we align the divs and recompute the aff