isl_constraint.c File Reference

#include <isl_constraint.h>
#include "isl_map_private.h"

Include dependency graph for isl_constraint.c:

Go to the source code of this file.

Functions

static unsigned n (struct isl_constraint *c, enum isl_dim_type type)
static unsigned offset (struct isl_constraint *c, enum isl_dim_type type)
static unsigned basic_set_offset (struct isl_basic_set *bset, enum isl_dim_type type)
struct isl_constraint * isl_basic_map_constraint (struct isl_basic_map *bmap, isl_int **line)
struct isl_constraint * isl_basic_set_constraint (struct isl_basic_set *bset, isl_int **line)
struct isl_constraint * isl_equality_alloc (struct isl_dim *dim)
struct isl_constraint * isl_inequality_alloc (struct isl_dim *dim)
struct isl_constraint * isl_constraint_dup (struct isl_constraint *c)
struct isl_constraint * isl_constraint_cow (struct isl_constraint *c)
struct isl_constraint * isl_constraint_copy (struct isl_constraint *constraint)
struct isl_constraint * isl_constraint_free (struct isl_constraint *c)
struct isl_constraint * isl_basic_set_first_constraint (struct isl_basic_set *bset)
struct isl_constraint * isl_constraint_next (struct isl_constraint *c)
int isl_constraint_is_equal (struct isl_constraint *constraint1, struct isl_constraint *constraint2)
struct isl_basic_map * isl_basic_map_add_constraint (struct isl_basic_map *bmap, struct isl_constraint *constraint)
struct isl_basic_set * isl_basic_set_add_constraint (struct isl_basic_set *bset, struct isl_constraint *constraint)
struct isl_constraint * isl_constraint_add_div (struct isl_constraint *constraint, struct isl_div *div, int *pos)
int isl_constraint_dim (struct isl_constraint *constraint, enum isl_dim_type type)
void isl_constraint_get_constant (struct isl_constraint *constraint, isl_int *v)
void isl_constraint_get_coefficient (struct isl_constraint *constraint, enum isl_dim_type type, int pos, isl_int *v)
struct isl_div * isl_constraint_div (struct isl_constraint *constraint, int pos)
void isl_constraint_set_constant (struct isl_constraint *constraint, isl_int v)
void isl_constraint_set_coefficient (struct isl_constraint *constraint, enum isl_dim_type type, int pos, isl_int v)
void isl_constraint_clear (struct isl_constraint *constraint)
struct isl_constraint * isl_constraint_negate (struct isl_constraint *constraint)
int isl_constraint_is_equality (struct isl_constraint *constraint)
struct isl_basic_set * isl_basic_set_from_constraint (struct isl_constraint *constraint)
int isl_basic_set_has_defining_equality (struct isl_basic_set *bset, enum isl_dim_type type, int pos, struct isl_constraint **c)
int isl_basic_set_has_defining_inequalities (struct isl_basic_set *bset, enum isl_dim_type type, int pos, struct isl_constraint **lower, struct isl_constraint **upper)

Function Documentation

static unsigned basic_set_offset ( struct isl_basic_set *  bset,
enum isl_dim_type  type 
) [static]

Definition at line 20 of file isl_constraint.c.

00022 {
00023         struct isl_dim *dim = bset->dim;
00024         switch (type) {
00025         case isl_dim_param:     return 1;
00026         case isl_dim_in:        return 1 + dim->nparam;
00027         case isl_dim_out:       return 1 + dim->nparam + dim->n_in;
00028         case isl_dim_div:       return 1 + dim->nparam + dim->n_in + dim->n_out;
00029         }
00030 }

struct isl_basic_map* isl_basic_map_add_constraint ( struct isl_basic_map *  bmap,
struct isl_constraint *  constraint 
) [read]

Definition at line 178 of file isl_constraint.c.

00180 {
00181         if (!bmap || !constraint)
00182                 goto error;
00183 
00184         isl_assert(constraint->ctx,
00185                 isl_dim_equal(bmap->dim, constraint->bmap->dim), goto error);
00186 
00187         bmap = isl_basic_map_intersect(bmap,
00188                                     isl_basic_map_copy(constraint->bmap));
00189         isl_constraint_free(constraint);
00190         return bmap;
00191 error:
00192         isl_basic_map_free(bmap);
00193         isl_constraint_free(constraint);
00194         return NULL;
00195 }

Here is the call graph for this function:

struct isl_constraint* isl_basic_map_constraint ( struct isl_basic_map *  bmap,
isl_int **  line 
) [read]

Definition at line 32 of file isl_constraint.c.

00034 {
00035         struct isl_constraint *constraint;
00036 
00037         if (!bmap || !line)
00038                 goto error;
00039         
00040         constraint = isl_alloc_type(bmap->ctx, struct isl_constraint);
00041         if (!constraint)
00042                 goto error;
00043 
00044         constraint->ctx = bmap->ctx;
00045         isl_ctx_ref(constraint->ctx);
00046         constraint->ref = 1;
00047         constraint->bmap = bmap;
00048         constraint->line = line;
00049 
00050         return constraint;
00051 error:
00052         isl_basic_map_free(bmap);
00053         return NULL;
00054 }

Here is the call graph for this function:

struct isl_basic_set* isl_basic_set_add_constraint ( struct isl_basic_set *  bset,
struct isl_constraint *  constraint 
) [read]

Definition at line 197 of file isl_constraint.c.

00199 {
00200         return (struct isl_basic_set *)
00201                 isl_basic_map_add_constraint((struct isl_basic_map *)bset,
00202                                                 constraint);
00203 }

Here is the call graph for this function:

struct isl_constraint* isl_basic_set_constraint ( struct isl_basic_set *  bset,
isl_int **  line 
) [read]

Definition at line 56 of file isl_constraint.c.

00058 {
00059         return isl_basic_map_constraint((struct isl_basic_map *)bset, line);
00060 }

Here is the call graph for this function:

struct isl_constraint* isl_basic_set_first_constraint ( struct isl_basic_set *  bset  )  [read]

Definition at line 135 of file isl_constraint.c.

00137 {
00138         struct isl_constraint *c;
00139 
00140         if (!bset)
00141                 return NULL;
00142 
00143         if (bset->n_eq > 0)
00144                 return isl_basic_set_constraint(bset, &bset->eq[0]);
00145 
00146         if (bset->n_ineq > 0)
00147                 return isl_basic_set_constraint(bset, &bset->ineq[0]);
00148 
00149         isl_basic_set_free(bset);
00150         return NULL;
00151 }

Here is the call graph for this function:

struct isl_basic_set* isl_basic_set_from_constraint ( struct isl_constraint *  constraint  )  [read]

Definition at line 326 of file isl_constraint.c.

00328 {
00329         int k;
00330         struct isl_basic_set *constraint_bset, *bset;
00331         isl_int *c;
00332         unsigned dim;
00333         unsigned nparam;
00334         unsigned total;
00335 
00336         if (!constraint)
00337                 return NULL;
00338 
00339         isl_assert(constraint->ctx,n(constraint, isl_dim_in) == 0, goto error);
00340 
00341         constraint_bset = (struct isl_basic_set *)constraint->bmap;
00342         bset = isl_basic_set_universe_like(constraint_bset);
00343         bset = isl_basic_set_align_divs(bset, constraint_bset);
00344         nparam = isl_basic_set_n_param(bset);
00345         dim = isl_basic_set_n_dim(bset);
00346         bset = isl_basic_set_cow(bset);
00347         bset = isl_basic_set_extend(bset, nparam, dim, 0, 1, 1);
00348         if (isl_constraint_is_equality(constraint)) {
00349                 k = isl_basic_set_alloc_equality(bset);
00350                 if (k < 0)
00351                         goto error;
00352                 c = bset->eq[k];
00353         }
00354         else {
00355                 k = isl_basic_set_alloc_inequality(bset);
00356                 if (k < 0)
00357                         goto error;
00358                 c = bset->ineq[k];
00359         }
00360         total = isl_basic_set_total_dim(bset);
00361         isl_seq_cpy(c, constraint->line[0], 1 + total);
00362         isl_constraint_free(constraint);
00363         return bset;
00364 error:
00365         isl_constraint_free(constraint);
00366         isl_basic_set_free(bset);
00367         return NULL;
00368 }

Here is the call graph for this function:

int isl_basic_set_has_defining_equality ( struct isl_basic_set *  bset,
enum isl_dim_type  type,
int  pos,
struct isl_constraint **  c 
)

Definition at line 370 of file isl_constraint.c.

00373 {
00374         int i;
00375         unsigned offset;
00376         unsigned total;
00377 
00378         if (!bset)
00379                 return -1;
00380         offset = basic_set_offset(bset, type);
00381         total = isl_basic_set_total_dim(bset);
00382         isl_assert(bset->ctx, pos < isl_basic_set_dim(bset, type), return -1);
00383         for (i = 0; i < bset->n_eq; ++i)
00384                 if (!isl_int_is_zero(bset->eq[i][offset + pos]) &&
00385                     isl_seq_first_non_zero(bset->eq[i]+offset+pos+1,
00386                                            1+total-offset-pos-1) == -1) {
00387                         *c= isl_basic_set_constraint(isl_basic_set_copy(bset),
00388                                                                 &bset->eq[i]);
00389                         return 1;
00390                 }
00391         return 0;
00392 }

Here is the call graph for this function:

int isl_basic_set_has_defining_inequalities ( struct isl_basic_set *  bset,
enum isl_dim_type  type,
int  pos,
struct isl_constraint **  lower,
struct isl_constraint **  upper 
)

Definition at line 394 of file isl_constraint.c.

00398 {
00399         int i, j;
00400         unsigned offset;
00401         unsigned total;
00402         isl_int m;
00403         isl_int **lower_line, **upper_line;
00404 
00405         if (!bset)
00406                 return -1;
00407         offset = basic_set_offset(bset, type);
00408         total = isl_basic_set_total_dim(bset);
00409         isl_assert(bset->ctx, pos < isl_basic_set_dim(bset, type), return -1);
00410         isl_int_init(m);
00411         for (i = 0; i < bset->n_ineq; ++i) {
00412                 if (isl_int_is_zero(bset->ineq[i][offset + pos]))
00413                         continue;
00414                 if (isl_int_is_one(bset->ineq[i][offset + pos]))
00415                         continue;
00416                 if (isl_int_is_negone(bset->ineq[i][offset + pos]))
00417                         continue;
00418                 if (isl_seq_first_non_zero(bset->ineq[i]+offset+pos+1,
00419                                                 1+total-offset-pos-1) != -1)
00420                         continue;
00421                 for (j = i + 1; j < bset->n_ineq; ++j) {
00422                         if (!isl_seq_is_neg(bset->ineq[i]+1, bset->ineq[j]+1,
00423                                             total))
00424                                 continue;
00425                         isl_int_add(m, bset->ineq[i][0], bset->ineq[j][0]);
00426                         if (isl_int_abs_ge(m, bset->ineq[i][offset+pos]))
00427                                 continue;
00428 
00429                         if (isl_int_is_pos(bset->ineq[i][offset+pos])) {
00430                                 lower_line = &bset->ineq[i];
00431                                 upper_line = &bset->ineq[j];
00432                         } else {
00433                                 lower_line = &bset->ineq[j];
00434                                 upper_line = &bset->ineq[i];
00435                         }
00436                         *lower = isl_basic_set_constraint(
00437                                         isl_basic_set_copy(bset), lower_line);
00438                         *upper = isl_basic_set_constraint(
00439                                         isl_basic_set_copy(bset), upper_line);
00440                         isl_int_clear(m);
00441                         return 1;
00442                 }
00443         }
00444         *lower = NULL;
00445         *upper = NULL;
00446         isl_int_clear(m);
00447         return 0;
00448 }

Here is the call graph for this function:

struct isl_constraint* isl_constraint_add_div ( struct isl_constraint *  constraint,
struct isl_div *  div,
int *  pos 
) [read]

Definition at line 205 of file isl_constraint.c.

00207 {
00208         if (!constraint || !div)
00209                 goto error;
00210 
00211         isl_assert(constraint->ctx,
00212             isl_dim_equal(div->bmap->dim, constraint->bmap->dim), goto error);
00213         isl_assert(constraint->ctx,
00214             constraint->bmap->n_eq + constraint->bmap->n_ineq == 1, goto error);
00215 
00216         constraint->bmap = isl_basic_map_cow(constraint->bmap);
00217         constraint->bmap = isl_basic_map_extend_dim(constraint->bmap,
00218                                 isl_dim_copy(constraint->bmap->dim), 1, 0, 0);
00219         if (!constraint->bmap)
00220                 goto error;
00221         constraint->line = &constraint->bmap->eq[0];
00222         *pos = isl_basic_map_alloc_div(constraint->bmap);
00223         if (*pos < 0)
00224                 goto error;
00225         isl_seq_cpy(constraint->bmap->div[*pos], div->line[0],
00226                         1 + 1 + isl_basic_map_total_dim(constraint->bmap));
00227         isl_div_free(div);
00228         return constraint;
00229 error:
00230         isl_constraint_free(constraint);
00231         isl_div_free(div);
00232         return NULL;
00233 }

Here is the call graph for this function:

void isl_constraint_clear ( struct isl_constraint *  constraint  ) 

Definition at line 287 of file isl_constraint.c.

00288 {
00289         struct isl_basic_set *bset;
00290         unsigned total;
00291 
00292         if (!constraint)
00293                 return;
00294         total = isl_basic_map_total_dim(constraint->bmap);
00295         isl_seq_clr(constraint->line[0], 1 + total);
00296 }

Here is the call graph for this function:

struct isl_constraint* isl_constraint_copy ( struct isl_constraint *  constraint  )  [read]

Definition at line 113 of file isl_constraint.c.

00114 {
00115         if (!constraint)
00116                 return NULL;
00117 
00118         constraint->ref++;
00119         return constraint;
00120 }

struct isl_constraint* isl_constraint_cow ( struct isl_constraint *  c  )  [read]

Definition at line 102 of file isl_constraint.c.

00103 {
00104         if (!c)
00105                 return NULL;
00106 
00107         if (c->ref == 1)
00108                 return c;
00109         c->ref--;
00110         return isl_constraint_dup(c);
00111 }

Here is the call graph for this function:

int isl_constraint_dim ( struct isl_constraint *  constraint,
enum isl_dim_type  type 
)

Definition at line 235 of file isl_constraint.c.

00237 {
00238         if (!constraint)
00239                 return -1;
00240         return n(constraint, type);
00241 }

Here is the call graph for this function:

struct isl_div* isl_constraint_div ( struct isl_constraint *  constraint,
int  pos 
) [read]

Definition at line 260 of file isl_constraint.c.

00261 {
00262         if (!constraint)
00263                 return NULL;
00264 
00265         isl_assert(constraint->ctx, pos < n(constraint, isl_dim_div),
00266                         return NULL);
00267         return isl_basic_map_div(isl_basic_map_copy(constraint->bmap), pos);
00268 }

Here is the call graph for this function:

struct isl_constraint* isl_constraint_dup ( struct isl_constraint *  c  )  [read]

Definition at line 94 of file isl_constraint.c.

00095 {
00096         if (!c)
00097                 return NULL;
00098 
00099         return isl_basic_map_constraint(isl_basic_map_copy(c->bmap), c->line);
00100 }

Here is the call graph for this function:

struct isl_constraint* isl_constraint_free ( struct isl_constraint *  c  )  [read]

Definition at line 122 of file isl_constraint.c.

00123 {
00124         if (!c)
00125                 return;
00126 
00127         if (--c->ref > 0)
00128                 return;
00129 
00130         isl_basic_map_free(c->bmap);
00131         isl_ctx_deref(c->ctx);
00132         free(c);
00133 }

Here is the call graph for this function:

void isl_constraint_get_coefficient ( struct isl_constraint *  constraint,
enum isl_dim_type  type,
int  pos,
isl_int *  v 
)

Definition at line 250 of file isl_constraint.c.

00252 {
00253         if (!constraint)
00254                 return;
00255 
00256         isl_assert(constraint->ctx, pos < n(constraint, type), return);
00257         isl_int_set(*v, constraint->line[0][offset(constraint, type) + pos]);
00258 }

Here is the call graph for this function:

void isl_constraint_get_constant ( struct isl_constraint *  constraint,
isl_int *  v 
)

Definition at line 243 of file isl_constraint.c.

00244 {
00245         if (!constraint)
00246                 return;
00247         isl_int_set(*v, constraint->line[0][0]);
00248 }

int isl_constraint_is_equal ( struct isl_constraint *  constraint1,
struct isl_constraint *  constraint2 
)

Definition at line 169 of file isl_constraint.c.

00171 {
00172         if (!constraint1 || !constraint2)
00173                 return 0;
00174         return constraint1->bmap == constraint2->bmap &&
00175                constraint1->line == constraint2->line;
00176 }

int isl_constraint_is_equality ( struct isl_constraint *  constraint  ) 

Definition at line 318 of file isl_constraint.c.

00319 {
00320         if (!constraint)
00321                 return -1;
00322         return constraint->line >= constraint->bmap->eq;
00323 }

struct isl_constraint* isl_constraint_negate ( struct isl_constraint *  constraint  )  [read]

Definition at line 298 of file isl_constraint.c.

00299 {
00300         unsigned total;
00301 
00302         if (!constraint)
00303                 return NULL;
00304 
00305         isl_assert(constraint->ctx, !isl_constraint_is_equality(constraint),
00306                         goto error);
00307         isl_assert(constraint->ctx, constraint->bmap->ref == 1, goto error);
00308         total = isl_basic_map_total_dim(constraint->bmap);
00309         isl_seq_neg(constraint->line[0], constraint->line[0], 1 + total);
00310         isl_int_sub_ui(constraint->line[0][0], constraint->line[0][0], 1);
00311         ISL_F_CLR(constraint->bmap, ISL_BASIC_MAP_NORMALIZED);
00312         return constraint;
00313 error:
00314         isl_constraint_free(constraint);
00315         return NULL;
00316 }

Here is the call graph for this function:

struct isl_constraint* isl_constraint_next ( struct isl_constraint *  c  )  [read]

Definition at line 153 of file isl_constraint.c.

00154 {
00155         c = isl_constraint_cow(c);
00156         if (c->line >= c->bmap->eq) {
00157                 c->line++;
00158                 if (c->line < c->bmap->eq + c->bmap->n_eq)
00159                         return c;
00160                 c->line = c->bmap->ineq;
00161         } else
00162                 c->line++;
00163         if (c->line < c->bmap->ineq + c->bmap->n_ineq)
00164                 return c;
00165         isl_constraint_free(c);
00166         return NULL;
00167 }

Here is the call graph for this function:

void isl_constraint_set_coefficient ( struct isl_constraint *  constraint,
enum isl_dim_type  type,
int  pos,
isl_int  v 
)

Definition at line 277 of file isl_constraint.c.

00279 {
00280         if (!constraint)
00281                 return;
00282 
00283         isl_assert(constraint->ctx, pos < n(constraint, type), return);
00284         isl_int_set(constraint->line[0][offset(constraint, type) + pos], v);
00285 }

Here is the call graph for this function:

void isl_constraint_set_constant ( struct isl_constraint *  constraint,
isl_int  v 
)

Definition at line 270 of file isl_constraint.c.

00271 {
00272         if (!constraint)
00273                 return;
00274         isl_int_set(constraint->line[0][0], v);
00275 }

struct isl_constraint* isl_equality_alloc ( struct isl_dim *  dim  )  [read]

Definition at line 62 of file isl_constraint.c.

00063 {
00064         struct isl_basic_map *bmap;
00065 
00066         if (!dim)
00067                 return NULL;
00068 
00069         bmap = isl_basic_map_alloc_dim(dim, 0, 1, 0);
00070         if (!bmap)
00071                 return NULL;
00072 
00073         isl_basic_map_alloc_equality(bmap);
00074         isl_seq_clr(bmap->eq[0], 1 + isl_basic_map_total_dim(bmap));
00075         return isl_basic_map_constraint(bmap, &bmap->eq[0]);
00076 }

Here is the call graph for this function:

struct isl_constraint* isl_inequality_alloc ( struct isl_dim *  dim  )  [read]

Definition at line 78 of file isl_constraint.c.

00079 {
00080         struct isl_basic_map *bmap;
00081 
00082         if (!dim)
00083                 return NULL;
00084 
00085         bmap = isl_basic_map_alloc_dim(dim, 0, 0, 1);
00086         if (!bmap)
00087                 return NULL;
00088 
00089         isl_basic_map_alloc_inequality(bmap);
00090         isl_seq_clr(bmap->ineq[0], 1 + isl_basic_map_total_dim(bmap));
00091         return isl_basic_map_constraint(bmap, &bmap->ineq[0]);
00092 }

Here is the call graph for this function:

static unsigned n ( struct isl_constraint *  c,
enum isl_dim_type  type 
) [static]

Definition at line 4 of file isl_constraint.c.

00005 {
00006         return isl_basic_map_dim(c->bmap, type);
00007 }

Here is the call graph for this function:

static unsigned offset ( struct isl_constraint *  c,
enum isl_dim_type  type 
) [static]

Definition at line 9 of file isl_constraint.c.

00010 {
00011         struct isl_dim *dim = c->bmap->dim;
00012         switch (type) {
00013         case isl_dim_param:     return 1;
00014         case isl_dim_in:        return 1 + dim->nparam;
00015         case isl_dim_out:       return 1 + dim->nparam + dim->n_in;
00016         case isl_dim_div:       return 1 + dim->nparam + dim->n_in + dim->n_out;
00017         }
00018 }

Generated on Mon Jul 13 06:54:10 2009 for ISL - Integer Set Library by  doxygen 1.5.7.1