static int increment_range(struct isl_scan_callback *cb, isl_int min, isl_int max)
{
struct isl_counter *cnt = (struct isl_counter *)cb;
isl_int_add(cnt->count, cnt->count, max);
isl_int_sub(cnt->count, cnt->count, min);
isl_int_add_ui(cnt->count, cnt->count, 1);
if (isl_int_is_zero(cnt->max) || isl_int_lt(cnt->count, cnt->max))
return 0;
isl_int_set(cnt->count, cnt->max);
return -1;
}
/* Check if dimension dim belongs to a residue class
* i_dim \equiv r mod m
* with m != 1 and if so return m in *modulo and r in *residue.
* As a special case, when i_dim has a fixed value v, then
* *modulo is set to 0 and *residue to v.
*
* If i_dim does not belong to such a residue class, then *modulo
* is set to 1 and *residue is set to 0.
*/
int isl_set_dim_residue_class(struct isl_set *set,
int pos, isl_int *modulo, isl_int *residue)
{
isl_int m;
isl_int r;
int i;
if (!set || !modulo || !residue)
return -1;
if (set->n == 0) {
isl_int_set_si(*modulo, 0);
isl_int_set_si(*residue, 0);
return 0;
}
if (isl_basic_set_dim_residue_class(set->p[0], pos, modulo, residue)<0)
return -1;
if (set->n == 1)
return 0;
if (isl_int_is_one(*modulo))
return 0;
isl_int_init(m);
isl_int_init(r);
for (i = 1; i < set->n; ++i) {
if (isl_basic_set_dim_residue_class(set->p[i], pos, &m, &r) < 0)
goto error;
isl_int_gcd(*modulo, *modulo, m);
isl_int_sub(m, *residue, r);
isl_int_gcd(*modulo, *modulo, m);
if (!isl_int_is_zero(*modulo))
isl_int_fdiv_r(*residue, *residue, *modulo);
if (isl_int_is_one(*modulo))
break;
}
isl_int_clear(m);
isl_int_clear(r);
return 0;
error:
isl_int_clear(m);
isl_int_clear(r);
return -1;
}
/* Make first row entries in column col of bset1 identical to
* those of bset2, using only these entries of the two matrices.
* Let t be the last row with different entries.
* For each row i < t, we set
* A[i] = (A[t][col]-B[t][col]) * A[i] + (B[i][col]-A[i][col) * A[t]
* B[i] = (A[t][col]-B[t][col]) * B[i] + (B[i][col]-A[i][col) * B[t]
* so that
* A[i][col] = B[i][col] = old(A[t][col]*B[i][col]-A[i][col]*B[t][col])
*/
static int transform_column(
struct isl_basic_set *bset1, struct isl_basic_set *bset2,
unsigned row, unsigned col)
{
int i, t;
isl_int a, b, g;
unsigned total;
for (t = row-1; t >= 0; --t)
if (isl_int_ne(bset1->eq[t][col], bset2->eq[t][col]))
break;
if (t < 0)
return 0;
total = 1 + isl_basic_set_n_dim(bset1);
isl_int_init(a);
isl_int_init(b);
isl_int_init(g);
isl_int_sub(b, bset1->eq[t][col], bset2->eq[t][col]);
for (i = 0; i < t; ++i) {
isl_int_sub(a, bset2->eq[i][col], bset1->eq[i][col]);
isl_int_gcd(g, a, b);
isl_int_divexact(a, a, g);
isl_int_divexact(g, b, g);
isl_seq_combine(bset1->eq[i], g, bset1->eq[i], a, bset1->eq[t],
total);
isl_seq_combine(bset2->eq[i], g, bset2->eq[i], a, bset2->eq[t],
total);
}
isl_int_clear(a);
isl_int_clear(b);
isl_int_clear(g);
delete_row(bset1, t);
delete_row(bset2, t);
return 1;
}
