reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

  326 		isl_die(bset->ctx, isl_error_invalid,
  329 		isl_die(bset->ctx, isl_error_invalid,
  337 		tab->basis = isl_mat_identity(bset->ctx, 1 + tab->n_var);
  341 		eq = isl_mat_sub_alloc6(bset->ctx, bset->eq, 0, bset->n_eq,

  225 	isl_assert(bset1->ctx, row == bset1->n_eq, goto error);
  308 	isl_assert(bset->ctx, bset->n_div == 0, goto error);
  721 	M = isl_mat_sub_alloc6(bset->ctx, cone->eq, 0, cone->n_eq, 1, total);

   74 	isl_assert(vertex->ctx, !isl_int_is_zero(denom), goto error);
  490 	len = isl_alloc_array(bset->ctx, int, nvar);
  540 	if (bset->ctx->opt->bernstein_recurse & ISL_BERNSTEIN_FACTORS)
  543 	    (bset->ctx->opt->bernstein_recurse & ISL_BERNSTEIN_INTERVALS))

   35 	if (bset->ctx->opt->bound == ISL_BOUND_RANGE)

   69 	int *eq = isl_calloc_array(bmap_i->ctx, int, 2 * bmap_i->n_eq);
  100 	int *ineq = isl_calloc_array(bmap_i->ctx, int, bmap_i->n_ineq);

  226 	isl_assert(bmap->ctx, ISL_F_ISSET(bmap, ISL_BASIC_MAP_FINAL),
 1196 	isl_assert(bset->ctx, pos < isl_basic_set_dim(bset, type),
 1198 	isl_assert(bset->ctx, type == isl_dim_param || type == isl_dim_set,

  172 	isl_assert(bset->ctx, isl_basic_set_n_param(bset) == 0, goto error);
  173 	isl_assert(bset->ctx, bset->n_div == 0, goto error);
  777 	hull = isl_basic_set_alloc(bset1->ctx, 0, 2 + 3 * dim, 0,
 1025 	dim = isl_space_set_alloc(bset1->ctx, 0, n);
 1114 	dir = isl_vec_alloc(bset1->ctx, 1 + d);
 1125 				bset1->ctx->one, dir->block.data,
 1132 				bset1->ctx->one, dir->block.data,
 1135 	isl_seq_normalize(bset1->ctx, dir->el, dir->size);
 1300 	if (bset1->ctx->opt->convex == ISL_CONVEX_HULL_FM)
 1618 	constraints = isl_calloc_array(hull->ctx, struct max_constraint,
 1622 	table = isl_alloc_type(hull->ctx, struct isl_hash_table);
 1623 	if (isl_hash_table_init(hull->ctx, table, min_constraints))
 1628 		constraints[i].c = isl_mat_sub_alloc6(hull->ctx,
 1638 		entry = isl_hash_table_find(hull->ctx, table, c_hash,
 1642 		isl_assert(hull->ctx, !entry->data, goto error);
 1655 				update_constraint(hull->ctx, table,
 1661 			update_constraint(hull->ctx, table, ineq, total, n,
 1685 			if (!has_constraint(hull->ctx, table, ineq, total, n))
 2027 			if (hash_ineq(bset->ctx, table, bset->eq[i], dim) < 0)
 2032 		if (hash_ineq(bset->ctx, table, bset->ineq[i], dim) < 0)
 2184 	entry = isl_hash_table_find(hull->ctx, data->hull_table, c_hash,
 2190 		entry = isl_hash_table_find(hull->ctx, data->p[j].table,
 2219 		entry = isl_hash_table_find(hull->ctx, data->p[j].table,
 2234 	entry = isl_hash_table_find(hull->ctx, data->hull_table, c_hash,

  196 	res = isl_dim_map_alloc(bmap->ctx, dim_map->len - 1 + bmap->n_div);

  675 	isl_assert(bset->ctx, isl_basic_set_n_param(bset) == 0, goto error);
  676 	isl_assert(bset->ctx, bset->n_div == 0, goto error);
  678 	isl_assert(bset->ctx, bset->n_eq <= dim, goto error);
  682 	B = isl_mat_sub_alloc6(bset->ctx, bset->eq, 0, bset->n_eq, 0, 1 + dim);
  714 	isl_assert(bset->ctx, isl_basic_set_n_param(bset) == 0, goto error);

   31 		len = isl_alloc_array(morph->dom->ctx, int, n_group);
   36 	f = isl_alloc_type(morph->dom->ctx, struct isl_factorizer);
  100 	id = isl_mat_identity(bset->ctx, ovar);
  268 	isl_assert(bset->ctx, isl_basic_set_dim(bset, isl_dim_div) == 0,
  275 	H = isl_mat_alloc(bset->ctx, bset->n_eq + bset->n_ineq, nvar);
  278 	isl_mat_sub_copy(bset->ctx, H->row, bset->eq, bset->n_eq,
  280 	isl_mat_sub_copy(bset->ctx, H->row + bset->n_eq, bset->ineq, bset->n_ineq,
  309 				isl_die(bset->ctx, isl_error_internal,

  306 		isl_die(bset->ctx, isl_error_invalid,
  331 		isl_die(bset->ctx, isl_error_invalid,

   92 	res = isl_basic_set_solve_lp(unit_box, 0, f, bset->ctx->one,
  215 	res = isl_basic_set_solve_lp(bset, 0, f, bset->ctx->one,
  273 	v = isl_vec_alloc(bset->ctx, 1 + dim);
  316 	isl_assert(bset->ctx, isl_basic_set_n_param(bset) == 0,

  333 	return bmap ? bmap->ctx : NULL;
  338 	return bset ? bset->ctx : NULL;
 1114 	bmap->ctx = ctx;
 1322 	isl_ctx_deref(bmap->ctx);
 1324 	isl_blk_free(bmap->ctx, bmap->block2);
 1326 	isl_blk_free(bmap->ctx, bmap->block);
 1428 	ctx = bmap->ctx;
 1465 	isl_assert(bmap->ctx, n <= bmap->n_eq, return -1);
 1480 	isl_assert(bmap->ctx, pos < bmap->n_eq, return -1);
 1526 	ctx = bmap->ctx;
 1547 	isl_assert(bmap->ctx, n <= bmap->n_ineq, return -1);
 1562 	isl_assert(bmap->ctx, pos < bmap->n_ineq, return -1);
 1631 	isl_assert(bmap->ctx, bmap->n_div < bmap->extra, return -1);
 1701 	isl_assert(bmap->ctx, n <= bmap->n_div, return isl_stat_error);
 1834 	isl_assert(base->ctx, base->dim->nparam <= dim->nparam, goto error);
 1835 	isl_assert(base->ctx, base->dim->n_in <= dim->n_in, goto error);
 1836 	isl_assert(base->ctx, base->dim->n_out <= dim->n_out, goto error);
 1890 	dim = isl_space_alloc(base->ctx, nparam, n_in, n_out);
 1995 	isl_assert(bmap->ctx,
 2005 	blk = isl_blk_alloc(bmap->ctx, n1 + n2);
 2021 	isl_blk_free(bmap->ctx, blk);
 2200 	div = isl_alloc_array(bmap->ctx, isl_int *, n);
 2250 	isl_assert(bmap->ctx, first + n <= dim, goto error);
 2356 	isl_assert(bmap->ctx, div < bmap->n_div, goto error);
 3348 	isl_assert(bmap->ctx, pos < bmap->n_ineq, return -1);
 3483 		isl_assert(bset->ctx,
 3610 		isl_assert(bmap1->ctx,
 3896 	dim_map = isl_dim_map_alloc(bmap->ctx, total);
 3949 	isl_assert(bset->ctx, type != isl_dim_in, goto error);
 4048 	isl_assert(bmap->ctx, dst_type != src_type, goto error);
 4068 	dim_map = isl_dim_map_alloc(bmap->ctx, total);
 4203 	dim_map = isl_dim_map_alloc(bmap->ctx, total);
 4252 	bmap->block2 = isl_blk_extend(bmap->ctx, bmap->block2,
 4256 	new_div = isl_alloc_array(bmap->ctx, isl_int *, bmap->extra + n);
 4507 	dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
 4508 	dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
 4540 	isl_assert(bset->ctx, isl_basic_map_compatible_domain(bmap, bset),
 4584 	isl_assert(bmap1->ctx, isl_space_is_equal(bmap1->dim, bmap2->dim),
 4592 	dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
 4593 	dim_map2 = isl_dim_map_alloc(bmap2->ctx, total);
 4752 	dim_map = isl_dim_map_alloc(bmap->ctx, total);
 5408 	ctx = bset->ctx;
 7089 	isl_assert(bset->ctx, mat->n_row == 1 + nparam, goto error);
 7312 	eq = isl_mat_sub_alloc6(bset->ctx, bset->eq, i, bset->n_eq - i,
 7473 	dim = isl_space_set_alloc(bmap->ctx,
 8078 	isl_assert(bmap->ctx, isl_space_tuple_is_equal(bmap->dim, isl_dim_in,
 8150 		isl_die(bmap->ctx, isl_error_invalid,
 8794 	isl_assert(bmap1->ctx, isl_space_is_equal(bmap1->dim, bmap2->dim), goto error);
 8959 	isl_assert(dst->ctx, div <= dst->n_div, return -1);
 9207 	ctx = bmap1->ctx;
 9976 	dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
 9977 	dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
10037 	dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
10038 	dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
10089 	dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
10090 	dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
10835 	bound = isl_vec_alloc(bset->ctx, 1 + isl_basic_set_total_dim(bset));
10885 	isl_assert(bset->ctx, first + n <= isl_basic_set_dim(bset, type),
11943 	mat = isl_mat_alloc(bmap->ctx, bmap->n_eq,
11972 	mat = isl_mat_alloc(bmap->ctx, bmap->n_ineq,
12124 		isl_die(bmap->ctx, isl_error_invalid,
12210 		isl_die(bmap->ctx, isl_error_invalid,
12288 		isl_die(bmap->ctx, isl_error_invalid,

  240 	isl_ctx *ctx = bmap->ctx;
  306 		isl_seq_normalize(bmap->ctx, bmap->eq[k], 1 + total);
  315 		isl_seq_normalize(bmap->ctx, bmap->ineq[k], 1 + total);
  437 	ctx = bmap->ctx;
  764 	ctx = bmap->ctx;
  921 		B = isl_mat_sub_alloc6(bmap->ctx, bmap->eq, div_eq,
  934 	d = isl_vec_alloc(bmap->ctx, div_eq);
  942 	B = isl_mat_sub_alloc6(bmap->ctx, bmap->eq, 0, div_eq, 0, 1 + total);
  966 	pos = isl_alloc_array(bmap->ctx, int, T->n_row);
 1656 		isl_die(bmap->ctx, isl_error_invalid,
 1836 	elim = isl_alloc_array(bset->ctx, int, isl_basic_set_n_dim(bset));
 2622 	eq = isl_mat_sub_alloc6(bset->ctx, aff->eq, 0, aff->n_eq, 0, 1 + total);
 3591 	isl_assert(bmap1->ctx, isl_space_is_equal(bmap1->dim, bmap2->dim),
 3601 	v = isl_vec_alloc(bmap1->ctx, 1 + total);
 3604 	elim = isl_alloc_array(bmap1->ctx, int, total);
 4718 	pairs = isl_calloc_array(bmap->ctx, int, bmap->n_div);

   68 	v = isl_vec_alloc(bmap->ctx, 1 + tab_total);
  125 	v = isl_vec_alloc(bmap->ctx, 1 + tab_total);
  176 		*div_map = isl_alloc_array(bmap->ctx, int, bmap->n_div);
  182 	vec = isl_vec_alloc(bmap->ctx, 2 + total + bmap->n_div);
  757 	isl_assert(bmap->ctx, bmap->n_eq == dim, return NULL);
  758 	point = isl_vec_alloc(bmap->ctx, 1 + dim);
  767 		isl_assert(bmap->ctx,
  770 		isl_assert(bmap->ctx,
  774 		isl_assert(bmap->ctx,

 1361 	ctx = bset->ctx;

   38 	morph = isl_alloc_type(dom->ctx, struct isl_morph);
  331 	id = isl_mat_identity(bset->ctx, 1 + total);
  351 	id = isl_mat_identity(bset->ctx, 1 + total);
  368 	isl_assert(bset->ctx, bset->n_div == 0, return NULL);
  432 	isl_assert(bset->ctx, bset->n_div == 0, return NULL);
  448 	E = isl_mat_sub_alloc6(bset->ctx, bset->eq, f_eq, n_eq, 0, orest);
  458 	Q = isl_mat_diagonal(Q, isl_mat_identity(bset->ctx, nrest));
  459 	C = isl_mat_diagonal(C, isl_mat_identity(bset->ctx, nrest));
  531 	B = isl_mat_sub_alloc6(bset->ctx, bset->eq, 0, n_eq, 0, 1 + nparam);
  532 	H = isl_mat_sub_alloc6(bset->ctx, bset->eq,
  535 	inv = isl_mat_diagonal(inv, isl_mat_identity(bset->ctx, nvar));
  623 	isl_assert(bset->ctx, isl_space_is_equal(bset->dim, morph->dom->dim),
  636 	mat = isl_mat_sub_alloc6(bset->ctx, bset->eq, 0, bset->n_eq,
  651 	mat = isl_mat_sub_alloc6(bset->ctx, bset->ineq, 0, bset->n_ineq,
  667 	mat = isl_mat_sub_alloc6(bset->ctx, bset->div, 0, bset->n_div,

  756 	c = isl_vec_alloc(bmap->ctx, 1 + total);
 1493 	isl_assert(bmap->ctx, 0, goto error);

  454 	isl_assert(bmap->ctx, isl_space_is_equal(bmap->dim, point->dim),
  460 	vec = isl_vec_alloc(bmap->ctx, 1 + dim + bmap->n_div);

   31 	vec = isl_vec_alloc(bset->ctx, 0);
   46 	sample = isl_vec_alloc(bset->ctx, 1 + dim);
   69 	sample = isl_vec_alloc(bset->ctx, 2);
   77 		isl_assert(bset->ctx, bset->n_eq == 1, goto error);
   78 		isl_assert(bset->ctx, bset->n_ineq == 0, goto error);
   82 			isl_assert(bset->ctx, isl_int_is_negone(bset->eq[0][1]),
  178 	isl_assert(bset->ctx, j == n_eq, goto error);
  686 	T = isl_mat_alloc(bset->ctx, 1 + total, 1 + total - (sample->size - 1));
  772 	isl_assert(cone->ctx, cone->n_eq == 0, goto error);
 1019 		row = isl_vec_alloc(bset->ctx, tab_cone->n_var);
 1133 	ctx = bset->ctx;

   73 	sample = isl_vec_alloc(bset->ctx, 1);
  122 	min = isl_vec_alloc(bset->ctx, dim);
  123 	max = isl_vec_alloc(bset->ctx, dim);
  124 	snap = isl_alloc_array(bset->ctx, struct isl_tab_undo *, dim);
  135 	tab->basis = isl_mat_identity(bset->ctx, 1 + dim);
  151 				    bset->ctx->one, &min->el[level], NULL, 0);
  159 				    bset->ctx->one, &max->el[level], NULL, 0);

 2223 	ineq = isl_vec_alloc(bmap->ctx, 1 + total);
 2398 	tab = isl_tab_alloc(bmap->ctx,
 2450 	tab = isl_tab_alloc(bset->ctx, bset->n_eq + bset->n_ineq,

  154 	if (bmap->ctx->opt->pip_symmetry)

  229 	partial = isl_alloc_type(dom->ctx, struct isl_partial_sol);
 1012 	ineq = isl_vec_alloc(bset->ctx, 1 + total);
 2287 	tab = isl_tab_alloc(bmap->ctx, 2 * bmap->n_eq + bmap->n_ineq + 1,
 2296 		tab->row_sign = isl_calloc_array(bmap->ctx,
 2824 	clex = isl_alloc_type(dom->ctx, struct isl_context_lex);
 3584 	cgbr = isl_calloc_type(dom->ctx, struct isl_context_gbr);
 3618 	if (dom->ctx->opt->context == ISL_CONTEXT_LEXMIN)
 3674 	sol_map = isl_calloc_type(bmap->ctx, struct isl_sol_map);
 5698 	sol_pma = isl_calloc_type(bmap->ctx, struct isl_sol_pma);

  391 	div_purity = isl_alloc_array(bset->ctx, int, n_div);

   92 	vertices = isl_calloc_type(bset->ctx, isl_vertices);
   97 	vertices->v = isl_alloc_array(bset->ctx, struct isl_vertex, n_vertices);
  144 	isl_assert(bset->ctx, v->v.vertex->n_eq >= nvar, goto error);
  174 	vertices = isl_calloc_type(bset->ctx, isl_vertices);
  199 	vertices = isl_calloc_type(bset->ctx, isl_vertices);
  205 	vertices->v = isl_calloc_array(bset->ctx, struct isl_vertex, 1);
  214 	vertices->c = isl_calloc_array(bset->ctx, struct isl_chamber, 1);
  219 	vertices->c[0].vertices = isl_calloc_array(bset->ctx, int, 1);
  399 	isl_assert(bset->ctx, isl_basic_set_dim(bset, isl_dim_div) == 0,
  424 	selection = isl_alloc_array(bset->ctx, int, bset->n_ineq);
  425 	snap = isl_alloc_array(bset->ctx, struct isl_tab_undo *, bset->n_ineq);
  426 	facets = isl_mat_alloc(bset->ctx, nvar, nvar);
 1053 	return cell ? cell->dom->ctx : NULL;
 1070 	cell = isl_calloc_type(dom->ctx, isl_cell);
 1075 	cell->ids = isl_alloc_array(dom->ctx, int, cell->n_vertices);
 1114 	tab = isl_tab_alloc(bset->ctx, bset->n_eq + bset->n_ineq + 1,
 1125 	c = isl_vec_alloc(bset->ctx, 1 + 1 + isl_basic_set_total_dim(bset));
 1323 	return vertices ? vertices->bset->ctx : NULL;
 1340 	isl_assert(vertices->bset->ctx, vertices->ref == 1, goto error);