Return the concatenation of the partial schedules of all outer band * nodes of "node" interesected with all outer filters * as an isl_union_map. */

Return the concatenation of the partial schedules of all outer band * nodes of "node" interesected with all outer filters * as an isl_union_pw_multi

Group the domain elements that reach "node" into instances * of a single statement with identifier "group_id". * In particular, group the domain ele

Return a copy of the (explicit) child at position "pos" of "tree" and * free "tree". */

Replace the domain of domain tree root "tree" by "domain". */

Return the extension of the extension tree root. */

Replace the filter of the filter tree root by "filter". */

Create a new domain schedule tree with the given domain and no children. */

Create a new extension schedule tree with the given extension and * no children. * Since the domain of the extension refers to the outer schedule di

Construct a tree with a root node of type "type" and as children * "tree1" and "tree2". * If the root of one (or both) of the input trees is itself

Create a new expansion schedule tree with the given contraction and * expansion and with "tree" as single child. */

Does the root node of "tree" depend on its position in the complete * schedule tree? * Band nodes may be anchored depending on the associated AST bu

Create and return a new leaf schedule tree. */

Remove all (explicit) children from "tree". */

Update the anchored field of "tree" based on whether the root node * itself in anchored and the anchored fields of the children. * * This function

Given two affine expressions "p" of length p_len (including the * denominator and the constant term) and "subs" of length subs_len, * plug in "subs"

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

Does the set tuple have a name? */

Return the minimum (maximum if max is set) of the integer affine * expression "obj" over the points in "set". * * Return infinity or negative infin

Compute the parameter domain of the given set. */

Do "set" and "space" have the same parameters? */

Given a facet "facet" of the convex hull of "set" and a facet "ridge" * of that facet, compute the other facet of the convex hull that contains * th

Return whether the argument is stored in big representation. */

Multiply two isl_ints. */

Can we apply isl_space_uncurry to "space"? * That is, does it have a nested relation in its range? */

Compare the "type" dimensions of two isl_spaces. * * The order is fairly arbitrary. */

Given a space of the form [A -> B] -> C, return the space A -> C. */

Are the two spaces the same, apart from positions and names of parameters? */

Given two map spaces { A -> C } and { B -> D }, construct the space * { [A -> B] -> [C -> D] }. * Given two set spaces { A } and { B }, construct th

Given a space of the form A -> [B -> C], return the space A -> C. */

Replace the parameters of dst by those of src. */

Compute a reduced basis for the set represented by the tableau "tab". * tab->basis, which must be initialized by the calling function to an affine *

Construct a tableau corresponding to the recession cone of "bset". */

Return 1 if "var" can attain values <= -1. * Return 0 otherwise. * * If the variable "var" is supposed to be non-negative (is_nonneg is set), * th

Given a description of the "sink" accesses, the "source" accesses and * a schedule, compute for each instance of a sink access * and for each elemen

Create a new isl_union_access_info with the given sink accesses and * and no other accesses or schedule information. */

Return the access relation of type "type" of "info". */

Replace the definite source accesses of "access" by "must_source". */

Replace the schedule of "access" by "schedule". * Also free the schedule_map in case it was set last. */

Replace the schedule map of "access" by "schedule_map". * Also free the schedule in case it was set last. */

Create a new isl_union_flow object, initialized with empty * dependence relations and sink subsets. */

Given a collection of "sink" and "source" accesses, * compute for each iteration of a sink access * and for each element accessed by that iteration,

Extract the map in "umap" that lives in the given space (ignoring * parameters). */

Intersect "umap" with the parameter domain "set". * * If "set" does not have any constraints, then we can return immediately. */

Intersect each map in "umap" in a space A -> [B -> C] * with the corresponding map in "factor" in the space A -> C and * collect the results. */

Check if the given map is single-valued. * * If the union map consists of a single map, then test it as an isl_map. * Otherwise, check if the union

Intersect each map in "umap" with the result of calling "order" * on the functions is "mupa" that apply to the domain and the range * of the map. *

Compute the preimage of the domain of "umap" under the function * represented by "ma". * In other words, plug in "ma" in the domain of "umap". * Th

Turn the "n" dimensions of type "type", starting at "first" * into existentially quantified variables. * Since the space of an isl_union_map only co

Remove all existentially quantified variables and integer divisions * from "umap" using Fourier-Motzkin elimination. */

Reset the user pointer on all identifiers of parameters and tuples * of the spaces of "umap". */

Return a union piecewise affine expression * that is equal to "aff" on "domain". */

Given f, return floor(f). */

Construct and return a union piecewise multi affine expression * that is equal to the given multi union piecewise affine expression. * * In order t

Reset the user pointer on all identifiers of parameters and tuples * of the spaces of "uset". */

Return the "ceiling" of "v". * That is, return the result of rounding towards +infinity. */

Return a reference to an isl_val representing +infinity. */

Does "v" represent the integer negative one? */

Is "v1" (strictly) less than "v2"? */

Return a reference to an isl_val representing -infinity. */

Extract the element at position "pos" of "vec". */

* Transform the loop level into the first static schedule * dimension after its corresponding dynamic dimension. * * In the example below, the firs

Given a parameter space "space", extend it to a set space * * { type[x] } * * or * * { [isolate[] -> type[x]] } * * depending on whether "isol

Compute the minimum or maximum of the given output dimension * as a function of the parameters and the input dimensions, * but independently of the

Add the tuple represented by the isl_multi_pw_aff "tuple" to "map". * We first create the appropriate space in "map" based on the range * space of t

Compute the positive powers of "map", or an overapproximation. * If the result is exact, then *exact is set to 1. * * If project is set, then we ar

Apply "basic_map_product" to each pair of basic maps in "map1" and "map2" * and collect the results. * The result live in the space obtained by call

Compute a superset of the convex hull of map that is described * by only (translates of) the constraints in the constituents of map. * Handle trivia

Mark the space as being that of a set, by setting the domain tuple * to isl_id_none. */