Lines Matching refs:div
525 return qp ? isl_local_copy(qp->div) : NULL;
547 local = qp->div;
548 qp->div = NULL;
564 if (qp->div == local) {
572 isl_local_free(qp->div);
573 qp->div = local;
622 return qp->div->n_row;
1411 qp->div = isl_mat_alloc(space->ctx, n_div, 1 + 1 + total + n_div);
1412 if (!qp->div)
1505 dup = isl_qpolynomial_alloc(isl_space_copy(qp->dim), qp->div->n_row,
1509 isl_mat_free(dup->div);
1510 dup->div = isl_qpolynomial_get_local(qp);
1511 if (!dup->div)
1541 isl_mat_free(qp->div);
1637 static int cmp_row(__isl_keep isl_mat *div, int i, int j)
1641 li = isl_seq_last_non_zero(div->row[i], div->n_col);
1642 lj = isl_seq_last_non_zero(div->row[j], div->n_col);
1647 return isl_seq_cmp(div->row[i], div->row[j], div->n_col);
1651 isl_mat *div;
1661 return cmp_row(i1->div, i1->row, i2->row);
1678 if (qp->div->n_row <= 1)
1685 array = isl_alloc_array(qp->div->ctx, struct isl_div_sort_info,
1686 qp->div->n_row);
1687 pos = isl_alloc_array(qp->div->ctx, int, qp->div->n_row);
1688 at = isl_alloc_array(qp->div->ctx, int, qp->div->n_row);
1689 len = qp->div->n_col - 2;
1690 reordering = isl_alloc_array(qp->div->ctx, int, len);
1694 for (i = 0; i < qp->div->n_row; ++i) {
1695 array[i].div = qp->div;
1701 qsort(array, qp->div->n_row, sizeof(struct isl_div_sort_info),
1707 for (i = 0; i < qp->div->n_row; ++i) {
1710 qp->div = isl_mat_swap_rows(qp->div, i, pos[array[i].row]);
1720 isl_seq_eq(qp->div->row[i - skip - 1],
1721 qp->div->row[i - skip], qp->div->n_col)) {
1722 qp->div = isl_mat_drop_rows(qp->div, i - skip, 1);
1723 isl_mat_col_add(qp->div, 2 + div_pos + i - skip - 1,
1725 qp->div = isl_mat_drop_cols(qp->div,
1734 if (!qp->poly || !qp->div)
1800 isl_mat *div = NULL;
1809 isl_assert(qp1->div->ctx, qp1->div->n_row >= qp2->div->n_row &&
1810 qp1->div->n_col >= qp2->div->n_col, goto error);
1812 n_div1 = qp1->div->n_row;
1813 n_div2 = qp2->div->n_row;
1814 exp1 = isl_alloc_array(qp1->div->ctx, int, n_div1);
1815 exp2 = isl_alloc_array(qp2->div->ctx, int, n_div2);
1819 div = isl_merge_divs(qp1->div, qp2->div, exp1, exp2);
1820 if (!div)
1823 isl_mat_free(qp1->div);
1824 qp1->div = isl_mat_copy(div);
1825 isl_mat_free(qp2->div);
1826 qp2->div = isl_mat_copy(div);
1828 qp1->poly = expand(qp1->poly, exp1, div->n_col - div->n_row - 2);
1829 qp2->poly = expand(qp2->poly, exp2, div->n_col - div->n_row - 2);
1834 isl_mat_free(div);
1840 isl_mat_free(div);
1857 if (qp1->div->n_row < qp2->div->n_row)
1860 compatible = compatible_divs(qp1->div, qp2->div);
2017 if (qp1->div->n_row < qp2->div->n_row)
2020 compatible = compatible_divs(qp1->div, qp2->div);
2224 if (qp->div->n_row > 0)
2291 aff = isl_vec_alloc(qp->div->ctx, 2 + d);
2328 cmp = isl_local_cmp(qp1->div, qp2->div);
2354 equal = isl_mat_is_equal(qp1->div, qp2->div);
2509 static void normalize_div(__isl_keep isl_qpolynomial *qp, int div)
2511 isl_ctx *ctx = qp->div->ctx;
2512 unsigned total = qp->div->n_col - 2;
2514 isl_seq_gcd(qp->div->row[div] + 2, total, &ctx->normalize_gcd);
2516 ctx->normalize_gcd, qp->div->row[div][0]);
2520 isl_seq_scale_down(qp->div->row[div] + 2, qp->div->row[div] + 2,
2522 isl_int_divexact(qp->div->row[div][0], qp->div->row[div][0],
2524 isl_int_fdiv_q(qp->div->row[div][1], qp->div->row[div][1],
2528 /* Replace the integer division identified by "div" by the polynomial "s".
2533 __isl_take isl_qpolynomial *qp, int div, __isl_take isl_poly *s)
2550 qp->poly = isl_poly_subs(qp->poly, div_pos + div, 1, &s);
2555 reordering = isl_alloc_array(ctx, int, div_pos + qp->div->n_row);
2558 for (i = 0; i < div_pos + div; ++i)
2560 for (i = div_pos + div + 1; i < div_pos + qp->div->n_row; ++i)
2562 qp->div = isl_mat_drop_rows(qp->div, div, 1);
2563 qp->div = isl_mat_drop_cols(qp->div, 2 + div_pos + div, 1);
2567 if (!qp->poly || !qp->div)
2592 for (i = 0; qp && i < qp->div->n_row; ++i) {
2593 if (!isl_int_is_one(qp->div->row[i][0]))
2595 for (j = i + 1; j < qp->div->n_row; ++j) {
2596 if (isl_int_is_zero(qp->div->row[j][2 + div_pos + i]))
2598 isl_seq_combine(qp->div->row[j] + 1,
2599 qp->div->ctx->one, qp->div->row[j] + 1,
2600 qp->div->row[j][2 + div_pos + i],
2601 qp->div->row[i] + 1, 1 + div_pos + i);
2602 isl_int_set_si(qp->div->row[j][2 + div_pos + i], 0);
2605 s = isl_poly_from_affine(qp->dim->ctx, qp->div->row[i] + 1,
2606 qp->div->row[i][0], qp->div->n_col - 1);
2614 /* Reduce the coefficients of div "div" to lie in the interval [0, d-1],
2619 * to adjust the coefficient of x in each later div that depends on the
2620 * current div "div" and also in the affine expressions in the rows of "mat"
2621 * (if they too depend on "div").
2623 static void reduce_div(__isl_keep isl_qpolynomial *qp, int div,
2628 unsigned total = qp->div->n_col - qp->div->n_row - 2;
2631 for (i = 0; i < 1 + total + div; ++i) {
2632 if (isl_int_is_nonneg(qp->div->row[div][1 + i]) &&
2633 isl_int_lt(qp->div->row[div][1 + i], qp->div->row[div][0]))
2635 isl_int_fdiv_q(v, qp->div->row[div][1 + i], qp->div->row[div][0]);
2636 isl_int_fdiv_r(qp->div->row[div][1 + i],
2637 qp->div->row[div][1 + i], qp->div->row[div][0]);
2638 *mat = isl_mat_col_addmul(*mat, i, v, 1 + total + div);
2639 for (j = div + 1; j < qp->div->n_row; ++j) {
2640 if (isl_int_is_zero(qp->div->row[j][2 + total + div]))
2642 isl_int_addmul(qp->div->row[j][1 + i],
2643 v, qp->div->row[j][2 + total + div]);
2650 * denominator. If so, we will invert the div to further reduce the number
2656 static int needs_invert(__isl_keep isl_mat *div, int row)
2661 for (i = div->n_col - 1; i >= 1; --i) {
2662 if (isl_int_is_zero(div->row[row][i]))
2664 isl_int_mul_ui(div->row[row][i], div->row[row][i], 2);
2665 cmp = isl_int_cmp(div->row[row][i], div->row[row][0]);
2666 isl_int_divexact_ui(div->row[row][i], div->row[row][i], 2);
2676 /* Replace div "div" q = [e/d] by -[(-e+(d-1))/d].
2681 static void invert_div(__isl_keep isl_qpolynomial *qp, int div,
2684 unsigned total = qp->div->n_col - qp->div->n_row - 2;
2686 isl_seq_neg(qp->div->row[div] + 1,
2687 qp->div->row[div] + 1, qp->div->n_col - 1);
2688 isl_int_sub_ui(qp->div->row[div][1], qp->div->row[div][1], 1);
2689 isl_int_add(qp->div->row[div][1],
2690 qp->div->row[div][1], qp->div->row[div][0]);
2691 *mat = isl_mat_col_neg(*mat, 1 + total + div);
2692 isl_mat_col_mul(qp->div, 2 + total + div,
2693 qp->div->ctx->negone, 2 + total + div);
2730 for (i = 0; i < qp->div->n_row; ++i) {
2733 if (needs_invert(qp->div, i)) {
2847 for (j = 0; j < qp->div->n_row; ++j) {
2848 if (isl_int_is_zero(qp->div->row[j][2 + i]))
2926 if (qp->div->n_row == 0)
2932 len = qp->div->n_col - 2;
2941 for (i = qp->div->n_row - 1; i >= 0; --i) {
2947 if (isl_int_is_zero(qp->div->row[i][2 + div_pos + j]))
2959 reordering = isl_alloc_array(qp->div->ctx, int, len);
2967 n_div = qp->div->n_row;
2970 qp->div = isl_mat_drop_rows(qp->div, i - skip, 1);
2971 qp->div = isl_mat_drop_cols(qp->div,
2980 if (!qp->poly || !qp->div)
3083 qp->div = isl_mat_drop_cols(qp->div, 2 + first, n);
3084 if (!qp->div)
3143 qp->div = isl_mat_cow(qp->div);
3144 if (!qp->div)
3155 for (k = 0; k < qp->div->n_row; ++k) {
3156 if (isl_int_is_zero(qp->div->row[k][1 + j]))
3158 isl_seq_elim(qp->div->row[k] + 1, eq->eq[i], j, total,
3159 &qp->div->row[k][0]);
3197 if (qp->div->n_row > 0)
3198 eq = isl_basic_set_add_dims(eq, isl_dim_set, qp->div->n_row);
3449 ext = isl_local_extend_point_vec(qp->div, isl_vec_copy(pnt->vec));
3487 isl_die(qp->div->ctx, isl_error_invalid,
3502 qp->div = isl_mat_insert_zero_cols(qp->div, 2 + g_pos, n);
3503 if (!qp->div)
3506 total = qp->div->n_col - 2;
3509 exp = isl_alloc_array(qp->div->ctx, int, total - g_pos);
3720 aff->ls->div->n_row, poly);
3724 isl_mat_free(qp->div);
3725 qp->div = isl_mat_copy(aff->ls->div);
3726 qp->div = isl_mat_cow(qp->div);
3727 if (!qp->div)
3808 isl_assert(qp->dim->ctx, qp->div->n_row == 0, goto error);
3810 isl_assert(qp->dim->ctx, subs[i]->div->n_row == 0, goto error);
3849 if (qp->div->n_row == 0)
3854 space = isl_space_add_dims(space, isl_dim_set, qp->div->n_row);
3986 isl_die(qp->div->ctx, isl_error_invalid,
3997 qp->div->n_row, poly);
4000 isl_mat_free(c->div);
4001 c->div = isl_qpolynomial_get_local(qp);
4002 if (!c->div)
4100 __isl_take isl_mat *div)
4107 if (d < 0 || !div)
4110 n = d + div->n_row;
4119 term->div = div;
4126 isl_mat_free(div);
4149 dup = isl_term_alloc(isl_space_copy(term->dim), isl_mat_copy(term->div));
4182 isl_mat_free(term->div);
4201 case isl_dim_div: return term->div->n_row;
4205 return dim + term->div->n_row;
4290 isl_mat_copy(term->div));
4295 isl_seq_cpy(aff->v->el, term->div->row[pos], aff->v->size);
4412 term->div->n_row, poly);
4415 isl_mat_free(qp->div);
4416 qp->div = isl_mat_copy(term->div);
4417 if (!qp->div)
4453 if (qp->div->n_row) {
4456 exp = isl_alloc_array(qp->div->ctx, int, qp->div->n_row);
4459 for (i = 0; i < qp->div->n_row; ++i)
4466 qp->div = isl_mat_insert_cols(qp->div, 2 + total, extra);
4467 if (!qp->div)
4469 for (i = 0; i < qp->div
4470 isl_seq_clr(qp->div->row[i] + 2 + total, extra);
4619 n_sub += qp->div->n_row;
4628 for (i = 0; i < qp->div->n_row; ++i)
4640 diag = isl_mat_diag(ctx, qp->div->n_row, morph->inv->row[0][0]);
4642 qp->div = isl_mat_product(qp->div, mat);
4644 if (!qp->poly || !qp->div)
4680 r = isl_reordering_extend(r, qp->div->n_row);
4733 /* Create a slice where the integer division "div" has the fixed value "v".
4734 * In particular, if "div" refers to floor(f/m), then create a slice
4744 __isl_keep isl_qpolynomial *qp, int div, isl_int v)
4759 isl_seq_cpy(bset->ineq[k], qp->div->row[div] + 1, 1 + total);
4760 isl_int_submul(bset->ineq[k][0], v, qp->div->row[div][0]);
4765 isl_seq_neg(bset->ineq[k], qp->div->row[div] + 1, 1 + total);
4766 isl_int_addmul(bset->ineq[k][0], v, qp->div->row[div][0]);
4767 isl_int_add(bset->ineq[k][0], bset->ineq[k][0], qp->div->row[div][0]);
4781 /* Create a slice of the domain "set" such that integer division "div"
4786 __isl_take isl_qpolynomial *qp, int div, isl_int v,
4794 slice = set_div_slice(isl_set_get_space(set), qp, div, v);
4801 for (i = div + 1; i < qp->div->n_row; ++i) {
4802 if (isl_int_is_zero(qp->div->row[i][2 + div_pos + div]))
4804 isl_int_addmul(qp->div->row[i][1],
4805 qp->div->row[i][2 + div_pos + div], v);
4806 isl_int_set_si(qp->div->row[i][2 + div_pos + div], 0);
4810 qp = substitute_div(qp, div, cst);
4819 /* Split the domain "set" such that integer division "div"
4824 __isl_take isl_qpolynomial *qp, int div, isl_int min, isl_int max,
4831 if (set_div(set_i, qp_i, div, min, data) < 0)
4864 if (qp->div->n_row == 0) {
4876 for (i = 0; i < qp->div->n_row; ++i) {
4879 if (isl_seq_first_non_zero(qp->div->row[i] + 2 + div_pos,
4880 qp->div->n_row) != -1)
4883 lp_res = isl_set_solve_lp(set, 0, qp->div->row[i] + 1,
4889 isl_int_fdiv_q(min, min, qp->div->row[i][0]);
4891 lp_res = isl_set_solve_lp(set, 1, qp->div->row[i] + 1,
4897 isl_int_fdiv_q(max, max, qp->div->row[i][0]);
4906 if (i < qp->div->n_row) {
5148 if (qp->div->n_row == 0)
5155 for (i = qp->div->n_row - 1; i >= 0; --i) {
5157 isl_int_sub(qp->div->row[i][1],
5158 qp->div->row[i][1], qp->div->row[i][0]);
5159 isl_int_add_ui(qp->div->row[i][1],
5160 qp->div->row[i][1], 1);
5162 s = isl_poly_from_affine(qp->dim->ctx, qp->div->row[i] + 1,
5163 qp->div->row[i][0], qp->div->n_col - 1);
5229 qp->div = isl_mat_cow(qp->div);
5230 if (!qp->div)
5233 v = isl_vec_alloc(qp->div->ctx, qp->div->n_col - 1);
5235 for (i = 0; i < qp->div->n_row; ++i) {
5236 isl_int *row = qp->div->row[i];
5262 for (j = i + 1; j < qp->div->n_row; ++j) {
5263 if (isl_int_is_zero(qp->div->row[j][2 + div_pos + i]))
5265 isl_seq_combine(qp->div->row[j] + 1,
5266 qp->div->ctx->one, qp->div->row[j] + 1,
5267 qp->div->row[j][2 + div_pos + i], v->el,
5272 qp->div->ctx->one, v->size);
5353 if (pwqp->p[i].qp->div->n_row == 0) {
Indexes created Fri Jul 31 00:23:59 UTC 2026