privately export isl_mat_unimodular_complete

isl_tab.c: add isl_tab_get_sample_value

isl_map_convex_hull: avoid introducing lineality spaces in convex hull of pairs

add two more convex hull test cases

isl_map_convex_hull: remove lineality space if any before computing convex hull

add isl_basic_set_is_universe

add isl_set_get_dim

isl_convex_hull.c: update wrap_facet to the fact we only apply it on polytopes

isl_convex_hull.c: fix typo in comment

isl_coalesce.c: fix typo in comment

isl_tab.c: fix typo in comment

configure.in: set AC_CONFIG_MACRO_DIR

add isl_basic_set_get_dim

isl_basic_map_gist: normalize divs (if any) in context

isl_basic_map_simplify: remove duplicate divs before dropping divs

The equalities on the duplicate but separate divs may
entail additional equalities among the variables that we do
not want to ignore.

add isl_basic_set_div

change calling convention of isl_basic_map_div

isl_map_simplify.c: uset_gist: break early if there are no inequalities

isl_map_simplify.c: uset_gist: break early if intersection is empty

add isl_basic_set_fast_is_empty

update piplib to 1.4.0

isl_tab.c: store number of equalities among the constraints in tableau

Before, we would check the bmap to figure out how many equalities we
had added, but there was at least one instance where we didn't actually
store the equalities in the tableau, leading to problems if any additional
equalities would be found in the tableau.

isl_mat_extend: properly extend matrices with reordered rows

isl_map_gist: handle some special cases

add isl_map_universe

add isl_basic_map_fast_is_empty

isl_basic_map_gist: replace by new version based on tableaus

The new version should be a little bit more efficient because
it only constructs a single tableau.

More importantly, the new version keeps better track of the original
constraints and never introduces an inequality constraint in the result
that did not appear in the input.
This is especially important in the presence of divs.
Throught variable compression, the original version would sometimes
translate constraints that did not involve any divs into constraints
that did involve divs.

isl_map_simplify.c: compute_elimination_index: don't assume equalities are in order

add isl_map_implicit_equalities

add isl_basic_set_free_equality

isl_map_convex_hull: mark result as not having any implicit equalities

convex_hull: coalesce set first

add isl_set_coalesce

isl_input_omega.c: basic_map_read: accept "+" in constraints

add isl_basic_set_alloc_div

add isl_set_align_divs

uset_affine_hull: ignore directions in affine hull of recession cone

isl_basic_map_implicit_equalities: perform Gaussian elimination on result

isl_affine_hull.c: outside_point: check for obvious candidate first

privately export isl_basic_set_contains

isl_ctx: add negone

isl_vec_dump: handle NULL vec

isl_affine_hull.c: extract uset_affine_hull

isl_mat_transpose: handle non-rectangular matrices

isl_map_simple_hull: compute affine hull before aligning divs

Computing the affine hull may change the internal representation.
In particular, it may simplify div constraints that are added
during the alignment to constraints that did not appear in the
original set and we do not want to introduce such constraints
in the simple hull.

isl_map_simple_hull: mark result as not having any implicit equalities

add isl_set_bounded_simple_hull

isl_map_affine_hull: detect equalities of integer affine hull before cowing

isl_basic_map_dup: copy flags of original to duplicate

Before, the copied flags would get removed by the subsequent dup_constraints.
Some other code depended on isl_basic_map_cow clearing all flags and
failed to clear some flags.

isl_basic_map_extend_dim: move responsibility of cow'ing to the caller

Some callers, notably isl_basic_map_detect_equalities, want to
extend the basic map to add equalities that are implicit to the
basic map.  These equalities should be added to all copies,
so we definitely do not want to cow in such cases.

isl_basic_map_extend_dim: only extend constraint matrix if needed

isl_solve_lp: use tableaus instead of calling piplib (by default)

isl_solve_lp: accept affine object function instead of linear function

isl_map_simple_hull: use hash tables and tableaus

isl_convex_hull.c: extract out uset_simple_hull

isl_convex_hull.c: extend: avoid wrapping around already known ridges

isl_convex_hull.c: introduce proto_hull based on obvious facet constraints

proto_hull looks for for obvious facet constraints.
If any such constraints can be found, then the calling function
no longer needs to call initial_hull.

isl_convex_hull.c: move initial hull construction into separate function

isl_convex_hull.c: move computation of bounds into uset_convex_hull_wrap

isl_map_convex_hull: check for boundedness using recession cone

isl_basic_map_convex_hull: use tableau to detect redundant constraints

isl_affine_hull.c: use tableau to detect implicit equalities

isl_tab.c: don't detect equalities while setting up tableau

The original description of the algorithm tries to detect equalities
as soon as possible.  In our application it may be best to wait
until all constraints are available.  In some case we are not
even interested in the equalities.

add internal representation of LP tableaus

add isl_mat_extend

add isl_set_dim

privately export isl_basic_{set,map}_normalize_constraints

add isl_basic_set_extend_dim

isl_basic_map_eliminate_vars: clear divs first

isl_basic_map_eliminate_vars: remove all dependent vars first

add isl_hash_table_alloc and isl_hash_table_free

isl_hash_table_init: take minimal size instead of number of bits needed

isl_{basic_,}set_preimage: drop ctx argument

isl_basic_map_intersect: reuse sample value of either basic map if possible

If the sample value stored in one of the two basic maps is an element
of both basic maps, then we can keep it as sample value for the intersection.

add isl_int_ge

isl_basic_set_has_defining_inequalities: fix typo

isl_constraint_div: perform required reference increase on basic map

Both divs and constraints own their contained basic maps, so we
can't just steal the basic map from the constraint.

isl_basic_map: put inequalities before equalities

When confronted with a list of inequalities that need to be
turned into equalities, we want to handle the inequalities
in the same order in which we handle inequalities that can
be removed.  Eventually, we would want to do these at the
same time.

add isl_seq_normalize

isl_ctx.h: make FL_ISSET return a boolean value

rename F_ and FL_ macros to ISL_F_ and ISL_FL_ to avoid name clashes

add isl_mat_swap_cols

isl_mat_dump: also indent NULL mat

add isl_calloc_type

isl_map_convex_hull: normalize map first

isl_set_preimage: clear ISL_SET_NORMALIZED flag

add isl_basic_map_detect_equalities

add isl_map_remove

export isl_basic_map_is_equal

add isl_basic_map_remove

add isl_dim_range

add isl_map_product

add isl_basic_map_add_constraint

add isl_dim_add

isl_map_piplib.c: isl_map_from_quast: properly keep track of dimension names

change calling convention of isl_basic_map_{equal,less_at,more_at}

add isl_map_copy_basic_map and isl_map_drop_basic_map

add isl_map_from_range

add isl_map_fast_is_empty

change calling convention of isl_map_empty and add isl_map_empty_like