isl_map_private.h File Reference

#include "isl_set.h"
#include "isl_map.h"
#include "isl_vec.h"

Go to the source code of this file.

Functions

unsigned isl_basic_map_offset (struct isl_basic_map *bmap, enum isl_dim_type type)
int isl_map_compatible_domain (struct isl_map *map, struct isl_set *set)
int isl_basic_map_compatible_domain (struct isl_basic_map *bmap, struct isl_basic_set *bset)
int isl_basic_map_compatible_range (struct isl_basic_map *bmap, struct isl_basic_set *bset)
struct isl_basic_map * isl_basic_map_extend_dim (struct isl_basic_map *base, struct isl_dim *dim, unsigned extra, unsigned n_eq, unsigned n_ineq)
struct isl_basic_set * isl_basic_set_extend_dim (struct isl_basic_set *base, struct isl_dim *dim, unsigned extra, unsigned n_eq, unsigned n_ineq)
struct isl_basic_set * isl_basic_set_add_constraints (struct isl_basic_set *bset1, struct isl_basic_set *bset2, unsigned pos)
int isl_basic_set_contains (struct isl_basic_set *bset, struct isl_vec *vec)
struct isl_basic_set * isl_basic_set_alloc_dim (struct isl_dim *dim, unsigned extra, unsigned n_eq, unsigned n_ineq)
struct isl_set * isl_set_alloc_dim (struct isl_dim *dim, int n, unsigned flags)
struct isl_basic_map * isl_basic_map_alloc_dim (struct isl_dim *dim, unsigned extra, unsigned n_eq, unsigned n_ineq)
struct isl_map * isl_map_alloc_dim (struct isl_dim *dim, int n, unsigned flags)
unsigned isl_basic_map_total_dim (const struct isl_basic_map *bmap)
int isl_basic_map_alloc_equality (struct isl_basic_map *bmap)
int isl_basic_set_alloc_equality (struct isl_basic_set *bset)
int isl_basic_set_free_inequality (struct isl_basic_set *bset, unsigned n)
int isl_basic_map_free_equality (struct isl_basic_map *bmap, unsigned n)
int isl_basic_set_free_equality (struct isl_basic_set *bset, unsigned n)
int isl_basic_set_alloc_inequality (struct isl_basic_set *bset)
int isl_basic_map_alloc_inequality (struct isl_basic_map *bmap)
int isl_basic_map_free_inequality (struct isl_basic_map *bmap, unsigned n)
int isl_basic_map_alloc_div (struct isl_basic_map *bmap)
int isl_basic_set_alloc_div (struct isl_basic_set *bset)
int isl_basic_map_free_div (struct isl_basic_map *bmap, unsigned n)
void isl_basic_map_inequality_to_equality (struct isl_basic_map *bmap, unsigned pos)
int isl_basic_map_drop_equality (struct isl_basic_map *bmap, unsigned pos)
int isl_basic_set_drop_equality (struct isl_basic_set *bset, unsigned pos)
int isl_basic_set_drop_inequality (struct isl_basic_set *bset, unsigned pos)
int isl_basic_map_drop_inequality (struct isl_basic_map *bmap, unsigned pos)
int isl_inequality_negate (struct isl_basic_map *bmap, unsigned pos)
struct isl_basic_set * isl_basic_set_cow (struct isl_basic_set *bset)
struct isl_basic_map * isl_basic_map_cow (struct isl_basic_map *bmap)
struct isl_set * isl_set_cow (struct isl_set *set)
struct isl_map * isl_map_cow (struct isl_map *map)
struct isl_basic_map * isl_basic_map_set_to_empty (struct isl_basic_map *bmap)
struct isl_basic_set * isl_basic_set_set_to_empty (struct isl_basic_set *bset)
struct isl_map * isl_basic_map_compute_divs (struct isl_basic_map *bmap)
struct isl_map * isl_map_compute_divs (struct isl_map *map)
struct isl_basic_map * isl_basic_map_align_divs (struct isl_basic_map *dst, struct isl_basic_map *src)
struct isl_basic_set * isl_basic_set_align_divs (struct isl_basic_set *dst, struct isl_basic_set *src)
struct isl_map * isl_map_align_divs (struct isl_map *map)
struct isl_set * isl_set_align_divs (struct isl_set *set)
struct isl_basic_map * isl_basic_map_gauss (struct isl_basic_map *bmap, int *progress)
struct isl_basic_set * isl_basic_set_gauss (struct isl_basic_set *bset, int *progress)
struct isl_basic_map * isl_basic_map_normalize_constraints (struct isl_basic_map *bmap)
struct isl_basic_set * isl_basic_set_normalize_constraints (struct isl_basic_set *bset)
struct isl_basic_map * isl_basic_map_implicit_equalities (struct isl_basic_map *bmap)
struct isl_basic_set * isl_basic_map_underlying_set (struct isl_basic_map *bmap)
struct isl_set * isl_map_underlying_set (struct isl_map *map)
struct isl_basic_map * isl_basic_map_overlying_set (struct isl_basic_set *bset, struct isl_basic_map *like)
struct isl_basic_map * isl_basic_map_drop (struct isl_basic_map *bmap, enum isl_dim_type type, unsigned first, unsigned n)
struct isl_basic_set * isl_basic_set_drop_dims (struct isl_basic_set *bset, unsigned first, unsigned n)
struct isl_set * isl_set_drop_dims (struct isl_set *set, unsigned first, unsigned n)
struct isl_map * isl_map_drop_inputs (struct isl_map *map, unsigned first, unsigned n)
struct isl_map * isl_map_drop (struct isl_map *map, enum isl_dim_type type, unsigned first, unsigned n)
struct isl_map * isl_map_remove_empty_parts (struct isl_map *map)
struct isl_set * isl_set_remove_empty_parts (struct isl_set *set)
struct isl_set * isl_set_normalize (struct isl_set *set)
struct isl_set * isl_set_drop_vars (struct isl_set *set, unsigned first, unsigned n)
struct isl_basic_map * isl_basic_map_eliminate_vars (struct isl_basic_map *bmap, unsigned pos, unsigned n)
struct isl_basic_set * isl_basic_set_eliminate_vars (struct isl_basic_set *bset, unsigned pos, unsigned n)
int isl_basic_set_constraint_is_redundant (struct isl_basic_set **bset, isl_int *c, isl_int *opt_n, isl_int *opt_d)
struct isl_basic_map * isl_basic_map_drop_redundant_divs (struct isl_basic_map *bmap)

Function Documentation

unsigned isl_basic_map_offset ( struct isl_basic_map *  bmap,
enum isl_dim_type  type 
)

Definition at line 115 of file isl_map.c.

00117 {
00118         struct isl_dim *dim = bmap->dim;
00119         switch (type) {
00120         case isl_dim_param:     return 1;
00121         case isl_dim_in:        return 1 + dim->nparam;
00122         case isl_dim_out:       return 1 + dim->nparam + dim->n_in;
00123         case isl_dim_div:       return 1 + dim->nparam + dim->n_in + dim->n_out;
00124         }
00125 }

int isl_map_compatible_domain ( struct isl_map *  map,
struct isl_set *  set 
)

Definition at line 203 of file isl_map.c.

00204 {
00205         return map->dim->n_in == set->dim->n_out &&
00206                map->dim->nparam == set->dim->nparam;
00207 }

int isl_basic_map_compatible_domain ( struct isl_basic_map *  bmap,
struct isl_basic_set *  bset 
)

Definition at line 209 of file isl_map.c.

00211 {
00212         return bmap->dim->n_in == bset->dim->n_out &&
00213                bmap->dim->nparam == bset->dim->nparam;
00214 }

int isl_basic_map_compatible_range ( struct isl_basic_map *  bmap,
struct isl_basic_set *  bset 
)

Definition at line 216 of file isl_map.c.

00218 {
00219         return bmap->dim->n_out == bset->dim->n_out &&
00220                bmap->dim->nparam == bset->dim->nparam;
00221 }

struct isl_basic_map* isl_basic_map_extend_dim ( struct isl_basic_map *  base,
struct isl_dim *  dim,
unsigned  extra,
unsigned  n_eq,
unsigned  n_ineq 
) [read]

Definition at line 818 of file isl_map.c.

00821 {
00822         struct isl_basic_map *ext;
00823         unsigned flags;
00824         int dims_ok;
00825 
00826         if (!dim)
00827                 goto error;
00828 
00829         if (!base)
00830                 goto error;
00831 
00832         dims_ok = isl_dim_equal(base->dim, dim) &&
00833                   base->extra >= base->n_div + extra;
00834 
00835         if (dims_ok && room_for_con(base, n_eq + n_ineq) &&
00836                        room_for_ineq(base, n_ineq)) {
00837                 isl_dim_free(dim);
00838                 return base;
00839         }
00840 
00841         isl_assert(base->ctx, base->dim->nparam <= dim->nparam, goto error);
00842         isl_assert(base->ctx, base->dim->n_in <= dim->n_in, goto error);
00843         isl_assert(base->ctx, base->dim->n_out <= dim->n_out, goto error);
00844         extra += base->extra;
00845         n_eq += base->n_eq;
00846         n_ineq += base->n_ineq;
00847 
00848         ext = isl_basic_map_alloc_dim(dim, extra, n_eq, n_ineq);
00849         dim = NULL;
00850         if (!ext)
00851                 goto error;
00852 
00853         flags = base->flags;
00854         ext = add_constraints(ext, base, 0, 0);
00855         if (ext) {
00856                 ext->flags = flags;
00857                 ISL_F_CLR(ext, ISL_BASIC_SET_FINAL);
00858         }
00859 
00860         return ext;
00861 
00862 error:
00863         isl_dim_free(dim);
00864         isl_basic_map_free(base);
00865         return NULL;
00866 }

struct isl_basic_set* isl_basic_set_extend_dim ( struct isl_basic_set *  base,
struct isl_dim *  dim,
unsigned  extra,
unsigned  n_eq,
unsigned  n_ineq 
) [read]

Definition at line 868 of file isl_map.c.

00871 {
00872         return (struct isl_basic_set *)
00873                 isl_basic_map_extend_dim((struct isl_basic_map *)base, dim,
00874                                                         extra, n_eq, n_ineq);
00875 }

struct isl_basic_set* isl_basic_set_add_constraints ( struct isl_basic_set *  bset1,
struct isl_basic_set *  bset2,
unsigned  pos 
) [read]

Definition at line 810 of file isl_map.c.

00812 {
00813         return (struct isl_basic_set *)
00814                 add_constraints((struct isl_basic_map *)bset1,
00815                                 (struct isl_basic_map *)bset2, 0, pos);
00816 }

int isl_basic_set_contains ( struct isl_basic_set *  bset,
struct isl_vec *  vec 
)

Definition at line 1641 of file isl_map.c.

01642 {
01643         return basic_map_contains((struct isl_basic_map *)bset, vec);
01644 }

struct isl_basic_set* isl_basic_set_alloc_dim ( struct isl_dim *  dim,
unsigned  extra,
unsigned  n_eq,
unsigned  n_ineq 
) [read]

Definition at line 312 of file isl_map.c.

00314 {
00315         struct isl_basic_map *bmap;
00316         if (!dim)
00317                 return NULL;
00318         isl_assert(dim->ctx, dim->n_in == 0, return NULL);
00319         bmap = isl_basic_map_alloc_dim(dim, extra, n_eq, n_ineq);
00320         return (struct isl_basic_set *)bmap;
00321 }

struct isl_set* isl_set_alloc_dim ( struct isl_dim *  dim,
int  n,
unsigned  flags 
) [read]

Definition at line 1382 of file isl_map.c.

01383 {
01384         struct isl_set *set;
01385 
01386         if (!dim)
01387                 return NULL;
01388         isl_assert(dim->ctx, dim->n_in == 0, return NULL);
01389         isl_assert(dim->ctx, n >= 0, return NULL);
01390         set = isl_alloc(dim->ctx, struct isl_set,
01391                         sizeof(struct isl_set) +
01392                         n * sizeof(struct isl_basic_set *));
01393         if (!set)
01394                 goto error;
01395 
01396         set->ctx = dim->ctx;
01397         isl_ctx_ref(set->ctx);
01398         set->ref = 1;
01399         set->size = n;
01400         set->n = 0;
01401         set->dim = dim;
01402         set->flags = flags;
01403         return set;
01404 error:
01405         isl_dim_free(dim);
01406         return NULL;
01407 }

struct isl_basic_map* isl_basic_map_alloc_dim ( struct isl_dim *  dim,
unsigned  extra,
unsigned  n_eq,
unsigned  n_ineq 
) [read]

Definition at line 323 of file isl_map.c.

00325 {
00326         struct isl_basic_map *bmap;
00327 
00328         if (!dim)
00329                 return NULL;
00330         bmap = isl_alloc_type(dim->ctx, struct isl_basic_map);
00331         if (!bmap)
00332                 goto error;
00333         bmap->dim = dim;
00334 
00335         return basic_map_init(dim->ctx, bmap, extra, n_eq, n_ineq);
00336 error:
00337         isl_dim_free(dim);
00338         return NULL;
00339 }

struct isl_map* isl_map_alloc_dim ( struct isl_dim *  dim,
int  n,
unsigned  flags 
) [read]

Definition at line 2516 of file isl_map.c.

02517 {
02518         struct isl_map *map;
02519 
02520         if (!dim)
02521                 return NULL;
02522         isl_assert(dim->ctx, n >= 0, return NULL);
02523         map = isl_alloc(dim->ctx, struct isl_map,
02524                         sizeof(struct isl_map) +
02525                         n * sizeof(struct isl_basic_map *));
02526         if (!map)
02527                 goto error;
02528 
02529         map->ctx = dim->ctx;
02530         isl_ctx_ref(map->ctx);
02531         map->ref = 1;
02532         map->size = n;
02533         map->n = 0;
02534         map->dim = dim;
02535         map->flags = flags;
02536         return map;
02537 error:
02538         isl_dim_free(dim);
02539         return NULL;
02540 }

unsigned isl_basic_map_total_dim ( const struct isl_basic_map *  bmap  ) 

Definition at line 183 of file isl_map.c.

00184 {
00185         return isl_dim_total(bmap->dim) + bmap->n_div;
00186 }

int isl_basic_map_alloc_equality ( struct isl_basic_map *  bmap  ) 

Definition at line 473 of file isl_map.c.

00474 {
00475         struct isl_ctx *ctx;
00476         if (!bmap)
00477                 return -1;
00478         ctx = bmap->ctx;
00479         isl_assert(ctx, room_for_con(bmap, 1), return -1);
00480         isl_assert(ctx, (bmap->eq - bmap->ineq) + bmap->n_eq <= bmap->c_size,
00481                         return -1);
00482         ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
00483         ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
00484         ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
00485         ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
00486         ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
00487         if ((bmap->eq - bmap->ineq) + bmap->n_eq == bmap->c_size) {
00488                 isl_int *t;
00489                 int j = isl_basic_map_alloc_inequality(bmap);
00490                 if (j < 0)
00491                         return -1;
00492                 t = bmap->ineq[j];
00493                 bmap->ineq[j] = bmap->ineq[bmap->n_ineq - 1];
00494                 bmap->ineq[bmap->n_ineq - 1] = bmap->eq[-1];
00495                 bmap->eq[-1] = t;
00496                 bmap->n_eq++;
00497                 bmap->n_ineq--;
00498                 bmap->eq--;
00499                 return 0;
00500         }
00501         isl_seq_clr(bmap->eq[bmap->n_eq] + 1 + isl_basic_map_total_dim(bmap),
00502                       bmap->extra - bmap->n_div);
00503         return bmap->n_eq++;
00504 }

int isl_basic_set_alloc_equality ( struct isl_basic_set *  bset  ) 

Definition at line 506 of file isl_map.c.

00507 {
00508         return isl_basic_map_alloc_equality((struct isl_basic_map *)bset);
00509 }

int isl_basic_set_free_inequality ( struct isl_basic_set *  bset,
unsigned  n 
)

Definition at line 600 of file isl_map.c.

00601 {
00602         return isl_basic_map_free_inequality((struct isl_basic_map *)bset, n);
00603 }

int isl_basic_map_free_equality ( struct isl_basic_map *  bmap,
unsigned  n 
)

Definition at line 511 of file isl_map.c.

00512 {
00513         if (!bmap)
00514                 return -1;
00515         isl_assert(bmap->ctx, n <= bmap->n_eq, return -1);
00516         bmap->n_eq -= n;
00517         return 0;
00518 }

int isl_basic_set_free_equality ( struct isl_basic_set *  bset,
unsigned  n 
)

Definition at line 520 of file isl_map.c.

00521 {
00522         return isl_basic_map_free_equality((struct isl_basic_map *)bset, n);
00523 }

int isl_basic_set_alloc_inequality ( struct isl_basic_set *  bset  ) 

Definition at line 586 of file isl_map.c.

00587 {
00588         return isl_basic_map_alloc_inequality((struct isl_basic_map *)bset);
00589 }

int isl_basic_map_alloc_inequality ( struct isl_basic_map *  bmap  ) 

Definition at line 569 of file isl_map.c.

00570 {
00571         struct isl_ctx *ctx;
00572         if (!bmap)
00573                 return -1;
00574         ctx = bmap->ctx;
00575         isl_assert(ctx, room_for_ineq(bmap, 1), return -1);
00576         ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
00577         ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
00578         ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
00579         ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
00580         isl_seq_clr(bmap->ineq[bmap->n_ineq] +
00581                       1 + isl_basic_map_total_dim(bmap),
00582                       bmap->extra - bmap->n_div);
00583         return bmap->n_ineq++;
00584 }

int isl_basic_map_free_inequality ( struct isl_basic_map *  bmap,
unsigned  n 
)

Definition at line 591 of file isl_map.c.

00592 {
00593         if (!bmap)
00594                 return -1;
00595         isl_assert(bmap->ctx, n <= bmap->n_ineq, return -1);
00596         bmap->n_ineq -= n;
00597         return 0;
00598 }

int isl_basic_map_alloc_div ( struct isl_basic_map *  bmap  ) 

Definition at line 627 of file isl_map.c.

00628 {
00629         if (!bmap)
00630                 return -1;
00631         isl_assert(bmap->ctx, bmap->n_div < bmap->extra, return -1);
00632         isl_seq_clr(bmap->div[bmap->n_div] +
00633                       1 + 1 + isl_basic_map_total_dim(bmap),
00634                       bmap->extra - bmap->n_div);
00635         ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
00636         return bmap->n_div++;
00637 }

int isl_basic_set_alloc_div ( struct isl_basic_set *  bset  ) 

Definition at line 639 of file isl_map.c.

00640 {
00641         return isl_basic_map_alloc_div((struct isl_basic_map *)bset);
00642 }

int isl_basic_map_free_div ( struct isl_basic_map *  bmap,
unsigned  n 
)

Definition at line 644 of file isl_map.c.

00645 {
00646         if (!bmap)
00647                 return -1;
00648         isl_assert(bmap->ctx, n <= bmap->n_div, return -1);
00649         bmap->n_div -= n;
00650         return 0;
00651 }

void isl_basic_map_inequality_to_equality ( struct isl_basic_map *  bmap,
unsigned  pos 
)

Definition at line 546 of file isl_map.c.

00548 {
00549         isl_int *t;
00550 
00551         t = bmap->ineq[pos];
00552         bmap->ineq[pos] = bmap->ineq[bmap->n_ineq - 1];
00553         bmap->ineq[bmap->n_ineq - 1] = bmap->eq[-1];
00554         bmap->eq[-1] = t;
00555         bmap->n_eq++;
00556         bmap->n_ineq--;
00557         bmap->eq--;
00558         ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
00559         ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
00560         ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
00561         ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
00562 }

int isl_basic_map_drop_equality ( struct isl_basic_map *  bmap,
unsigned  pos 
)

Definition at line 525 of file isl_map.c.

00526 {
00527         isl_int *t;
00528         if (!bmap)
00529                 return -1;
00530         isl_assert(bmap->ctx, pos < bmap->n_eq, return -1);
00531 
00532         if (pos != bmap->n_eq - 1) {
00533                 t = bmap->eq[pos];
00534                 bmap->eq[pos] = bmap->eq[bmap->n_eq - 1];
00535                 bmap->eq[bmap->n_eq - 1] = t;
00536         }
00537         bmap->n_eq--;
00538         return 0;
00539 }

int isl_basic_set_drop_equality ( struct isl_basic_set *  bset,
unsigned  pos 
)

Definition at line 541 of file isl_map.c.

00542 {
00543         return isl_basic_map_drop_equality((struct isl_basic_map *)bset, pos);
00544 }

int isl_basic_set_drop_inequality ( struct isl_basic_set *  bset,
unsigned  pos 
)

Definition at line 622 of file isl_map.c.

00623 {
00624         return isl_basic_map_drop_inequality((struct isl_basic_map *)bset, pos);
00625 }

int isl_basic_map_drop_inequality ( struct isl_basic_map *  bmap,
unsigned  pos 
)

Definition at line 605 of file isl_map.c.

00606 {
00607         isl_int *t;
00608         if (!bmap)
00609                 return -1;
00610         isl_assert(bmap->ctx, pos < bmap->n_ineq, return -1);
00611 
00612         if (pos != bmap->n_ineq - 1) {
00613                 t = bmap->ineq[pos];
00614                 bmap->ineq[pos] = bmap->ineq[bmap->n_ineq - 1];
00615                 bmap->ineq[bmap->n_ineq - 1] = t;
00616                 ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
00617         }
00618         bmap->n_ineq--;
00619         return 0;
00620 }

int isl_inequality_negate ( struct isl_basic_map *  bmap,
unsigned  pos 
)

Definition at line 1369 of file isl_map.c.

01370 {
01371         unsigned total;
01372         if (!bmap)
01373                 return -1;
01374         total = isl_basic_map_total_dim(bmap);
01375         isl_assert(bmap->ctx, pos < bmap->n_ineq, return -1);
01376         isl_seq_neg(bmap->ineq[pos], bmap->ineq[pos], 1 + total);
01377         isl_int_sub_ui(bmap->ineq[pos][0], bmap->ineq[pos][0], 1);
01378         ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
01379         return 0;
01380 }

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

Definition at line 920 of file isl_map.c.

00921 {
00922         return (struct isl_basic_set *)
00923                 isl_basic_map_cow((struct isl_basic_map *)bset);
00924 }

struct isl_basic_map* isl_basic_map_cow ( struct isl_basic_map *  bmap  )  [read]

Definition at line 926 of file isl_map.c.

00927 {
00928         if (!bmap)
00929                 return NULL;
00930 
00931         if (bmap->ref > 1) {
00932                 bmap->ref--;
00933                 bmap = isl_basic_map_dup(bmap);
00934         }
00935         ISL_F_CLR(bmap, ISL_BASIC_SET_FINAL);
00936         return bmap;
00937 }

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

Definition at line 939 of file isl_map.c.

00940 {
00941         if (!set)
00942                 return NULL;
00943 
00944         if (set->ref == 1)
00945                 return set;
00946         set->ref--;
00947         return isl_set_dup(set);
00948 }

struct isl_map* isl_map_cow ( struct isl_map *  map  )  [read]

Definition at line 950 of file isl_map.c.

00951 {
00952         if (!map)
00953                 return NULL;
00954 
00955         if (map->ref == 1)
00956                 return map;
00957         map->ref--;
00958         return isl_map_dup(map);
00959 }

struct isl_basic_map* isl_basic_map_set_to_empty ( struct isl_basic_map *  bmap  )  [read]

Definition at line 1035 of file isl_map.c.

01036 {
01037         int i = 0;
01038         unsigned total;
01039         if (!bmap)
01040                 goto error;
01041         total = isl_basic_map_total_dim(bmap);
01042         isl_basic_map_free_div(bmap, bmap->n_div);
01043         isl_basic_map_free_inequality(bmap, bmap->n_ineq);
01044         if (bmap->n_eq > 0)
01045                 isl_basic_map_free_equality(bmap, bmap->n_eq-1);
01046         else {
01047                 isl_basic_map_alloc_equality(bmap);
01048                 if (i < 0)
01049                         goto error;
01050         }
01051         isl_int_set_si(bmap->eq[i][0], 1);
01052         isl_seq_clr(bmap->eq[i]+1, total);
01053         ISL_F_SET(bmap, ISL_BASIC_MAP_EMPTY);
01054         return isl_basic_map_finalize(bmap);
01055 error:
01056         isl_basic_map_free(bmap);
01057         return NULL;
01058 }

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

Definition at line 1060 of file isl_map.c.

01061 {
01062         return (struct isl_basic_set *)
01063                 isl_basic_map_set_to_empty((struct isl_basic_map *)bset);
01064 }

struct isl_map* isl_basic_map_compute_divs ( struct isl_basic_map *  bmap  )  [read]

Definition at line 2952 of file isl_map.c.

02953 {
02954         int i;
02955         unsigned off;
02956 
02957         if (!bmap)
02958                 return NULL;
02959         off = isl_dim_total(bmap->dim);
02960         for (i = 0; i < bmap->n_div; ++i) {
02961                 if (isl_int_is_zero(bmap->div[i][0]))
02962                         break;
02963                 isl_assert(bmap->ctx, isl_int_is_zero(bmap->div[i][1+1+off+i]),
02964                                 goto error);
02965         }
02966         if (i == bmap->n_div)
02967                 return isl_map_from_basic_map(bmap);
02968         bmap = isl_basic_map_drop_redundant_divs(bmap);
02969         if (!bmap)
02970                 goto error;
02971         for (i = 0; i < bmap->n_div; ++i)
02972                 if (isl_int_is_zero(bmap->div[i][0]))
02973                         break;
02974         if (i == bmap->n_div)
02975                 return isl_map_from_basic_map(bmap);
02976         struct isl_map *map = isl_pip_basic_map_compute_divs(bmap);
02977         return map;
02978 error:
02979         isl_basic_map_free(bmap);
02980         return NULL;
02981 }

struct isl_map* isl_map_compute_divs ( struct isl_map *  map  )  [read]

Definition at line 2983 of file isl_map.c.

02984 {
02985         int i;
02986         struct isl_map *res;
02987 
02988         if (!map)
02989                 return NULL;
02990         if (map->n == 0)
02991                 return map;
02992         res = isl_basic_map_compute_divs(isl_basic_map_copy(map->p[0]));
02993         for (i = 1 ; i < map->n; ++i) {
02994                 struct isl_map *r2;
02995                 r2 = isl_basic_map_compute_divs(isl_basic_map_copy(map->p[i]));
02996                 if (ISL_F_ISSET(map, ISL_MAP_DISJOINT))
02997                         res = isl_map_union_disjoint(res, r2);
02998                 else
02999                         res = isl_map_union(res, r2);
03000         }
03001         isl_map_free(map);
03002 
03003         return res;
03004 }

struct isl_basic_map* isl_basic_map_align_divs ( struct isl_basic_map *  dst,
struct isl_basic_map *  src 
) [read]

Definition at line 3630 of file isl_map.c.

03632 {
03633         int i;
03634         unsigned total = isl_dim_total(src->dim);
03635 
03636         if (!dst || !src)
03637                 goto error;
03638 
03639         if (src->n_div == 0)
03640                 return dst;
03641 
03642         for (i = 0; i < src->n_div; ++i)
03643                 isl_assert(src->ctx, !isl_int_is_zero(src->div[i][0]), goto error);
03644 
03645         src = order_divs(src);
03646         dst = isl_basic_map_cow(dst);
03647         dst = isl_basic_map_extend_dim(dst, isl_dim_copy(dst->dim),
03648                         src->n_div, 0, 2 * src->n_div);
03649         if (!dst)
03650                 return NULL;
03651         for (i = 0; i < src->n_div; ++i) {
03652                 int j = find_div(dst, src, i);
03653                 if (j < 0) {
03654                         j = isl_basic_map_alloc_div(dst);
03655                         if (j < 0)
03656                                 goto error;
03657                         isl_seq_cpy(dst->div[j], src->div[i], 1+1+total+i);
03658                         isl_seq_clr(dst->div[j]+1+1+total+i, dst->n_div - i);
03659                         if (add_div_constraints(dst, j) < 0)
03660                                 goto error;
03661                 }
03662                 if (j != i)
03663                         swap_div(dst, i, j);
03664         }
03665         return dst;
03666 error:
03667         isl_basic_map_free(dst);
03668         return NULL;
03669 }

struct isl_basic_set* isl_basic_set_align_divs ( struct isl_basic_set *  dst,
struct isl_basic_set *  src 
) [read]

Definition at line 3671 of file isl_map.c.

03673 {
03674         return (struct isl_basic_set *)isl_basic_map_align_divs(
03675                 (struct isl_basic_map *)dst, (struct isl_basic_map *)src);
03676 }

struct isl_map* isl_map_align_divs ( struct isl_map *  map  )  [read]

Definition at line 3678 of file isl_map.c.

03679 {
03680         int i;
03681 
03682         map = isl_map_compute_divs(map);
03683         map = isl_map_cow(map);
03684         if (!map)
03685                 return NULL;
03686 
03687         for (i = 1; i < map->n; ++i)
03688                 map->p[0] = isl_basic_map_align_divs(map->p[0], map->p[i]);
03689         for (i = 1; i < map->n; ++i)
03690                 map->p[i] = isl_basic_map_align_divs(map->p[i], map->p[0]);
03691 
03692         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
03693         return map;
03694 }

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

Definition at line 3696 of file isl_map.c.

03697 {
03698         return (struct isl_set *)isl_map_align_divs((struct isl_map *)set);
03699 }

struct isl_basic_map* isl_basic_map_gauss ( struct isl_basic_map *  bmap,
int *  progress 
) [read]

Definition at line 494 of file isl_map_simplify.c.

00496 {
00497         int k;
00498         int done;
00499         int last_var;
00500         unsigned total_var;
00501         unsigned total;
00502 
00503         if (!bmap)
00504                 return NULL;
00505 
00506         total = isl_basic_map_total_dim(bmap);
00507         total_var = total - bmap->n_div;
00508 
00509         last_var = total - 1;
00510         for (done = 0; done < bmap->n_eq; ++done) {
00511                 for (; last_var >= 0; --last_var) {
00512                         for (k = done; k < bmap->n_eq; ++k)
00513                                 if (!isl_int_is_zero(bmap->eq[k][1+last_var]))
00514                                         break;
00515                         if (k < bmap->n_eq)
00516                                 break;
00517                 }
00518                 if (last_var < 0)
00519                         break;
00520                 if (k != done)
00521                         swap_equality(bmap, k, done);
00522                 if (isl_int_is_neg(bmap->eq[done][1+last_var]))
00523                         isl_seq_neg(bmap->eq[done], bmap->eq[done], 1+total);
00524 
00525                 eliminate_var_using_equality(bmap, last_var, bmap->eq[done],
00526                                                 progress);
00527 
00528                 if (last_var >= total_var &&
00529                     isl_int_is_zero(bmap->div[last_var - total_var][0])) {
00530                         unsigned div = last_var - total_var;
00531                         isl_seq_neg(bmap->div[div]+1, bmap->eq[done], 1+total);
00532                         isl_int_set_si(bmap->div[div][1+1+last_var], 0);
00533                         isl_int_set(bmap->div[div][0],
00534                                     bmap->eq[done][1+last_var]);
00535                         ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
00536                 }
00537         }
00538         if (done == bmap->n_eq)
00539                 return bmap;
00540         for (k = done; k < bmap->n_eq; ++k) {
00541                 if (isl_int_is_zero(bmap->eq[k][0]))
00542                         continue;
00543                 return isl_basic_map_set_to_empty(bmap);
00544         }
00545         isl_basic_map_free_equality(bmap, bmap->n_eq-done);
00546         return bmap;
00547 }

struct isl_basic_set* isl_basic_set_gauss ( struct isl_basic_set *  bset,
int *  progress 
) [read]

Definition at line 549 of file isl_map_simplify.c.

00551 {
00552         return (struct isl_basic_set*)isl_basic_map_gauss(
00553                         (struct isl_basic_map *)bset, progress);
00554 }

struct isl_basic_map* isl_basic_map_normalize_constraints ( struct isl_basic_map *  bmap  )  [read]

Definition at line 290 of file isl_map_simplify.c.

00292 {
00293         int i;
00294         isl_int gcd;
00295         unsigned total = isl_basic_map_total_dim(bmap);
00296 
00297         isl_int_init(gcd);
00298         for (i = bmap->n_eq - 1; i >= 0; --i) {
00299                 isl_seq_gcd(bmap->eq[i]+1, total, &gcd);
00300                 if (isl_int_is_zero(gcd)) {
00301                         if (!isl_int_is_zero(bmap->eq[i][0])) {
00302                                 bmap = isl_basic_map_set_to_empty(bmap);
00303                                 break;
00304                         }
00305                         isl_basic_map_drop_equality(bmap, i);
00306                         continue;
00307                 }
00308                 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
00309                         isl_int_gcd(gcd, gcd, bmap->eq[i][0]);
00310                 if (isl_int_is_one(gcd))
00311                         continue;
00312                 if (!isl_int_is_divisible_by(bmap->eq[i][0], gcd)) {
00313                         bmap = isl_basic_map_set_to_empty(bmap);
00314                         break;
00315                 }
00316                 isl_seq_scale_down(bmap->eq[i], bmap->eq[i], gcd, 1+total);
00317         }
00318 
00319         for (i = bmap->n_ineq - 1; i >= 0; --i) {
00320                 isl_seq_gcd(bmap->ineq[i]+1, total, &gcd);
00321                 if (isl_int_is_zero(gcd)) {
00322                         if (isl_int_is_neg(bmap->ineq[i][0])) {
00323                                 bmap = isl_basic_map_set_to_empty(bmap);
00324                                 break;
00325                         }
00326                         isl_basic_map_drop_inequality(bmap, i);
00327                         continue;
00328                 }
00329                 if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
00330                         isl_int_gcd(gcd, gcd, bmap->ineq[i][0]);
00331                 if (isl_int_is_one(gcd))
00332                         continue;
00333                 isl_int_fdiv_q(bmap->ineq[i][0], bmap->ineq[i][0], gcd);
00334                 isl_seq_scale_down(bmap->ineq[i]+1, bmap->ineq[i]+1, gcd, total);
00335         }
00336         isl_int_clear(gcd);
00337 
00338         return bmap;
00339 }

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

Definition at line 341 of file isl_map_simplify.c.

00343 {
00344         (struct isl_basic_set *)isl_basic_map_normalize_constraints(
00345                 (struct isl_basic_map *)bset);
00346 }

struct isl_basic_map* isl_basic_map_implicit_equalities ( struct isl_basic_map *  bmap  )  [read]

Definition at line 11 of file isl_affine_hull.c.

00013 {
00014         struct isl_tab *tab;
00015 
00016         if (!bmap)
00017                 return bmap;
00018 
00019         bmap = isl_basic_map_gauss(bmap, NULL);
00020         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
00021                 return bmap;
00022         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NO_IMPLICIT))
00023                 return bmap;
00024         if (bmap->n_ineq <= 1)
00025                 return bmap;
00026 
00027         tab = isl_tab_from_basic_map(bmap);
00028         tab = isl_tab_detect_equalities(bmap->ctx, tab);
00029         bmap = isl_basic_map_update_from_tab(bmap, tab);
00030         isl_tab_free(bmap->ctx, tab);
00031         bmap = isl_basic_map_gauss(bmap, NULL);
00032         ISL_F_SET(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
00033         return bmap;
00034 }

struct isl_basic_set* isl_basic_map_underlying_set ( struct isl_basic_map *  bmap  )  [read]

Definition at line 2244 of file isl_map.c.

02246 {
02247         if (!bmap)
02248                 goto error;
02249         if (bmap->dim->nparam == 0 && bmap->dim->n_in == 0 && bmap->n_div == 0)
02250                 return (struct isl_basic_set *)bmap;
02251         bmap = isl_basic_map_cow(bmap);
02252         if (!bmap)
02253                 goto error;
02254         bmap->dim = isl_dim_underlying(bmap->dim, bmap->n_div);
02255         if (!bmap->dim)
02256                 goto error;
02257         bmap->extra -= bmap->n_div;
02258         bmap->n_div = 0;
02259         bmap = isl_basic_map_finalize(bmap);
02260         return (struct isl_basic_set *)bmap;
02261 error:
02262         return NULL;
02263 }

struct isl_set* isl_map_underlying_set ( struct isl_map *  map  )  [read]

Definition at line 2374 of file isl_map.c.

02375 {
02376         int i;
02377 
02378         map = isl_map_cow(map);
02379         if (!map)
02380                 return NULL;
02381         map->dim = isl_dim_cow(map->dim);
02382         if (!map->dim)
02383                 goto error;
02384 
02385         for (i = 1; i < map->n; ++i)
02386                 isl_assert(map->ctx, map->p[0]->n_div == map->p[i]->n_div,
02387                                 goto error);
02388         for (i = 0; i < map->n; ++i) {
02389                 map->p[i] = (struct isl_basic_map *)
02390                                 isl_basic_map_underlying_set(map->p[i]);
02391                 if (!map->p[i])
02392                         goto error;
02393         }
02394         if (map->n == 0)
02395                 map->dim = isl_dim_underlying(map->dim, 0);
02396         else {
02397                 isl_dim_free(map->dim);
02398                 map->dim = isl_dim_copy(map->p[0]->dim);
02399         }
02400         if (!map->dim)
02401                 goto error;
02402         return (struct isl_set *)map;
02403 error:
02404         isl_map_free(map);
02405         return NULL;
02406 }

struct isl_basic_map* isl_basic_map_overlying_set ( struct isl_basic_set *  bset,
struct isl_basic_map *  like 
) [read]

Definition at line 2265 of file isl_map.c.

02267 {
02268         struct isl_basic_map *bmap;
02269         struct isl_ctx *ctx;
02270         unsigned total;
02271         int i;
02272 
02273         if (!bset || !like)
02274                 goto error;
02275         ctx = bset->ctx;
02276         isl_assert(ctx, bset->n_div == 0, goto error);
02277         isl_assert(ctx, isl_basic_set_n_param(bset) == 0, goto error);
02278         isl_assert(ctx, bset->dim->n_out == isl_basic_map_total_dim(like),
02279                         goto error);
02280         if (isl_dim_equal(bset->dim, like->dim) && like->n_div == 0) {
02281                 isl_basic_map_free(like);
02282                 return (struct isl_basic_map *)bset;
02283         }
02284         bset = isl_basic_set_cow(bset);
02285         if (!bset)
02286                 goto error;
02287         total = bset->dim->n_out + bset->extra;
02288         bmap = (struct isl_basic_map *)bset;
02289         isl_dim_free(bmap->dim);
02290         bmap->dim = isl_dim_copy(like->dim);
02291         if (!bmap->dim)
02292                 goto error;
02293         bmap->n_div = like->n_div;
02294         bmap->extra += like->n_div;
02295         if (bmap->extra) {
02296                 unsigned ltotal;
02297                 ltotal = total - bmap->extra + like->extra;
02298                 if (ltotal > total)
02299                         ltotal = total;
02300                 bmap->block2 = isl_blk_extend(ctx, bmap->block2,
02301                                         bmap->extra * (1 + 1 + total));
02302                 if (isl_blk_is_error(bmap->block2))
02303                         goto error;
02304                 bmap->div = isl_realloc_array(ctx, bmap->div, isl_int *,
02305                                                 bmap->extra);
02306                 if (!bmap->div)
02307                         goto error;
02308                 for (i = 0; i < bmap->extra; ++i)
02309                         bmap->div[i] = bmap->block2.data + i * (1 + 1 + total);
02310                 for (i = 0; i < like->n_div; ++i) {
02311                         isl_seq_cpy(bmap->div[i], like->div[i], 1 + 1 + ltotal);
02312                         isl_seq_clr(bmap->div[i]+1+1+ltotal, total - ltotal);
02313                 }
02314                 bmap = isl_basic_map_extend_constraints(bmap, 
02315                                                         0, 2 * like->n_div);
02316                 for (i = 0; i < like->n_div; ++i) {
02317                         if (isl_int_is_zero(bmap->div[i][0]))
02318                                 continue;
02319                         if (add_div_constraints(bmap, i) < 0)
02320                                 goto error;
02321                 }
02322         }
02323         isl_basic_map_free(like);
02324         bmap = isl_basic_map_simplify(bmap);
02325         bmap = isl_basic_map_finalize(bmap);
02326         return bmap;
02327 error:
02328         isl_basic_map_free(like);
02329         isl_basic_set_free(bset);
02330         return NULL;
02331 }

struct isl_basic_map* isl_basic_map_drop ( struct isl_basic_map *  bmap,
enum isl_dim_type  type,
unsigned  first,
unsigned  n 
) [read]

Definition at line 147 of file isl_map_simplify.c.

00149 {
00150         int i;
00151         unsigned dim;
00152         unsigned offset;
00153         unsigned left;
00154 
00155         if (!bmap)
00156                 goto error;
00157 
00158         dim = isl_basic_map_dim(bmap, type);
00159         isl_assert(bmap->ctx, first + n <= dim, goto error);
00160 
00161         if (n == 0)
00162                 return bmap;
00163 
00164         bmap = isl_basic_map_cow(bmap);
00165         if (!bmap)
00166                 return NULL;
00167 
00168         offset = isl_basic_map_offset(bmap, type) + first;
00169         left = isl_basic_map_total_dim(bmap) - (offset - 1) - n;
00170         for (i = 0; i < bmap->n_eq; ++i)
00171                 constraint_drop_vars(bmap->eq[i]+offset, n, left);
00172 
00173         for (i = 0; i < bmap->n_ineq; ++i)
00174                 constraint_drop_vars(bmap->ineq[i]+offset, n, left);
00175 
00176         for (i = 0; i < bmap->n_div; ++i)
00177                 constraint_drop_vars(bmap->div[i]+1+offset, n, left);
00178 
00179         if (type == isl_dim_div) {
00180                 bmap = move_divs_last(bmap, first, n);
00181                 if (!bmap)
00182                         goto error;
00183                 isl_basic_map_free_div(bmap, n);
00184         } else
00185                 bmap->dim = isl_dim_drop(bmap->dim, type, first, n);
00186         if (!bmap->dim)
00187                 goto error;
00188 
00189         ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
00190         bmap = isl_basic_map_simplify(bmap);
00191         return isl_basic_map_finalize(bmap);
00192 error:
00193         isl_basic_map_free(bmap);
00194         return NULL;
00195 }

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

Definition at line 40 of file isl_map_simplify.c.

00042 {
00043         int i;
00044 
00045         if (!bset)
00046                 goto error;
00047 
00048         isl_assert(bset->ctx, first + n <= bset->dim->n_out, goto error);
00049 
00050         if (n == 0)
00051                 return bset;
00052 
00053         bset = isl_basic_set_cow(bset);
00054         if (!bset)
00055                 return NULL;
00056 
00057         for (i = 0; i < bset->n_eq; ++i)
00058                 constraint_drop_vars(bset->eq[i]+1+bset->dim->nparam+first, n,
00059                                      (bset->dim->n_out-first-n)+bset->extra);
00060 
00061         for (i = 0; i < bset->n_ineq; ++i)
00062                 constraint_drop_vars(bset->ineq[i]+1+bset->dim->nparam+first, n,
00063                                      (bset->dim->n_out-first-n)+bset->extra);
00064 
00065         for (i = 0; i < bset->n_div; ++i)
00066                 constraint_drop_vars(bset->div[i]+1+1+bset->dim->nparam+first, n,
00067                                      (bset->dim->n_out-first-n)+bset->extra);
00068 
00069         bset->dim = isl_dim_drop_outputs(bset->dim, first, n);
00070         if (!bset->dim)
00071                 goto error;
00072 
00073         ISL_F_CLR(bset, ISL_BASIC_SET_NORMALIZED);
00074         bset = isl_basic_set_simplify(bset);
00075         return isl_basic_set_finalize(bset);
00076 error:
00077         isl_basic_set_free(bset);
00078         return NULL;
00079 }

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

Definition at line 81 of file isl_map_simplify.c.

00083 {
00084         int i;
00085 
00086         if (!set)
00087                 goto error;
00088 
00089         isl_assert(set->ctx, first + n <= set->dim->n_out, goto error);
00090 
00091         if (n == 0)
00092                 return set;
00093         set = isl_set_cow(set);
00094         if (!set)
00095                 goto error;
00096         set->dim = isl_dim_drop_outputs(set->dim, first, n);
00097         if (!set->dim)
00098                 goto error;
00099 
00100         for (i = 0; i < set->n; ++i) {
00101                 set->p[i] = isl_basic_set_drop_dims(set->p[i], first, n);
00102                 if (!set->p[i])
00103                         goto error;
00104         }
00105 
00106         ISL_F_CLR(set, ISL_SET_NORMALIZED);
00107         return set;
00108 error:
00109         isl_set_free(set);
00110         return NULL;
00111 }

struct isl_map* isl_map_drop_inputs ( struct isl_map *  map,
unsigned  first,
unsigned  n 
) [read]

Definition at line 235 of file isl_map_simplify.c.

00237 {
00238         return isl_map_drop(map, isl_dim_in, first, n);
00239 }

struct isl_map* isl_map_drop ( struct isl_map *  map,
enum isl_dim_type  type,
unsigned  first,
unsigned  n 
) [read]

Definition at line 203 of file isl_map_simplify.c.

00205 {
00206         int i;
00207 
00208         if (!map)
00209                 goto error;
00210 
00211         isl_assert(map->ctx, first + n <= isl_map_dim(map, type), goto error);
00212 
00213         if (n == 0)
00214                 return map;
00215         map = isl_map_cow(map);
00216         if (!map)
00217                 goto error;
00218         map->dim = isl_dim_drop(map->dim, type, first, n);
00219         if (!map->dim)
00220                 goto error;
00221 
00222         for (i = 0; i < map->n; ++i) {
00223                 map->p[i] = isl_basic_map_drop(map->p[i], type, first, n);
00224                 if (!map->p[i])
00225                         goto error;
00226         }
00227         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
00228 
00229         return map;
00230 error:
00231         isl_map_free(map);
00232         return NULL;
00233 }

struct isl_map* isl_map_remove_empty_parts ( struct isl_map *  map  )  [read]

Definition at line 3877 of file isl_map.c.

03878 {
03879         int i;
03880 
03881         if (!map)
03882                 return NULL;
03883 
03884         for (i = map->n-1; i >= 0; --i) {
03885                 if (!ISL_F_ISSET(map->p[i], ISL_BASIC_MAP_EMPTY))
03886                         continue;
03887                 isl_basic_map_free(map->p[i]);
03888                 if (i != map->n-1) {
03889                         ISL_F_CLR(map, ISL_MAP_NORMALIZED);
03890                         map->p[i] = map->p[map->n-1];
03891                 }
03892                 map->n--;
03893         }
03894 
03895         return map;
03896 }

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

Definition at line 3898 of file isl_map.c.

03899 {
03900         return (struct isl_set *)
03901                 isl_map_remove_empty_parts((struct isl_map *)set);
03902 }

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

Definition at line 4355 of file isl_map.c.

04356 {
04357         return (struct isl_set *)isl_map_normalize((struct isl_map *)set);
04358 }

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

struct isl_basic_map* isl_basic_map_eliminate_vars ( struct isl_basic_map *  bmap,
unsigned  pos,
unsigned  n 
) [read]

Definition at line 1199 of file isl_map_simplify.c.

01201 {
01202         int d;
01203         int i, j, k;
01204         unsigned total;
01205 
01206         if (n == 0)
01207                 return bmap;
01208         if (!bmap)
01209                 return NULL;
01210         total = isl_basic_map_total_dim(bmap);
01211 
01212         bmap = isl_basic_map_cow(bmap);
01213         for (d = pos + n - 1; d >= 0 && d >= pos; --d)
01214                 bmap = remove_dependent_vars(bmap, d);
01215 
01216         for (d = pos + n - 1;
01217              d >= 0 && d >= total - bmap->n_div && d >= pos; --d)
01218                 isl_seq_clr(bmap->div[d-(total-bmap->n_div)], 2+total);
01219         for (d = pos + n - 1; d >= 0 && d >= pos; --d) {
01220                 int n_lower, n_upper;
01221                 if (!bmap)
01222                         return NULL;
01223                 for (i = 0; i < bmap->n_eq; ++i) {
01224                         if (isl_int_is_zero(bmap->eq[i][1+d]))
01225                                 continue;
01226                         eliminate_var_using_equality(bmap, d, bmap->eq[i], NULL);
01227                         isl_basic_map_drop_equality(bmap, i);
01228                         break;
01229                 }
01230                 if (i < bmap->n_eq)
01231                         continue;
01232                 n_lower = 0;
01233                 n_upper = 0;
01234                 for (i = 0; i < bmap->n_ineq; ++i) {
01235                         if (isl_int_is_pos(bmap->ineq[i][1+d]))
01236                                 n_lower++;
01237                         else if (isl_int_is_neg(bmap->ineq[i][1+d]))
01238                                 n_upper++;
01239                 }
01240                 bmap = isl_basic_map_extend_constraints(bmap,
01241                                 0, n_lower * n_upper);
01242                 for (i = bmap->n_ineq - 1; i >= 0; --i) {
01243                         int last;
01244                         if (isl_int_is_zero(bmap->ineq[i][1+d]))
01245                                 continue;
01246                         last = -1;
01247                         for (j = 0; j < i; ++j) {
01248                                 if (isl_int_is_zero(bmap->ineq[j][1+d]))
01249                                         continue;
01250                                 last = j;
01251                                 if (isl_int_sgn(bmap->ineq[i][1+d]) ==
01252                                     isl_int_sgn(bmap->ineq[j][1+d]))
01253                                         continue;
01254                                 k = isl_basic_map_alloc_inequality(bmap);
01255                                 if (k < 0)
01256                                         goto error;
01257                                 isl_seq_cpy(bmap->ineq[k], bmap->ineq[i],
01258                                                 1+total);
01259                                 isl_seq_elim(bmap->ineq[k], bmap->ineq[j],
01260                                                 1+d, 1+total, NULL);
01261                         }
01262                         isl_basic_map_drop_inequality(bmap, i);
01263                         i = last + 1;
01264                 }
01265                 if (n_lower > 0 && n_upper > 0) {
01266                         bmap = isl_basic_map_normalize_constraints(bmap);
01267                         bmap = remove_duplicate_constraints(bmap, NULL);
01268                         bmap = isl_basic_map_gauss(bmap, NULL);
01269                         bmap = isl_basic_map_convex_hull(bmap);
01270                         if (!bmap)
01271                                 goto error;
01272                         if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
01273                                 break;
01274                 }
01275         }
01276         ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
01277         return bmap;
01278 error:
01279         isl_basic_map_free(bmap);
01280         return NULL;
01281 }

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

Definition at line 1283 of file isl_map_simplify.c.

01285 {
01286         return (struct isl_basic_set *)isl_basic_map_eliminate_vars(
01287                         (struct isl_basic_map *)bset, pos, n);
01288 }

int isl_basic_set_constraint_is_redundant ( struct isl_basic_set **  bset,
isl_int *  c,
isl_int *  opt_n,
isl_int *  opt_d 
)

Definition at line 65 of file isl_convex_hull.c.

00067 {
00068         return isl_basic_map_constraint_is_redundant(
00069                         (struct isl_basic_map **)bset, c, opt_n, opt_d);
00070 }

struct isl_basic_map* isl_basic_map_drop_redundant_divs ( struct isl_basic_map *  bmap  )  [read]

Definition at line 2265 of file isl_map_simplify.c.

02267 {
02268         int i, j;
02269         unsigned off;
02270         int *pairs = NULL;
02271         int n = 0;
02272 
02273         if (!bmap)
02274                 goto error;
02275 
02276         off = isl_dim_total(bmap->dim);
02277         pairs = isl_calloc_array(bmap->ctx, int, bmap->n_div);
02278         if (!pairs)
02279                 goto error;
02280 
02281         for (i = 0; i < bmap->n_div; ++i) {
02282                 int pos, neg;
02283                 int last_pos, last_neg;
02284                 int redundant;
02285 
02286                 if (!isl_int_is_zero(bmap->div[i][0]))
02287                         continue;
02288                 for (j = 0; j < bmap->n_eq; ++j)
02289                         if (!isl_int_is_zero(bmap->eq[j][1 + off + i]))
02290                                 break;
02291                 if (j < bmap->n_eq)
02292                         continue;
02293                 ++n;
02294                 pos = neg = 0;
02295                 for (j = 0; j < bmap->n_ineq; ++j) {
02296                         if (isl_int_is_pos(bmap->ineq[j][1 + off + i])) {
02297                                 last_pos = j;
02298                                 ++pos;
02299                         }
02300                         if (isl_int_is_neg(bmap->ineq[j][1 + off + i])) {
02301                                 last_neg = j;
02302                                 ++neg;
02303                         }
02304                 }
02305                 pairs[i] = pos * neg;
02306                 if (pairs[i] == 0) {
02307                         for (j = bmap->n_ineq - 1; j >= 0; --j)
02308                                 if (!isl_int_is_zero(bmap->ineq[j][1+off+i]))
02309                                         isl_basic_map_drop_inequality(bmap, j);
02310                         bmap = isl_basic_map_drop_div(bmap, i);
02311                         free(pairs);
02312                         return isl_basic_map_drop_redundant_divs(bmap);
02313                 }
02314                 if (pairs[i] != 1)
02315                         continue;
02316                 if (!isl_seq_is_neg(bmap->ineq[last_pos] + 1,
02317                                     bmap->ineq[last_neg] + 1,
02318                                     off + bmap->n_div))
02319                         continue;
02320 
02321                 isl_int_add(bmap->ineq[last_pos][0],
02322                             bmap->ineq[last_pos][0], bmap->ineq[last_neg][0]);
02323                 isl_int_add_ui(bmap->ineq[last_pos][0],
02324                                bmap->ineq[last_pos][0], 1);
02325                 redundant = isl_int_ge(bmap->ineq[last_pos][0],
02326                                 bmap->ineq[last_pos][1+off+i]);
02327                 isl_int_sub_ui(bmap->ineq[last_pos][0],
02328                                bmap->ineq[last_pos][0], 1);
02329                 isl_int_sub(bmap->ineq[last_pos][0],
02330                             bmap->ineq[last_pos][0], bmap->ineq[last_neg][0]);
02331                 if (!redundant) {
02332                         if (!ok_to_set_div_from_bound(bmap, i, last_pos)) {
02333                                 pairs[i] = 0;
02334                                 --n;
02335                                 continue;
02336                         }
02337                         bmap = set_div_from_lower_bound(bmap, i, last_pos);
02338                         bmap = isl_basic_map_simplify(bmap);
02339                         free(pairs);
02340                         return isl_basic_map_drop_redundant_divs(bmap);
02341                 }
02342                 if (last_pos > last_neg) {
02343                         isl_basic_map_drop_inequality(bmap, last_pos);
02344                         isl_basic_map_drop_inequality(bmap, last_neg);
02345                 } else {
02346                         isl_basic_map_drop_inequality(bmap, last_neg);
02347                         isl_basic_map_drop_inequality(bmap, last_pos);
02348                 }
02349                 bmap = isl_basic_map_drop_div(bmap, i);
02350                 free(pairs);
02351                 return isl_basic_map_drop_redundant_divs(bmap);
02352         }
02353 
02354         if (n > 0)
02355                 return coalesce_or_drop_more_redundant_divs(bmap, pairs, n);
02356 
02357         free(pairs);
02358         return bmap;
02359 error:
02360         free(pairs);
02361         isl_basic_map_free(bmap);
02362         return NULL;
02363 }

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