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

isl_map_intersect_{domain,range}: allow intersection with parameter constraints

isl_map_intersect: allow intersection with pure parameter constraints

isl_basic_map_affine_hull: fix search for integer points

Before, we would mistakenly only look for integer points
in adjacent hyperplanes.  This would be sufficient if we
were looking instead for rational points, although we could
then obtain an over-approximation of the integer affine hull.

isl_basic_map_overlying_set: don't add div constraints for unknown divs

Constructing div constraints as if the div were known, results in
unsatisfiable constraints.
Perhaps isl_basic_map_overlying_set shouldn't get called with a model
with unknown divs, but we currently allow it.

isl_dim.c: update n_name (only) when changing names

fix serious error in isl_mat_parameter_compression

The old version would sometimes remove valid solutions.
Since isl_mat_parameter_compression is used during simplification
on practically any set containing existentially quantified variables
involved in equalities, any such set could get corrupted.

export isl_basic_map_intersect_range

add isl_basic_map_floordiv

add isl_basic_map_fast_is_fixed

add isl_basic_map_neg

add isl_basic_map_sum

add isl_map_fix_si, a generalization of isl_basic_map_fix_input_si

isl_map_simplify.c: remove_duplicate_divs: remove divs from last to first

isl_basic_map_gauss: be careful not to introduce circular div definitions

add functions for setting isl_divs

isl_map_from_quast: don't throw away any bottom leaves

Before, we would perform an "optimization" that would simply
discard any leaves with a bottom when we hadn't seen any leaves
with a solution yet, the intention being that we don't need
to collect bottom leaves if there are no solutions.
However, the bottom leaves may precede solution leaves and
then we would erroneously discard them.

isl_map_simplify.c: normalize_divs: fix use of variable compression

When there is a div that depends on another div, then we need
to be careful not to look for the other div in the variable
compression matrix.

isl_mat_variable_compression: fix use after free