Check if info->bmap contains the basic map represented * by the tableau "tab". * For each equality, we check both the constraint itself * (as an in

Insert a div specified by "div" to the tableau "tab" at position "pos" and * return isl_bool_true if the div is obviously non-negative. */

Convert the result of a function that returns an isl_lp_result * to an isl_val. The numerator of "v" is set to the optimal value * if lp_res is isl

Special case for computing the convex hull of a one dimensional set. * We simply collect the lower and upper bounds of each basic set * and the bigg

Compute the convex hull of a pair of basic sets without any parameters or * integer divisions, where the convex hull is known to be pointed, * but t

Assuming that "tab" contains the equality constraints and * the initial inequality constraints of "bmap", copy the remaining * inequality constraint

Given a dependence relation "old_map" between a must-source and the sink, * return a subset of the dependences, augmented with instances * of the so

Return the number of (halves of) equality constraints in the description * of the basic map represented by "info" that * have position "status" with

Fill in the "ci" data structure for holding the inequalities of "bmap". */

Given a non-negative variable "var", temporarily add a new non-negative * variable that is the opposite of "var", ensuring that "var" can only attain

Does the domain of "umap" intersect "uset"? */

Downsample with a 1 3 3 1 filter

Drop constraints from "map" by applying "drop" to each basic map. */

Drop the last constraint added to "tab" in position "r". * The constraint is expected to have remained in a row. */

Drop all prefixes starting at "first". */

* domain_constraints_set: a set defined on the space of the domain of the * schedule. * * range_constraints_set: a set defined on the space of the

Does either of "pa1" or "pa2" involve any NaN2? */

Assumes divs have been ordered if keep_divs is set. */

Eliminate divs based on equalities */

Print the end of a compound statement. */

Compute the position of the equalities of basic map "bmap_i" * with respect to the basic map represented by "tab_j". * The resulting array has twice

Are "ma1" and "ma2" equal to each other on "dom"? * * Combine "ma1" and "ma2" with "dom" and check if the results are the same. * "dom" may have ex

Given a dimension specification Z^{n+1} -> Z^{n+1} and a parameter "param", * construct a map that equates the parameter to the difference * in the

Construct a basic map where the given dimensions are equal to each other. */

Return the exact lower bound (or upper bound if "upper" is set) * of "domain" as a piecewise affine expression. * * If we are computing a lower bou

Extend an initial (under-)approximation of the affine hull of basic * set represented by the tableau "tab" * by looking for points that do not satis

Extend the domain of the current entry of "data", which is assumed * to contain a single subpiece, with "set". If "replace" is set, * then also rep

Extend length of ids array to the total number of dimensions. */

Can the list of subpieces in the last piece of "data" be extended with * "set" and "aff" based on "test"? * In particular, is it the case for each e

Return the argument of the integer division at position "pos" in "ls". * All local variables in "ls" are known to have a (complete) explicit * repre

Extract the inequalities of "bset" as an isl_mat. */

Given a basic map where each output dimension is defined * in terms of the parameters and input dimensions using an equality, * extract an isl_multi

Extract a mapping key from the token "tok". * Return KEY_ERROR on error, i.e., if "tok" does not * correspond to any known key. */

Extract the loop AST generation type for the band member * at position "pos" from "options". * If "isolate" is set, then extract the loop types for

Given that data->v * div_i in data->aff is of the form * * f * d * floor(div/d) * * with div nonnegative on data->build, rewrite it as * * f * (

Check if "aff" involves any (implicit) modulo computations. * If so, remove them from aff and add expressions corresponding * to those modulo comput

Extract an isl_multi_pw_aff with domain space "dom_space" * from a tuple "tuple" read by read_tuple. * * Note that the function read_tuple accepts

Collect the nodes contained in the grafts in "list" in a node list. */

Return the transformation on "node" expressed by the current (and only) * band of "merge_graph" applied to the clusters in "c". * * First find the

Given that data->v * div_i in data->aff is of the form * * f * d * floor(div/d) (1) * * check if div is non-negative on data->build and, if so

If the ast_build_exploit_nested_bounds option is set, then return * the constraints enforced by all elements in "list". * Otherwise, return the univ

Given that data->v * div_i in data->aff is equal to * * f * (term - (arg mod d)) * * with data->d * f = data->v, add * * f * term * * to data-

Compute the dual of "bset" by applying Farkas' lemma. * As explained above, we add an extra dimension to represent * the coefficient of the constant

Extract the final schedule row as a map with the iteration domain * of "node" as domain. */

Check if integer division "div" of "dom" also occurs in "bmap". * If so, return its position within the divs. * If not, return -1. */

Compute the lexicographic minimum of the set represented by the main * tableau "tab" within the context "sol->context_tab". * On entry the sample va

Given a basic set "bset" that only involves parameters and existentially * quantified variables, return the index of the first equality * that only

The core of the Floyd-Warshall algorithm. * Updates the given n x x matrix of relations in place. * * The algorithm iterates over all vertices. In

Call "fn" for each type of operation represented in the "macros" * bit vector. */

Call "fn" on each iteration of the current dimension of "domain". * If "init" is not NULL, then it is called with the number of * iterations before

* Construct a function with the name \p name. */

Generate an AST that visits the elements in the range of "executed" * in the relative order specified by the corresponding domain element(s). * * "

Generate an AST that visits the elements in the range of data->executed * in the relative order specified by the corresponding domain element(s) * f

Generate an AST after having handled the complete schedule * of this call to the code generator or the complete band * if we are generating an AST f

Return an isl_id called "c%d", with "%d" set to "i". * If an isl_id with such a name already appears among the parameters * in build->domain, then a

Generate code for a single component, after shifting (if any) * has been applied. * * The component inverse schedule is specified as the "map" fiel

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

Check if variable "var" of "tab" can only attain a single (integer) * value, and, if so, add an equality constraint to fix the variable * to this si

Return the index of a div that corresponds to "div". * We first check if we already have such a div and if not, we create one. */

Get the number of integer divisions in the expression for the iterator * value at the first slice in the unrolling based on lower bound "lower", * t

* Return the Halide statement that represents the whole * function. * The Halide statement is generated by the code generator. * This function s

TODO: get_live_out_computations() does not consider the case of "maybe" live-out (non-affine control flow, ...).

Return the number of coincident dimensions in the current band of "graph", * where the nodes of "graph" are assumed to be scheduled by a single band.

Return a non-parametric set in the compressed space of "node" that is * bounded by the size in each direction * * { [x] : -S_i <= x_i <= S_i } *

For each graft in "list", replace its guard with the gist with * respect to "context". */