isl_set.h File Reference

#include "isl_map.h"
#include "isl_list.h"

Go to the source code of this file.

Data Structures

struct  isl_basic_set
struct  isl_set

Defines

#define ISL_BASIC_SET_FINAL   (1 << 0)
#define ISL_BASIC_SET_EMPTY   (1 << 1)
#define ISL_BASIC_SET_NO_IMPLICIT   (1 << 2)
#define ISL_BASIC_SET_NO_REDUNDANT   (1 << 3)
#define ISL_BASIC_SET_RATIONAL   (1 << 4)
#define ISL_BASIC_SET_NORMALIZED   (1 << 5)
#define ISL_BASIC_SET_NORMALIZED_DIVS   (1 << 6)
#define ISL_BASIC_SET_ALL_EQUALITIES   (1 << 7)
#define ISL_SET_DISJOINT   (1 << 0)
#define ISL_SET_NORMALIZED   (1 << 1)
#define ISL_FORMAT_POLYLIB   1
#define ISL_FORMAT_OMEGA   2
#define ISL_FORMAT_POLYLIB_CONSTRAINTS   3

Functions

unsigned isl_basic_set_n_dim (const struct isl_basic_set *bset)
unsigned isl_basic_set_n_param (const struct isl_basic_set *bset)
unsigned isl_basic_set_total_dim (const struct isl_basic_set *bset)
unsigned isl_basic_set_dim (const struct isl_basic_set *bset, enum isl_dim_type type)
unsigned isl_set_n_dim (const struct isl_set *set)
unsigned isl_set_n_param (const struct isl_set *set)
unsigned isl_set_dim (const struct isl_set *set, enum isl_dim_type type)
struct isl_dim * isl_basic_set_get_dim (struct isl_basic_set *bset)
struct isl_dim * isl_set_get_dim (struct isl_set *set)
struct isl_basic_set * isl_basic_set_alloc (struct isl_ctx *ctx, unsigned nparam, unsigned dim, unsigned extra, unsigned n_eq, unsigned n_ineq)
struct isl_basic_set * isl_basic_set_extend (struct isl_basic_set *base, unsigned nparam, unsigned dim, unsigned extra, unsigned n_eq, unsigned n_ineq)
struct isl_basic_set * isl_basic_set_extend_constraints (struct isl_basic_set *base, unsigned n_eq, unsigned n_ineq)
struct isl_basic_set * isl_basic_set_finalize (struct isl_basic_set *bset)
void isl_basic_set_free (struct isl_basic_set *bset)
struct isl_basic_set * isl_basic_set_copy (struct isl_basic_set *bset)
struct isl_basic_set * isl_basic_set_dup (struct isl_basic_set *bset)
struct isl_basic_set * isl_basic_set_empty (struct isl_dim *dim)
struct isl_basic_set * isl_basic_set_empty_like (struct isl_basic_set *bset)
struct isl_basic_set * isl_basic_set_universe (struct isl_dim *dim)
struct isl_basic_set * isl_basic_set_universe_like (struct isl_basic_set *bset)
struct isl_basic_set * isl_basic_set_interval (struct isl_ctx *ctx, isl_int min, isl_int max)
void isl_basic_set_dump (struct isl_basic_set *bset, FILE *out, int indent)
struct isl_basic_set * isl_basic_set_swap_vars (struct isl_basic_set *bset, unsigned n)
struct isl_basic_set * isl_basic_set_intersect (struct isl_basic_set *bset1, struct isl_basic_set *bset2)
struct isl_basic_set * isl_basic_set_apply (struct isl_basic_set *bset, struct isl_basic_map *bmap)
struct isl_basic_set * isl_basic_set_affine_hull (struct isl_basic_set *bset)
struct isl_basic_set * isl_basic_set_simplify (struct isl_basic_set *bset)
struct isl_basic_set * isl_basic_set_product (struct isl_basic_set_list *list)
struct isl_basic_set * isl_basic_set_read_from_file (struct isl_ctx *ctx, FILE *input, unsigned nparam, unsigned input_format)
struct isl_basic_set * isl_basic_set_read_from_str (struct isl_ctx *ctx, const char *str, unsigned nparam, unsigned input_format)
struct isl_set * isl_set_read_from_file (struct isl_ctx *ctx, FILE *input, unsigned nparam, unsigned input_format)
void isl_basic_set_print (struct isl_basic_set *bset, FILE *out, int indent, const char *prefix, const char *suffix, unsigned output_format)
void isl_set_print (struct isl_set *set, FILE *out, int indent, unsigned output_format)
struct isl_basic_set * isl_basic_set_fix_si (struct isl_basic_set *bset, enum isl_dim_type type, unsigned pos, int value)
struct isl_basic_set * isl_basic_set_from_underlying_set (struct isl_basic_set *bset, struct isl_basic_set *like)
struct isl_set * isl_set_from_underlying_set (struct isl_set *set, struct isl_basic_set *like)
struct isl_set * isl_set_to_underlying_set (struct isl_set *set)
int isl_basic_set_is_equal (struct isl_basic_set *bset1, struct isl_basic_set *bset2)
struct isl_set * isl_basic_set_lexmin (struct isl_basic_set *bset)
struct isl_set * isl_basic_set_union (struct isl_basic_set *bset1, struct isl_basic_set *bset2)
int isl_basic_set_compare_at (struct isl_basic_set *bset1, struct isl_basic_set *bset2, int pos)
int isl_basic_set_is_universe (struct isl_basic_set *bset)
int isl_basic_set_fast_is_empty (struct isl_basic_set *bset)
int isl_basic_set_is_empty (struct isl_basic_set *bset)
struct isl_set * isl_set_alloc (struct isl_ctx *ctx, unsigned nparam, unsigned dim, int n, unsigned flags)
struct isl_set * isl_set_extend (struct isl_set *base, unsigned nparam, unsigned dim)
struct isl_set * isl_set_empty (struct isl_dim *dim)
struct isl_set * isl_set_empty_like (struct isl_set *set)
struct isl_set * isl_set_universe (struct isl_dim *dim)
struct isl_set * isl_set_add (struct isl_set *set, struct isl_basic_set *bset)
struct isl_set * isl_set_finalize (struct isl_set *set)
struct isl_set * isl_set_copy (struct isl_set *set)
void isl_set_free (struct isl_set *set)
struct isl_set * isl_set_dup (struct isl_set *set)
struct isl_set * isl_set_from_basic_set (struct isl_basic_set *bset)
struct isl_basic_set * isl_set_affine_hull (struct isl_set *set)
struct isl_basic_set * isl_set_convex_hull (struct isl_set *set)
struct isl_basic_set * isl_set_simple_hull (struct isl_set *set)
struct isl_basic_set * isl_set_bounded_simple_hull (struct isl_set *set)
struct isl_set * isl_set_union_disjoint (struct isl_set *set1, struct isl_set *set2)
struct isl_set * isl_set_union (struct isl_set *set1, struct isl_set *set2)
struct isl_set * isl_set_product (struct isl_set *set1, struct isl_set *set2)
struct isl_set * isl_set_intersect (struct isl_set *set1, struct isl_set *set2)
struct isl_set * isl_set_subtract (struct isl_set *set1, struct isl_set *set2)
struct isl_set * isl_set_apply (struct isl_set *set, struct isl_map *map)
struct isl_set * isl_set_fix_dim_si (struct isl_set *set, unsigned dim, int value)
struct isl_set * isl_set_lower_bound_dim (struct isl_set *set, unsigned dim, isl_int value)
struct isl_basic_set * isl_basic_set_remove_dims (struct isl_basic_set *bset, unsigned first, unsigned n)
struct isl_basic_set * isl_basic_set_remove_divs (struct isl_basic_set *bset)
struct isl_set * isl_set_eliminate_dims (struct isl_set *set, unsigned first, unsigned n)
struct isl_set * isl_set_remove_dims (struct isl_set *set, unsigned first, unsigned n)
struct isl_set * isl_set_remove_divs (struct isl_set *set)
void isl_set_dump (struct isl_set *set, FILE *out, int indent)
struct isl_set * isl_set_swap_vars (struct isl_set *set, unsigned n)
int isl_set_is_empty (struct isl_set *set)
int isl_set_is_subset (struct isl_set *set1, struct isl_set *set2)
int isl_set_is_equal (struct isl_set *set1, struct isl_set *set2)
struct isl_set * isl_basic_set_compute_divs (struct isl_basic_set *bset)
struct isl_set * isl_set_compute_divs (struct isl_set *set)
struct isl_basic_set * isl_set_copy_basic_set (struct isl_set *set)
struct isl_set * isl_set_drop_basic_set (struct isl_set *set, struct isl_basic_set *bset)
int isl_set_fast_dim_is_fixed (struct isl_set *set, unsigned dim, isl_int *val)
int isl_set_fast_dim_has_fixed_lower_bound (struct isl_set *set, unsigned dim, isl_int *val)
struct isl_basic_set * isl_basic_set_gist (struct isl_basic_set *bset, struct isl_basic_set *context)
struct isl_set * isl_set_gist (struct isl_set *set, struct isl_basic_set *context)
int isl_basic_set_dim_residue_class (struct isl_basic_set *bset, int pos, isl_int *modulo, isl_int *residue)
struct isl_set * isl_set_coalesce (struct isl_set *set)
int isl_set_fast_is_equal (struct isl_set *set1, struct isl_set *set2)
int isl_set_fast_is_disjoint (struct isl_set *set1, struct isl_set *set2)
uint32_t isl_set_get_hash (struct isl_set *set)
int isl_set_dim_is_unique (struct isl_set *set, unsigned dim)

Define Documentation

#define ISL_BASIC_SET_FINAL   (1 << 0)

Definition at line 16 of file isl_set.h.

#define ISL_BASIC_SET_EMPTY   (1 << 1)

Definition at line 17 of file isl_set.h.

#define ISL_BASIC_SET_NO_IMPLICIT   (1 << 2)

Definition at line 18 of file isl_set.h.

#define ISL_BASIC_SET_NO_REDUNDANT   (1 << 3)

Definition at line 19 of file isl_set.h.

#define ISL_BASIC_SET_RATIONAL   (1 << 4)

Definition at line 20 of file isl_set.h.

#define ISL_BASIC_SET_NORMALIZED   (1 << 5)

Definition at line 21 of file isl_set.h.

#define ISL_BASIC_SET_NORMALIZED_DIVS   (1 << 6)

Definition at line 22 of file isl_set.h.

#define ISL_BASIC_SET_ALL_EQUALITIES   (1 << 7)

Definition at line 23 of file isl_set.h.

#define ISL_SET_DISJOINT   (1 << 0)

Definition at line 54 of file isl_set.h.

#define ISL_SET_NORMALIZED   (1 << 1)

Definition at line 55 of file isl_set.h.

#define ISL_FORMAT_POLYLIB   1

Definition at line 113 of file isl_set.h.

#define ISL_FORMAT_OMEGA   2

Definition at line 114 of file isl_set.h.

#define ISL_FORMAT_POLYLIB_CONSTRAINTS   3

Definition at line 121 of file isl_set.h.

Function Documentation

unsigned isl_basic_set_n_dim ( const struct isl_basic_set *  bset  ) 

Definition at line 138 of file isl_map.c.

00139 {
00140         return bset->dim->n_out;
00141 }

unsigned isl_basic_set_n_param ( const struct isl_basic_set *  bset  ) 

Definition at line 143 of file isl_map.c.

00144 {
00145         return bset->dim->nparam;
00146 }

unsigned isl_basic_set_total_dim ( const struct isl_basic_set *  bset  ) 

Definition at line 148 of file isl_map.c.

00149 {
00150         return isl_dim_total(bset->dim) + bset->n_div;
00151 }

unsigned isl_basic_set_dim ( const struct isl_basic_set *  bset,
enum isl_dim_type  type 
)

Definition at line 132 of file isl_map.c.

00134 {
00135         return isl_basic_map_dim((const struct isl_basic_map*)bset, type);
00136 }

unsigned isl_set_n_dim ( const struct isl_set *  set  ) 

Definition at line 153 of file isl_map.c.

00154 {
00155         return set->dim->n_out;
00156 }

unsigned isl_set_n_param ( const struct isl_set *  set  ) 

Definition at line 158 of file isl_map.c.

00159 {
00160         return set->dim->nparam;
00161 }

unsigned isl_set_dim ( const struct isl_set *  set,
enum isl_dim_type  type 
)

Definition at line 110 of file isl_map.c.

00111 {
00112         return n(set->dim, type);
00113 }

struct isl_dim* isl_basic_set_get_dim ( struct isl_basic_set *  bset  )  [read]

Definition at line 223 of file isl_map.c.

00224 {
00225         if (!bset)
00226                 return NULL;
00227         return isl_dim_copy(bset->dim);
00228 }

struct isl_dim* isl_set_get_dim ( struct isl_set *  set  )  [read]

Definition at line 230 of file isl_map.c.

00231 {
00232         if (!set)
00233                 return NULL;
00234         return isl_dim_copy(set->dim);
00235 }

struct isl_basic_set* isl_basic_set_alloc ( struct isl_ctx *  ctx,
unsigned  nparam,
unsigned  dim,
unsigned  extra,
unsigned  n_eq,
unsigned  n_ineq 
) [read]

Definition at line 303 of file isl_map.c.

00306 {
00307         struct isl_basic_map *bmap;
00308         bmap = isl_basic_map_alloc(ctx, nparam, 0, dim, extra, n_eq, n_ineq);
00309         return (struct isl_basic_set *)bmap;
00310 }

struct isl_basic_set* isl_basic_set_extend ( struct isl_basic_set *  base,
unsigned  nparam,
unsigned  dim,
unsigned  extra,
unsigned  n_eq,
unsigned  n_ineq 
) [read]

Definition at line 903 of file isl_map.c.

00906 {
00907         return (struct isl_basic_set *)
00908                 isl_basic_map_extend((struct isl_basic_map *)base,
00909                                         nparam, 0, dim, extra, n_eq, n_ineq);
00910 }

struct isl_basic_set* isl_basic_set_extend_constraints ( struct isl_basic_set *  base,
unsigned  n_eq,
unsigned  n_ineq 
) [read]

Definition at line 912 of file isl_map.c.

00914 {
00915         return (struct isl_basic_set *)
00916                 isl_basic_map_extend_constraints((struct isl_basic_map *)base,
00917                                                     n_eq, n_ineq);
00918 }

struct isl_basic_set* isl_basic_set_finalize ( struct isl_basic_set *  bset  )  [read]

Definition at line 1134 of file isl_map_simplify.c.

01135 {
01136         return (struct isl_basic_set *)
01137                 isl_basic_map_finalize((struct isl_basic_map *)bset);
01138 }

void isl_basic_set_free ( struct isl_basic_set *  bset  ) 

Definition at line 463 of file isl_map.c.

00464 {
00465         isl_basic_map_free((struct isl_basic_map *)bset);
00466 }

struct isl_basic_set* isl_basic_set_copy ( struct isl_basic_set *  bset  )  [read]

Definition at line 403 of file isl_map.c.

00404 {
00405         if (!bset)
00406                 return NULL;
00407 
00408         if (ISL_F_ISSET(bset, ISL_BASIC_SET_FINAL)) {
00409                 bset->ref++;
00410                 return bset;
00411         }
00412         return isl_basic_set_dup(bset);
00413 }

struct isl_basic_set* isl_basic_set_dup ( struct isl_basic_set *  bset  )  [read]

Definition at line 395 of file isl_map.c.

00396 {
00397         struct isl_basic_map *dup;
00398 
00399         dup = isl_basic_map_dup((struct isl_basic_map *)bset);
00400         return (struct isl_basic_set *)dup;
00401 }

struct isl_basic_set* isl_basic_set_empty ( struct isl_dim *  dim  )  [read]

Definition at line 2566 of file isl_map.c.

02567 {
02568         struct isl_basic_set *bset;
02569         bset = isl_basic_set_alloc_dim(dim, 0, 1, 0);
02570         bset = isl_basic_set_set_to_empty(bset);
02571         return bset;
02572 }

struct isl_basic_set* isl_basic_set_empty_like ( struct isl_basic_set *  bset  )  [read]

Definition at line 2594 of file isl_map.c.

02595 {
02596         struct isl_basic_set *bset;
02597         if (!model)
02598                 return NULL;
02599         bset = isl_basic_set_alloc_dim(isl_dim_copy(model->dim), 0, 1, 0);
02600         bset = isl_basic_set_set_to_empty(bset);
02601         return bset;
02602 }

struct isl_basic_set* isl_basic_set_universe ( struct isl_dim *  dim  )  [read]

Definition at line 2611 of file isl_map.c.

02612 {
02613         struct isl_basic_set *bset;
02614         bset = isl_basic_set_alloc_dim(dim, 0, 0, 0);
02615         return bset;
02616 }

struct isl_basic_set* isl_basic_set_universe_like ( struct isl_basic_set *  bset  )  [read]

Definition at line 2618 of file isl_map.c.

02619 {
02620         if (!model)
02621                 return NULL;
02622         return isl_basic_set_alloc_dim(isl_dim_copy(model->dim), 0, 0, 0);
02623 }

struct isl_basic_set* isl_basic_set_interval ( struct isl_ctx *  ctx,
isl_int  min,
isl_int  max 
) [read]

Definition at line 4402 of file isl_map.c.

04404 {
04405         int k;
04406         struct isl_basic_set *bset = NULL;
04407 
04408         bset = isl_basic_set_alloc(ctx, 0, 1, 0, 0, 2);
04409         if (!bset)
04410                 goto error;
04411 
04412         k = isl_basic_set_alloc_inequality(bset);
04413         if (k < 0)
04414                 goto error;
04415         isl_int_set_si(bset->ineq[k][1], 1);
04416         isl_int_neg(bset->ineq[k][0], min);
04417 
04418         k = isl_basic_set_alloc_inequality(bset);
04419         if (k < 0)
04420                 goto error;
04421         isl_int_set_si(bset->ineq[k][1], -1);
04422         isl_int_set(bset->ineq[k][0], max);
04423 
04424         return bset;
04425 error:
04426         isl_basic_set_free(bset);
04427         return NULL;
04428 }

void isl_basic_set_dump ( struct isl_basic_set *  bset,
FILE *  out,
int  indent 
)

Definition at line 1339 of file isl_map.c.

01340 {
01341         if (!bset) {
01342                 fprintf(out, "null basic set\n");
01343                 return;
01344         }
01345 
01346         fprintf(out, "%*s", indent, "");
01347         fprintf(out, "ref: %d, nparam: %d, dim: %d, extra: %d, flags: %x\n",
01348                         bset->ref, bset->dim->nparam, bset->dim->n_out,
01349                         bset->extra, bset->flags);
01350         dump((struct isl_basic_map *)bset, out, indent);
01351 }

struct isl_basic_set* isl_basic_set_swap_vars ( struct isl_basic_set *  bset,
unsigned  n 
) [read]

Definition at line 969 of file isl_map.c.

00971 {
00972         int i;
00973         struct isl_blk blk;
00974         unsigned dim;
00975         unsigned nparam;
00976 
00977         if (!bset)
00978                 goto error;
00979 
00980         nparam = isl_basic_set_n_param(bset);
00981         dim = isl_basic_set_n_dim(bset);
00982         isl_assert(bset->ctx, n <= dim, goto error);
00983 
00984         if (n == dim)
00985                 return bset;
00986 
00987         bset = isl_basic_set_cow(bset);
00988         if (!bset)
00989                 return NULL;
00990 
00991         blk = isl_blk_alloc(bset->ctx, dim);
00992         if (isl_blk_is_error(blk))
00993                 goto error;
00994 
00995         for (i = 0; i < bset->n_eq; ++i)
00996                 swap_vars(blk,
00997                           bset->eq[i]+1+nparam, n, dim - n);
00998 
00999         for (i = 0; i < bset->n_ineq; ++i)
01000                 swap_vars(blk,
01001                           bset->ineq[i]+1+nparam, n, dim - n);
01002 
01003         for (i = 0; i < bset->n_div; ++i)
01004                 swap_vars(blk,
01005                           bset->div[i]+1+1+nparam, n, dim - n);
01006 
01007         isl_blk_free(bset->ctx, blk);
01008 
01009         ISL_F_CLR(bset, ISL_BASIC_SET_NORMALIZED);
01010         return bset;
01011 
01012 error:
01013         isl_basic_set_free(bset);
01014         return NULL;
01015 }

struct isl_basic_set* isl_basic_set_intersect ( struct isl_basic_set *  bset1,
struct isl_basic_set *  bset2 
) [read]

Definition at line 1698 of file isl_map.c.

01700 {
01701         return (struct isl_basic_set *)
01702                 isl_basic_map_intersect(
01703                         (struct isl_basic_map *)bset1,
01704                         (struct isl_basic_map *)bset2);
01705 }

struct isl_basic_set* isl_basic_set_apply ( struct isl_basic_set *  bset,
struct isl_basic_map *  bmap 
) [read]

Definition at line 1895 of file isl_map.c.

01897 {
01898         if (!bset || !bmap)
01899                 goto error;
01900 
01901         isl_assert(set->ctx, isl_basic_map_compatible_domain(bmap, bset),
01902                     goto error);
01903 
01904         return (struct isl_basic_set *)
01905                 isl_basic_map_apply_range((struct isl_basic_map *)bset, bmap);
01906 error:
01907         isl_basic_set_free(bset);
01908         isl_basic_map_free(bmap);
01909         return NULL;
01910 }

struct isl_basic_set* isl_basic_set_affine_hull ( struct isl_basic_set *  bset  )  [read]

Definition at line 560 of file isl_affine_hull.c.

00561 {
00562         return (struct isl_basic_set *)
00563                 isl_basic_map_affine_hull((struct isl_basic_map *)bset);
00564 }

struct isl_basic_set* isl_basic_set_simplify ( struct isl_basic_set *  bset  )  [read]

Definition at line 1047 of file isl_map_simplify.c.

01048 {
01049         return (struct isl_basic_set *)
01050                 isl_basic_map_simplify((struct isl_basic_map *)bset);
01051 }

struct isl_basic_set* isl_basic_set_product ( struct isl_basic_set_list *  list  )  [read]

Definition at line 4432 of file isl_map.c.

04433 {
04434         int i;
04435         unsigned dim;
04436         unsigned nparam;
04437         unsigned extra;
04438         unsigned n_eq;
04439         unsigned n_ineq;
04440         struct isl_basic_set *product = NULL;
04441 
04442         if (!list)
04443                 goto error;
04444         isl_assert(list->ctx, list->n > 0, goto error);
04445         isl_assert(list->ctx, list->p[0], goto error);
04446         nparam = isl_basic_set_n_param(list->p[0]);
04447         dim = isl_basic_set_n_dim(list->p[0]);
04448         extra = list->p[0]->n_div;
04449         n_eq = list->p[0]->n_eq;
04450         n_ineq = list->p[0]->n_ineq;
04451         for (i = 1; i < list->n; ++i) {
04452                 isl_assert(list->ctx, list->p[i], goto error);
04453                 isl_assert(list->ctx,
04454                     nparam == isl_basic_set_n_param(list->p[i]), goto error);
04455                 dim += isl_basic_set_n_dim(list->p[i]);
04456                 extra += list->p[i]->n_div;
04457                 n_eq += list->p[i]->n_eq;
04458                 n_ineq += list->p[i]->n_ineq;
04459         }
04460         product = isl_basic_set_alloc(list->ctx, nparam, dim, extra,
04461                                         n_eq, n_ineq);
04462         if (!product)
04463                 goto error;
04464         dim = 0;
04465         for (i = 0; i < list->n; ++i) {
04466                 isl_basic_set_add_constraints(product,
04467                                         isl_basic_set_copy(list->p[i]), dim);
04468                 dim += isl_basic_set_n_dim(list->p[i]);
04469         }
04470         isl_basic_set_list_free(list);
04471         return product;
04472 error:
04473         isl_basic_set_free(product);
04474         isl_basic_set_list_free(list);
04475         return NULL;
04476 }

struct isl_basic_set* isl_basic_set_read_from_file ( struct isl_ctx *  ctx,
FILE *  input,
unsigned  nparam,
unsigned  input_format 
) [read]

Definition at line 119 of file isl_input.c.

00121 {
00122         if (input_format == ISL_FORMAT_POLYLIB)
00123                 return isl_basic_set_read_from_file_polylib(ctx, input, nparam);
00124         else if (input_format == ISL_FORMAT_OMEGA) {
00125                 isl_assert(ctx, nparam == 0, return NULL);
00126                 return isl_basic_set_read_from_file_omega(ctx, input);
00127         } else
00128                 isl_assert(ctx, 0, return NULL);
00129 }

struct isl_basic_set* isl_basic_set_read_from_str ( struct isl_ctx *  ctx,
const char *  str,
unsigned  nparam,
unsigned  input_format 
) [read]

Definition at line 131 of file isl_input.c.

00133 {
00134         if (input_format == ISL_FORMAT_OMEGA) {
00135                 isl_assert(ctx, nparam == 0, return NULL);
00136                 return isl_basic_set_read_from_str_omega(ctx, str);
00137         } else
00138                 isl_assert(ctx, 0, return NULL);
00139 }

struct isl_set* isl_set_read_from_file ( struct isl_ctx *  ctx,
FILE *  input,
unsigned  nparam,
unsigned  input_format 
) [read]

Definition at line 150 of file isl_input.c.

00152 {
00153         if (input_format == ISL_FORMAT_POLYLIB)
00154                 return isl_set_read_from_file_polylib(ctx, input, nparam);
00155         else
00156                 isl_assert(ctx, 0, return NULL);
00157 }

void isl_basic_set_print ( struct isl_basic_set *  bset,
FILE *  out,
int  indent,
const char *  prefix,
const char *  suffix,
unsigned  output_format 
)

Definition at line 66 of file isl_output.c.

00068 {
00069         if (!bset)
00070                 return;
00071         if (output_format == ISL_FORMAT_POLYLIB)
00072                 isl_basic_set_print_polylib(bset, out, indent, prefix, suffix);
00073         else if (output_format == ISL_FORMAT_POLYLIB_CONSTRAINTS)
00074                 print_constraints_polylib(bset, out, indent, prefix, suffix);
00075         else
00076                 isl_assert(bset->ctx, 0, return);
00077 }

void isl_set_print ( struct isl_set *  set,
FILE *  out,
int  indent,
unsigned  output_format 
)

Definition at line 79 of file isl_output.c.

00081 {
00082         if (!set)
00083                 return;
00084         if (output_format == ISL_FORMAT_POLYLIB)
00085                 isl_set_print_polylib(set, out, indent);
00086         else
00087                 isl_assert(set->ctx, 0, return);
00088 }

struct isl_basic_set* isl_basic_set_fix_si ( struct isl_basic_set *  bset,
enum isl_dim_type  type,
unsigned  pos,
int  value 
) [read]

Definition at line 2788 of file isl_map.c.

02790 {
02791         return (struct isl_basic_set *)
02792                 isl_basic_map_fix_si((struct isl_basic_map *)bset,
02793                                         type, pos, value);
02794 }

struct isl_basic_set* isl_basic_set_from_underlying_set ( struct isl_basic_set *  bset,
struct isl_basic_set *  like 
) [read]

Definition at line 2333 of file isl_map.c.

02335 {
02336         return (struct isl_basic_set *)
02337                 isl_basic_map_overlying_set(bset, (struct isl_basic_map *)like);
02338 }

struct isl_set* isl_set_from_underlying_set ( struct isl_set *  set,
struct isl_basic_set *  like 
) [read]

Definition at line 2340 of file isl_map.c.

02342 {
02343         int i;
02344 
02345         if (!set || !like)
02346                 goto error;
02347         isl_assert(set->ctx, set->dim->n_out == isl_basic_set_total_dim(like),
02348                     goto error);
02349         if (isl_dim_equal(set->dim, like->dim) && like->n_div == 0) {
02350                 isl_basic_set_free(like);
02351                 return set;
02352         }
02353         set = isl_set_cow(set);
02354         if (!set)
02355                 goto error;
02356         for (i = 0; i < set->n; ++i) {
02357                 set->p[i] = isl_basic_set_from_underlying_set(set->p[i],
02358                                                       isl_basic_set_copy(like));
02359                 if (!set->p[i])
02360                         goto error;
02361         }
02362         isl_dim_free(set->dim);
02363         set->dim = isl_dim_copy(like->dim);
02364         if (!set->dim)
02365                 goto error;
02366         isl_basic_set_free(like);
02367         return set;
02368 error:
02369         isl_basic_set_free(like);
02370         isl_set_free(set);
02371         return NULL;
02372 }

struct isl_set* isl_set_to_underlying_set ( struct isl_set *  set  )  [read]

Definition at line 2408 of file isl_map.c.

02409 {
02410         return (struct isl_set *)isl_map_underlying_set((struct isl_map *)set);
02411 }

int isl_basic_set_is_equal ( struct isl_basic_set *  bset1,
struct isl_basic_set *  bset2 
)

Definition at line 3395 of file isl_map.c.

03397 {
03398         return isl_basic_map_is_equal(
03399                 (struct isl_basic_map *)bset1, (struct isl_basic_map *)bset2);
03400 }

struct isl_set* isl_basic_set_lexmin ( struct isl_basic_set *  bset  )  [read]

Definition at line 2924 of file isl_map.c.

02925 {
02926         struct isl_basic_map *bmap = NULL;
02927         struct isl_basic_set *dom = NULL;
02928         struct isl_map *min;
02929         struct isl_dim *param_dim;
02930 
02931         if (!bset)
02932                 goto error;
02933         bmap = isl_basic_map_from_basic_set(bset, isl_dim_copy(bset->dim));
02934         if (!bmap)
02935                 goto error;
02936         param_dim = isl_dim_domain(isl_dim_copy(bmap->dim));
02937         dom = isl_basic_set_universe(param_dim);
02938         if (!dom)
02939                 goto error;
02940         min = isl_basic_map_lexmin(bmap, dom, NULL);
02941         return isl_map_range(min);
02942 error:
02943         isl_basic_map_free(bmap);
02944         return NULL;
02945 }

struct isl_set* isl_basic_set_union ( struct isl_basic_set *  bset1,
struct isl_basic_set *  bset2 
) [read]

Definition at line 3582 of file isl_map.c.

03584 {
03585         return (struct isl_set *)isl_basic_map_union(
03586                                             (struct isl_basic_map *)bset1,
03587                                             (struct isl_basic_map *)bset2);
03588 }

int isl_basic_set_compare_at ( struct isl_basic_set *  bset1,
struct isl_basic_set *  bset2,
int  pos 
)

Definition at line 3966 of file isl_map.c.

03968 {
03969         struct isl_dim *dims;
03970         struct isl_basic_map *bmap1 = NULL;
03971         struct isl_basic_map *bmap2 = NULL;
03972         struct isl_ctx *ctx;
03973         struct isl_vec *obj;
03974         unsigned total;
03975         unsigned nparam;
03976         unsigned dim1, dim2;
03977         isl_int num, den;
03978         enum isl_lp_result res;
03979         int cmp;
03980 
03981         if (!bset1 || !bset2)
03982                 return -2;
03983 
03984         nparam = isl_basic_set_n_param(bset1);
03985         dim1 = isl_basic_set_n_dim(bset1);
03986         dim2 = isl_basic_set_n_dim(bset2);
03987         dims = isl_dim_alloc(bset1->ctx, nparam, pos, dim1 - pos);
03988         bmap1 = isl_basic_map_from_basic_set(isl_basic_set_copy(bset1), dims);
03989         dims = isl_dim_alloc(bset2->ctx, nparam, pos, dim2 - pos);
03990         bmap2 = isl_basic_map_from_basic_set(isl_basic_set_copy(bset2), dims);
03991         if (!bmap1 || !bmap2)
03992                 goto error;
03993         bmap1 = isl_basic_map_cow(bmap1);
03994         bmap1 = isl_basic_map_extend(bmap1, nparam,
03995                         pos, (dim1 - pos) + (dim2 - pos),
03996                         bmap2->n_div, bmap2->n_eq, bmap2->n_ineq);
03997         bmap1 = add_constraints(bmap1, bmap2, 0, dim1 - pos);
03998         if (!bmap1)
03999                 goto error;
04000         total = isl_basic_map_total_dim(bmap1);
04001         ctx = bmap1->ctx;
04002         obj = isl_vec_alloc(ctx, 1 + total);
04003         isl_seq_clr(obj->block.data, 1 + total);
04004         isl_int_set_si(obj->block.data[1+nparam+pos], 1);
04005         isl_int_set_si(obj->block.data[1+nparam+pos+(dim1-pos)], -1);
04006         if (!obj)
04007                 goto error;
04008         isl_int_init(num);
04009         isl_int_init(den);
04010         res = isl_solve_lp(bmap1, 0, obj->block.data, ctx->one, &num, &den);
04011         if (res == isl_lp_empty)
04012                 cmp = 0;
04013         else if (res == isl_lp_ok && isl_int_is_pos(num))
04014                 cmp = 1;
04015         else if ((res == isl_lp_ok && isl_int_is_neg(num)) ||
04016                   res == isl_lp_unbounded)
04017                 cmp = -1;
04018         else
04019                 cmp = -2;
04020         isl_int_clear(num);
04021         isl_int_clear(den);
04022         isl_basic_map_free(bmap1);
04023         isl_vec_free(ctx, obj);
04024         return cmp;
04025 error:
04026         isl_basic_map_free(bmap1);
04027         isl_basic_map_free(bmap2);
04028         return -2;
04029 }

int isl_basic_set_is_universe ( struct isl_basic_set *  bset  ) 

Definition at line 3490 of file isl_map.c.

03491 {
03492         if (!bset)
03493                 return -1;
03494         return bset->n_eq == 0 && bset->n_ineq == 0;
03495 }

int isl_basic_set_fast_is_empty ( struct isl_basic_set *  bset  ) 

Definition at line 3549 of file isl_map.c.

03550 {
03551         if (!bset)
03552                 return -1;
03553         return ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY);
03554 }

int isl_basic_set_is_empty ( struct isl_basic_set *  bset  ) 

Definition at line 3556 of file isl_map.c.

03557 {
03558         return isl_basic_map_is_empty((struct isl_basic_map *)bset);
03559 }

struct isl_set* isl_set_alloc ( struct isl_ctx *  ctx,
unsigned  nparam,
unsigned  dim,
int  n,
unsigned  flags 
) [read]

Definition at line 1409 of file isl_map.c.

01411 {
01412         struct isl_set *set;
01413         struct isl_dim *dims;
01414 
01415         dims = isl_dim_alloc(ctx, nparam, 0, dim);
01416         if (!dims)
01417                 return NULL;
01418 
01419         set = isl_set_alloc_dim(dims, n, flags);
01420         return set;
01421 }

struct isl_set* isl_set_extend ( struct isl_set *  base,
unsigned  nparam,
unsigned  dim 
) [read]

Definition at line 2748 of file isl_map.c.

02750 {
02751         return (struct isl_set *)isl_map_extend((struct isl_map *)base,
02752                                                         nparam, 0, dim);
02753 }

struct isl_set* isl_set_empty ( struct isl_dim *  dim  )  [read]

Definition at line 2644 of file isl_map.c.

02645 {
02646         return isl_set_alloc_dim(dim, 0, ISL_MAP_DISJOINT);
02647 }

struct isl_set* isl_set_empty_like ( struct isl_set *  set  )  [read]

Definition at line 2649 of file isl_map.c.

02650 {
02651         if (!model)
02652                 return NULL;
02653         return isl_set_empty(isl_dim_copy(model->dim));
02654 }

struct isl_set* isl_set_universe ( struct isl_dim *  dim  )  [read]

Definition at line 2666 of file isl_map.c.

02667 {
02668         struct isl_set *set;
02669         if (!dim)
02670                 return NULL;
02671         set = isl_set_alloc_dim(isl_dim_copy(dim), 1, ISL_MAP_DISJOINT);
02672         set = isl_set_add(set, isl_basic_set_universe(dim));
02673         return set;
02674 }

struct isl_set* isl_set_add ( struct isl_set *  set,
struct isl_basic_set *  bset 
) [read]

Definition at line 1469 of file isl_map.c.

01470 {
01471         if (!bset || !set)
01472                 goto error;
01473         isl_assert(set->ctx, isl_dim_equal(set->dim, bset->dim), goto error);
01474         isl_assert(set->ctx, set->n < set->size, goto error);
01475         set->p[set->n] = bset;
01476         set->n++;
01477         return set;
01478 error:
01479         if (set)
01480                 isl_set_free(set);
01481         if (bset)
01482                 isl_basic_set_free(bset);
01483         return NULL;
01484 }

struct isl_set* isl_set_finalize ( struct isl_set *  set  )  [read]

Definition at line 1140 of file isl_map_simplify.c.

01141 {
01142         int i;
01143 
01144         if (!set)
01145                 return NULL;
01146         for (i = 0; i < set->n; ++i) {
01147                 set->p[i] = isl_basic_set_finalize(set->p[i]);
01148                 if (!set->p[i])
01149                         goto error;
01150         }
01151         return set;
01152 error:
01153         isl_set_free(set);
01154         return NULL;
01155 }

struct isl_set* isl_set_copy ( struct isl_set *  set  )  [read]

Definition at line 415 of file isl_map.c.

00416 {
00417         if (!set)
00418                 return NULL;
00419 
00420         set->ref++;
00421         return set;
00422 }

void isl_set_free ( struct isl_set *  set  ) 

Definition at line 1486 of file isl_map.c.

01487 {
01488         int i;
01489 
01490         if (!set)
01491                 return;
01492 
01493         if (--set->ref > 0)
01494                 return;
01495 
01496         isl_ctx_deref(set->ctx);
01497         for (i = 0; i < set->n; ++i)
01498                 isl_basic_set_free(set->p[i]);
01499         isl_dim_free(set->dim);
01500         free(set);
01501 }

struct isl_set* isl_set_dup ( struct isl_set *  set  )  [read]

Definition at line 1423 of file isl_map.c.

01424 {
01425         int i;
01426         struct isl_set *dup;
01427 
01428         if (!set)
01429                 return NULL;
01430 
01431         dup = isl_set_alloc_dim(isl_dim_copy(set->dim), set->n, set->flags);
01432         if (!dup)
01433                 return NULL;
01434         for (i = 0; i < set->n; ++i)
01435                 dup = isl_set_add(dup, isl_basic_set_copy(set->p[i]));
01436         return dup;
01437 }

struct isl_set* isl_set_from_basic_set ( struct isl_basic_set *  bset  )  [read]

Definition at line 1439 of file isl_map.c.

01440 {
01441         struct isl_set *set;
01442 
01443         if (!bset)
01444                 return NULL;
01445 
01446         set = isl_set_alloc_dim(isl_dim_copy(bset->dim), 1, ISL_MAP_DISJOINT);
01447         if (!set) {
01448                 isl_basic_set_free(bset);
01449                 return NULL;
01450         }
01451         return isl_set_add(set, bset);
01452 }

struct isl_basic_set* isl_set_affine_hull ( struct isl_set *  set  )  [read]

Definition at line 622 of file isl_affine_hull.c.

00623 {
00624         return (struct isl_basic_set *)
00625                 isl_map_affine_hull((struct isl_map *)set);
00626 }

struct isl_basic_set* isl_set_convex_hull ( struct isl_set *  set  )  [read]

Definition at line 1964 of file isl_convex_hull.c.

01965 {
01966         return (struct isl_basic_set *)
01967                 isl_map_convex_hull((struct isl_map *)set);
01968 }

struct isl_basic_set* isl_set_simple_hull ( struct isl_set *  set  )  [read]

Definition at line 2331 of file isl_convex_hull.c.

02332 {
02333         return (struct isl_basic_set *)
02334                 isl_map_simple_hull((struct isl_map *)set);
02335 }

struct isl_basic_set* isl_set_bounded_simple_hull ( struct isl_set *  set  )  [read]

Definition at line 2352 of file isl_convex_hull.c.

02353 {
02354         int i, j;
02355         struct isl_basic_set *hull;
02356         unsigned nparam, left;
02357         int removed_divs = 0;
02358 
02359         hull = isl_set_simple_hull(isl_set_copy(set));
02360         if (!hull)
02361                 goto error;
02362 
02363         nparam = isl_basic_set_dim(hull, isl_dim_param);
02364         for (i = 0; i < isl_basic_set_dim(hull, isl_dim_set); ++i) {
02365                 int lower = 0, upper = 0;
02366                 struct isl_basic_set *bounds;
02367 
02368                 left = isl_basic_set_total_dim(hull) - nparam - i - 1;
02369                 for (j = 0; j < hull->n_eq; ++j) {
02370                         if (isl_int_is_zero(hull->eq[j][1 + nparam + i]))
02371                                 continue;
02372                         if (isl_seq_first_non_zero(hull->eq[j]+1+nparam+i+1,
02373                                                     left) == -1)
02374                                 break;
02375                 }
02376                 if (j < hull->n_eq)
02377                         continue;
02378 
02379                 for (j = 0; j < hull->n_ineq; ++j) {
02380                         if (isl_int_is_zero(hull->ineq[j][1 + nparam + i]))
02381                                 continue;
02382                         if (isl_seq_first_non_zero(hull->ineq[j]+1+nparam+i+1,
02383                                                     left) != -1 ||
02384                             isl_seq_first_non_zero(hull->ineq[j]+1+nparam,
02385                                                     i) != -1)
02386                                 continue;
02387                         if (isl_int_is_pos(hull->ineq[j][1 + nparam + i]))
02388                                 lower = 1;
02389                         else
02390                                 upper = 1;
02391                         if (lower && upper)
02392                                 break;
02393                 }
02394 
02395                 if (lower && upper)
02396                         continue;
02397 
02398                 if (!removed_divs) {
02399                         set = isl_set_remove_divs(set);
02400                         if (!set)
02401                                 goto error;
02402                         removed_divs = 1;
02403                 }
02404                 bounds = set_bounds(set, i);
02405                 hull = isl_basic_set_intersect(hull, bounds);
02406                 if (!hull)
02407                         goto error;
02408         }
02409 
02410         isl_set_free(set);
02411         return hull;
02412 error:
02413         isl_set_free(set);
02414         return NULL;
02415 }

struct isl_set* isl_set_union_disjoint ( struct isl_set *  set1,
struct isl_set *  set2 
) [read]

Definition at line 3108 of file isl_map.c.

03110 {
03111         return (struct isl_set *)
03112                 isl_map_union_disjoint(
03113                         (struct isl_map *)set1, (struct isl_map *)set2);
03114 }

struct isl_set* isl_set_union ( struct isl_set *  set1,
struct isl_set *  set2 
) [read]

Definition at line 3116 of file isl_map.c.

03117 {
03118         return (struct isl_set *)
03119                 isl_map_union((struct isl_map *)set1, (struct isl_map *)set2);
03120 }

struct isl_set* isl_set_product ( struct isl_set *  set1,
struct isl_set *  set2 
) [read]

Definition at line 4573 of file isl_map.c.

04574 {
04575         return (struct isl_set *)isl_map_product((struct isl_map *)set1,
04576                                                  (struct isl_map *)set2);
04577 }

struct isl_set* isl_set_intersect ( struct isl_set *  set1,
struct isl_set *  set2 
) [read]

Definition at line 1757 of file isl_map.c.

01758 {
01759         return (struct isl_set *)
01760                 isl_map_intersect((struct isl_map *)set1,
01761                                   (struct isl_map *)set2);
01762 }

struct isl_set* isl_set_subtract ( struct isl_set *  set1,
struct isl_set *  set2 
) [read]

Definition at line 3853 of file isl_map.c.

03854 {
03855         return (struct isl_set *)
03856                 isl_map_subtract(
03857                         (struct isl_map *)set1, (struct isl_map *)set2);
03858 }

struct isl_set* isl_set_apply ( struct isl_set *  set,
struct isl_map *  map 
) [read]

Definition at line 3860 of file isl_map.c.

03861 {
03862         if (!set || !map)
03863                 goto error;
03864         isl_assert(set->ctx, isl_map_compatible_domain(map, set), goto error);
03865         map = isl_map_intersect_domain(map, set);
03866         set = isl_map_range(map);
03867         return set;
03868 error:
03869         isl_set_free(set);
03870         isl_map_free(map);
03871         return NULL;
03872 }

struct isl_set* isl_set_fix_dim_si ( struct isl_set *  set,
unsigned  dim,
int  value 
) [read]

Definition at line 2838 of file isl_map.c.

02839 {
02840         return (struct isl_set *)
02841                 isl_map_fix_si((struct isl_map *)set, isl_dim_set, dim, value);
02842 }

struct isl_set* isl_set_lower_bound_dim ( struct isl_set *  set,
unsigned  dim,
isl_int  value 
) [read]

Definition at line 2865 of file isl_map.c.

02867 {
02868         int i;
02869 
02870         set = isl_set_cow(set);
02871         if (!set)
02872                 return NULL;
02873 
02874         isl_assert(set->ctx, dim < isl_set_n_dim(set), goto error);
02875         for (i = 0; i < set->n; ++i) {
02876                 set->p[i] = isl_basic_set_lower_bound_dim(set->p[i], dim, value);
02877                 if (!set->p[i])
02878                         goto error;
02879         }
02880         return set;
02881 error:
02882         isl_set_free(set);
02883         return NULL;
02884 }

struct isl_basic_set* isl_basic_set_remove_dims ( struct isl_basic_set *  bset,
unsigned  first,
unsigned  n 
) [read]

Definition at line 1214 of file isl_map.c.

01216 {
01217         unsigned nparam = isl_basic_set_n_param(bset);
01218         bset = isl_basic_set_eliminate_vars(bset, nparam + first, n);
01219         bset = isl_basic_set_drop_dims(bset, first, n);
01220         return bset;
01221 }

struct isl_basic_set* isl_basic_set_remove_divs ( struct isl_basic_set *  bset  )  [read]

Definition at line 1127 of file isl_map.c.

01128 {
01129         bset = isl_basic_set_eliminate_vars(bset, isl_dim_total(bset->dim),
01130                                                 bset->n_div);
01131         if (!bset)
01132                 return NULL;
01133         bset->n_div = 0;
01134         return bset;
01135 }

struct isl_set* isl_set_eliminate_dims ( struct isl_set *  set,
unsigned  first,
unsigned  n 
) [read]

Definition at line 1089 of file isl_map.c.

01091 {
01092         int i;
01093         unsigned nparam;
01094 
01095         if (!set)
01096                 return NULL;
01097         if (n == 0)
01098                 return set;
01099 
01100         set = isl_set_cow(set);
01101         if (!set)
01102                 return NULL;
01103         isl_assert(set->ctx, first+n <= isl_set_n_dim(set), goto error);
01104         nparam = isl_set_n_param(set);
01105         
01106         for (i = 0; i < set->n; ++i) {
01107                 set->p[i] = isl_basic_set_eliminate_vars(set->p[i],
01108                                                             nparam + first, n);
01109                 if (!set->p[i])
01110                         goto error;
01111         }
01112         return set;
01113 error:
01114         isl_set_free(set);
01115         return NULL;
01116 }

struct isl_set* isl_set_remove_dims ( struct isl_set *  set,
unsigned  first,
unsigned  n 
) [read]

Definition at line 1119 of file isl_map.c.

01121 {
01122         set = isl_set_eliminate_dims(set, first, n);
01123         set = isl_set_drop_dims(set, first, n);
01124         return set;
01125 }

struct isl_set* isl_set_remove_divs ( struct isl_set *  set  )  [read]

Definition at line 1137 of file isl_map.c.

01138 {
01139         int i;
01140 
01141         if (!set)
01142                 return NULL;
01143         if (set->n == 0)
01144                 return set;
01145 
01146         set = isl_set_cow(set);
01147         if (!set)
01148                 return NULL;
01149         
01150         for (i = 0; i < set->n; ++i) {
01151                 set->p[i] = isl_basic_set_remove_divs(set->p[i]);
01152                 if (!set->p[i])
01153                         goto error;
01154         }
01155         return set;
01156 error:
01157         isl_set_free(set);
01158         return NULL;
01159 }

void isl_set_dump ( struct isl_set *  set,
FILE *  out,
int  indent 
)

Definition at line 1503 of file isl_map.c.

01504 {
01505         int i;
01506 
01507         if (!set) {
01508                 fprintf(out, "null set\n");
01509                 return;
01510         }
01511 
01512         fprintf(out, "%*s", indent, "");
01513         fprintf(out, "ref: %d, n: %d, nparam: %d, dim: %d, flags: %x\n",
01514                         set->ref, set->n, set->dim->nparam, set->dim->n_out,
01515                         set->flags);
01516         for (i = 0; i < set->n; ++i) {
01517                 fprintf(out, "%*s", indent, "");
01518                 fprintf(out, "basic set %d:\n", i);
01519                 isl_basic_set_dump(set->p[i], out, indent+4);
01520         }
01521 }

struct isl_set* isl_set_swap_vars ( struct isl_set *  set,
unsigned  n 
) [read]

Definition at line 1017 of file isl_map.c.

01018 {
01019         int i;
01020         set = isl_set_cow(set);
01021         if (!set)
01022                 return NULL;
01023 
01024         for (i = 0; i < set->n; ++i) {
01025                 set->p[i] = isl_basic_set_swap_vars(set->p[i], n);
01026                 if (!set->p[i]) {
01027                         isl_set_free(set);
01028                         return NULL;
01029                 }
01030         }
01031         ISL_F_CLR(set, ISL_SET_NORMALIZED);
01032         return set;
01033 }

int isl_set_is_empty ( struct isl_set *  set  ) 

Definition at line 3424 of file isl_map.c.

03425 {
03426         return isl_map_is_empty((struct isl_map *)set);
03427 }

int isl_set_is_subset ( struct isl_set *  set1,
struct isl_set *  set2 
)

Definition at line 3354 of file isl_map.c.

03355 {
03356         return isl_map_is_subset(
03357                         (struct isl_map *)set1, (struct isl_map *)set2);
03358 }

int isl_set_is_equal ( struct isl_set *  set1,
struct isl_set *  set2 
)

Definition at line 3349 of file isl_map.c.

03350 {
03351         return isl_map_is_equal((struct isl_map *)set1, (struct isl_map *)set2);
03352 }

struct isl_set* isl_basic_set_compute_divs ( struct isl_basic_set *  bset  )  [read]

Definition at line 3006 of file isl_map.c.

03007 {
03008         return (struct isl_set *)
03009                 isl_basic_map_compute_divs((struct isl_basic_map *)bset);
03010 }

struct isl_set* isl_set_compute_divs ( struct isl_set *  set  )  [read]

Definition at line 3012 of file isl_map.c.

03013 {
03014         return (struct isl_set *)
03015                 isl_map_compute_divs((struct isl_map *)set);
03016 }

struct isl_basic_set* isl_set_copy_basic_set ( struct isl_set *  set  )  [read]

Definition at line 3914 of file isl_map.c.

03915 {
03916         (struct isl_basic_set *)isl_map_copy_basic_map((struct isl_map *)set);
03917 }

struct isl_set* isl_set_drop_basic_set ( struct isl_set *  set,
struct isl_basic_set *  bset 
) [read]

Definition at line 3948 of file isl_map.c.

03950 {
03951         (struct isl_set *)isl_map_drop_basic_map((struct isl_map *)set,
03952                                                 (struct isl_basic_map *)bset);
03953 }

int isl_set_fast_dim_is_fixed ( struct isl_set *  set,
unsigned  dim,
isl_int *  val 
)

Definition at line 4107 of file isl_map.c.

04108 {
04109         return isl_set_fast_has_fixed_var(set, isl_set_n_param(set) + dim, val);
04110 }

int isl_set_fast_dim_has_fixed_lower_bound ( struct isl_set *  set,
unsigned  dim,
isl_int *  val 
)

Definition at line 4165 of file isl_map.c.

04167 {
04168         int i;
04169         isl_int v;
04170         isl_int tmp;
04171         int fixed;
04172 
04173         if (!set)
04174                 return -1;
04175         if (set->n == 0)
04176                 return 0;
04177         if (set->n == 1)
04178                 return isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[0],
04179                                                                 dim, val);
04180         isl_int_init(v);
04181         isl_int_init(tmp);
04182         fixed = isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[0],
04183                                                                 dim, &v);
04184         for (i = 1; fixed == 1 && i < set->n; ++i) {
04185                 fixed = isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[i],
04186                                                                 dim, &tmp);
04187                 if (fixed == 1 && isl_int_ne(tmp, v))
04188                         fixed = 0;
04189         }
04190         if (val)
04191                 isl_int_set(*val, v);
04192         isl_int_clear(tmp);
04193         isl_int_clear(v);
04194         return fixed;
04195 }

struct isl_basic_set* isl_basic_set_gist ( struct isl_basic_set *  bset,
struct isl_basic_set *  context 
) [read]

Definition at line 1742 of file isl_map_simplify.c.

01744 {
01745         return (struct isl_basic_set *)isl_basic_map_gist(
01746                 (struct isl_basic_map *)bset, (struct isl_basic_map *)context);
01747 }

struct isl_set* isl_set_gist ( struct isl_set *  set,
struct isl_basic_set *  context 
) [read]

Definition at line 1749 of file isl_map_simplify.c.

01750 {
01751         return (struct isl_set *)isl_map_gist((struct isl_map *)set,
01752                                         (struct isl_basic_map *)context);
01753 }

int isl_basic_set_dim_residue_class ( struct isl_basic_set *  bset,
int  pos,
isl_int *  modulo,
isl_int *  residue 
)

Definition at line 554 of file isl_equalities.c.

00556 {
00557         struct isl_ctx *ctx;
00558         struct isl_mat *H = NULL, *U = NULL, *C, *H1, *U1;
00559         unsigned total;
00560         unsigned nparam;
00561 
00562         if (!bset || !modulo || !residue)
00563                 return -1;
00564 
00565         ctx = bset->ctx;
00566         total = isl_basic_set_total_dim(bset);
00567         nparam = isl_basic_set_n_param(bset);
00568         H = isl_mat_sub_alloc(ctx, bset->eq, 0, bset->n_eq, 1, total);
00569         H = isl_mat_left_hermite(ctx, H, 0, &U, NULL);
00570         if (!H)
00571                 return -1;
00572 
00573         isl_seq_gcd(U->row[nparam + pos]+bset->n_eq,
00574                         total-bset->n_eq, modulo);
00575         if (isl_int_is_zero(*modulo) || isl_int_is_one(*modulo)) {
00576                 isl_int_set_si(*residue, 0);
00577                 isl_mat_free(ctx, H);
00578                 isl_mat_free(ctx, U);
00579                 return 0;
00580         }
00581 
00582         C = isl_mat_alloc(ctx, 1+bset->n_eq, 1);
00583         if (!C)
00584                 goto error;
00585         isl_int_set_si(C->row[0][0], 1);
00586         isl_mat_sub_neg(ctx, C->row+1, bset->eq, bset->n_eq, 0, 0, 1);
00587         H1 = isl_mat_sub_alloc(ctx, H->row, 0, H->n_row, 0, H->n_row);
00588         H1 = isl_mat_lin_to_aff(ctx, H1);
00589         C = isl_mat_inverse_product(ctx, H1, C);
00590         isl_mat_free(ctx, H);
00591         U1 = isl_mat_sub_alloc(ctx, U->row, nparam+pos, 1, 0, bset->n_eq);
00592         U1 = isl_mat_lin_to_aff(ctx, U1);
00593         isl_mat_free(ctx, U);
00594         C = isl_mat_product(ctx, U1, C);
00595         if (!C)
00596                 goto error;
00597         if (!isl_int_is_divisible_by(C->row[1][0], C->row[0][0])) {
00598                 bset = isl_basic_set_copy(bset);
00599                 bset = isl_basic_set_set_to_empty(bset);
00600                 isl_basic_set_free(bset);
00601                 isl_int_set_si(*modulo, 0);
00602                 isl_int_set_si(*residue, 0);
00603                 return 0;
00604         }
00605         isl_int_divexact(*residue, C->row[1][0], C->row[0][0]);
00606         isl_int_fdiv_r(*residue, *residue, *modulo);
00607         isl_mat_free(ctx, C);
00608         return 0;
00609 error:
00610         isl_mat_free(ctx, H);
00611         isl_mat_free(ctx, U);
00612         return -1;
00613 }

struct isl_set* isl_set_coalesce ( struct isl_set *  set  )  [read]

Definition at line 618 of file isl_coalesce.c.

00619 {
00620         (struct isl_set *)isl_map_coalesce((struct isl_map *)set);
00621 }

int isl_set_fast_is_equal ( struct isl_set *  set1,
struct isl_set *  set2 
)

Definition at line 4394 of file isl_map.c.

04395 {
04396         return isl_map_fast_is_equal((struct isl_map *)set1,
04397                                                 (struct isl_map *)set2);
04398 }

int isl_set_fast_is_disjoint ( struct isl_set *  set1,
struct isl_set *  set2 
)

Definition at line 1853 of file isl_map_simplify.c.

01854 {
01855         return isl_map_fast_is_disjoint((struct isl_map *)set1,
01856                                         (struct isl_map *)set2);
01857 }

uint32_t isl_set_get_hash ( struct isl_set *  set  ) 

Definition at line 4617 of file isl_map.c.

04618 {
04619         int i;
04620         uint32_t hash;
04621 
04622         if (!set)
04623                 return 0;
04624         set = isl_set_copy(set);
04625         set = isl_set_normalize(set);
04626         if (!set)
04627                 return 0;
04628 
04629         hash = isl_hash_init();
04630         for (i = 0; i < set->n; ++i) {
04631                 uint32_t bset_hash;
04632                 bset_hash = isl_basic_set_get_hash(set->p[i]);
04633                 isl_hash_hash(hash, bset_hash);
04634         }
04635                 
04636         isl_set_free(set);
04637 
04638         return hash;
04639 }

int isl_set_dim_is_unique ( struct isl_set *  set,
unsigned  dim 
)

Definition at line 4664 of file isl_map.c.

04665 {
04666         int i;
04667 
04668         if (!set)
04669                 return -1;
04670         for (i = 0; i < set->n; ++i) {
04671                 int unique;
04672                 unique = isl_basic_set_dim_is_unique(set->p[i], dim);
04673                 if (unique != 1)
04674                         return unique;
04675         }
04676         return 1;
04677 }

Generated on Fri Jul 17 16:32:57 2009 for CLooG / ISL by  doxygen 1.5.9