isl_pw_templ.c

   1 #define xFN(TYPE,NAME) TYPE ## _ ## NAME
   2 #define FN(TYPE,NAME) xFN(TYPE,NAME)
   3 #define xS(TYPE,NAME) struct TYPE ## _ ## NAME
   4 #define S(TYPE,NAME) xS(TYPE,NAME)
   5
   6 #ifdef HAS_TYPE
   7 static __isl_give PW *FN(PW,alloc_)(__isl_take isl_dim *dim,
   8         enum isl_fold type, int n)
   9 #else
  10 static __isl_give PW *FN(PW,alloc_)(__isl_take isl_dim *dim, int n)
  11 #endif
  12 {
  13         isl_ctx *ctx;
  14         struct PW *pw;
  15
  16         if (!dim)
  17                 return NULL;
  18         ctx = isl_dim_get_ctx(dim);
  19         isl_assert(ctx, n >= 0, goto error);
  20         pw = isl_alloc(ctx, struct PW,
  21                         sizeof(struct PW) + (n - 1) * sizeof(S(PW,piece)));
  22         if (!pw)
  23                 goto error;
  24
  25         pw->ref = 1;
  26 #ifdef HAS_TYPE
  27         pw->type = type;
  28 #endif
  29         pw->size = n;
  30         pw->n = 0;
  31         pw->dim = dim;
  32         return pw;
  33 error:
  34         isl_dim_free(dim);
  35         return NULL;
  36 }
  37
  38 #ifdef HAS_TYPE
  39 __isl_give PW *FN(PW,zero)(__isl_take isl_dim *dim, enum isl_fold type)
  40 {
  41         return FN(PW,alloc_)(dim, type, 0);
  42 }
  43 #else
  44 __isl_give PW *FN(PW,zero)(__isl_take isl_dim *dim)
  45 {
  46         return FN(PW,alloc_)(dim, 0);
  47 }
  48 #endif
  49
  50 __isl_give PW *FN(PW,add_piece)(__isl_take PW *pw,
  51         __isl_take isl_set *set, __isl_take EL *el)
  52 {
  53         isl_ctx *ctx;
  54         isl_dim *el_dim = NULL;
  55
  56         if (!pw || !set || !el)
  57                 goto error;
  58
  59         if (isl_set_plain_is_empty(set) || FN(EL,IS_ZERO)(el)) {
  60                 isl_set_free(set);
  61                 FN(EL,free)(el);
  62                 return pw;
  63         }
  64
  65         ctx = isl_set_get_ctx(set);
  66 #ifdef HAS_TYPE
  67         if (pw->type != el->type)
  68                 isl_die(ctx, isl_error_invalid, "fold types don't match",
  69                         goto error);
  70 #endif
  71         el_dim = FN(EL,get_dim(el));
  72         isl_assert(ctx, isl_dim_equal(pw->dim, el_dim), goto error);
  73         isl_assert(ctx, pw->n < pw->size, goto error);
  74
  75         pw->p[pw->n].set = set;
  76         pw->p[pw->n].FIELD = el;
  77         pw->n++;
  78
  79         isl_dim_free(el_dim);
  80         return pw;
  81 error:
  82         isl_dim_free(el_dim);
  83         FN(PW,free)(pw);
  84         isl_set_free(set);
  85         FN(EL,free)(el);
  86         return NULL;
  87 }
  88
  89 #ifdef HAS_TYPE
  90 __isl_give PW *FN(PW,alloc)(enum isl_fold type,
  91         __isl_take isl_set *set, __isl_take EL *el)
  92 #else
  93 __isl_give PW *FN(PW,alloc)(__isl_take isl_set *set, __isl_take EL *el)
  94 #endif
  95 {
  96         PW *pw;
  97
  98         if (!set || !el)
  99                 goto error;
 100
 101 #ifdef HAS_TYPE
 102         pw = FN(PW,alloc_)(isl_set_get_dim(set), type, 1);
 103 #else
 104         pw = FN(PW,alloc_)(isl_set_get_dim(set), 1);
 105 #endif
 106
 107         return FN(PW,add_piece)(pw, set, el);
 108 error:
 109         isl_set_free(set);
 110         FN(EL,free)(el);
 111         return NULL;
 112 }
 113
 114 __isl_give PW *FN(PW,dup)(__isl_keep PW *pw)
 115 {
 116         int i;
 117         PW *dup;
 118
 119         if (!pw)
 120                 return NULL;
 121
 122 #ifdef HAS_TYPE
 123         dup = FN(PW,alloc_)(isl_dim_copy(pw->dim), pw->type, pw->n);
 124 #else
 125         dup = FN(PW,alloc_)(isl_dim_copy(pw->dim), pw->n);
 126 #endif
 127         if (!dup)
 128                 return NULL;
 129
 130         for (i = 0; i < pw->n; ++i)
 131                 dup = FN(PW,add_piece)(dup, isl_set_copy(pw->p[i].set),
 132                                             FN(EL,copy)(pw->p[i].FIELD));
 133
 134         return dup;
 135 }
 136
 137 __isl_give PW *FN(PW,cow)(__isl_take PW *pw)
 138 {
 139         if (!pw)
 140                 return NULL;
 141
 142         if (pw->ref == 1)
 143                 return pw;
 144         pw->ref--;
 145         return FN(PW,dup)(pw);
 146 }
 147
 148 __isl_give PW *FN(PW,copy)(__isl_keep PW *pw)
 149 {
 150         if (!pw)
 151                 return NULL;
 152
 153         pw->ref++;
 154         return pw;
 155 }
 156
 157 void *FN(PW,free)(__isl_take PW *pw)
 158 {
 159         int i;
 160
 161         if (!pw)
 162                 return NULL;
 163         if (--pw->ref > 0)
 164                 return NULL;
 165
 166         for (i = 0; i < pw->n; ++i) {
 167                 isl_set_free(pw->p[i].set);
 168                 FN(EL,free)(pw->p[i].FIELD);
 169         }
 170         isl_dim_free(pw->dim);
 171         free(pw);
 172
 173         return NULL;
 174 }
 175
 176 int FN(PW,is_zero)(__isl_keep PW *pw)
 177 {
 178         if (!pw)
 179                 return -1;
 180
 181         return pw->n == 0;
 182 }
 183
 184 __isl_give PW *FN(PW,add)(__isl_take PW *pw1, __isl_take PW *pw2)
 185 {
 186         int i, j, n;
 187         struct PW *res;
 188         isl_ctx *ctx;
 189         isl_set *set;
 190
 191         if (!pw1 || !pw2)
 192                 goto error;
 193
 194         ctx = isl_dim_get_ctx(pw1->dim);
 195 #ifdef HAS_TYPE
 196         if (pw1->type != pw2->type)
 197                 isl_die(ctx, isl_error_invalid,
 198                         "fold types don't match", goto error);
 199 #endif
 200         isl_assert(ctx, isl_dim_equal(pw1->dim, pw2->dim), goto error);
 201
 202         if (FN(PW,is_zero)(pw1)) {
 203                 FN(PW,free)(pw1);
 204                 return pw2;
 205         }
 206
 207         if (FN(PW,is_zero)(pw2)) {
 208                 FN(PW,free)(pw2);
 209                 return pw1;
 210         }
 211
 212         n = (pw1->n + 1) * (pw2->n + 1);
 213 #ifdef HAS_TYPE
 214         res = FN(PW,alloc_)(isl_dim_copy(pw1->dim), pw1->type, n);
 215 #else
 216         res = FN(PW,alloc_)(isl_dim_copy(pw1->dim), n);
 217 #endif
 218
 219         for (i = 0; i < pw1->n; ++i) {
 220                 set = isl_set_copy(pw1->p[i].set);
 221                 for (j = 0; j < pw2->n; ++j) {
 222                         struct isl_set *common;
 223                         EL *sum;
 224                         set = isl_set_subtract(set,
 225                                         isl_set_copy(pw2->p[j].set));
 226                         common = isl_set_intersect(isl_set_copy(pw1->p[i].set),
 227                                                 isl_set_copy(pw2->p[j].set));
 228                         if (isl_set_plain_is_empty(common)) {
 229                                 isl_set_free(common);
 230                                 continue;
 231                         }
 232
 233                         sum = FN(EL,add_on_domain)(common,
 234                                                    FN(EL,copy)(pw1->p[i].FIELD),
 235                                                    FN(EL,copy)(pw2->p[j].FIELD));
 236
 237                         res = FN(PW,add_piece)(res, common, sum);
 238                 }
 239                 res = FN(PW,add_piece)(res, set, FN(EL,copy)(pw1->p[i].FIELD));
 240         }
 241
 242         for (j = 0; j < pw2->n; ++j) {
 243                 set = isl_set_copy(pw2->p[j].set);
 244                 for (i = 0; i < pw1->n; ++i)
 245                         set = isl_set_subtract(set,
 246                                         isl_set_copy(pw1->p[i].set));
 247                 res = FN(PW,add_piece)(res, set, FN(EL,copy)(pw2->p[j].FIELD));
 248         }
 249
 250         FN(PW,free)(pw1);
 251         FN(PW,free)(pw2);
 252
 253         return res;
 254 error:
 255         FN(PW,free)(pw1);
 256         FN(PW,free)(pw2);
 257         return NULL;
 258 }
 259
 260 __isl_give PW *FN(PW,add_disjoint)(__isl_take PW *pw1, __isl_take PW *pw2)
 261 {
 262         int i;
 263         isl_ctx *ctx;
 264         PW *res;
 265
 266         if (!pw1 || !pw2)
 267                 goto error;
 268
 269         ctx = isl_dim_get_ctx(pw1->dim);
 270 #ifdef HAS_TYPE
 271         if (pw1->type != pw2->type)
 272                 isl_die(ctx, isl_error_invalid,
 273                         "fold types don't match", goto error);
 274 #endif
 275         isl_assert(ctx, isl_dim_equal(pw1->dim, pw2->dim), goto error);
 276
 277         if (FN(PW,is_zero)(pw1)) {
 278                 FN(PW,free)(pw1);
 279                 return pw2;
 280         }
 281
 282         if (FN(PW,is_zero)(pw2)) {
 283                 FN(PW,free)(pw2);
 284                 return pw1;
 285         }
 286
 287 #ifdef HAS_TYPE
 288         res = FN(PW,alloc_)(isl_dim_copy(pw1->dim), pw1->type, pw1->n + pw2->n);
 289 #else
 290         res = FN(PW,alloc_)(isl_dim_copy(pw1->dim), pw1->n + pw2->n);
 291 #endif
 292
 293         for (i = 0; i < pw1->n; ++i)
 294                 res = FN(PW,add_piece)(res,
 295                                 isl_set_copy(pw1->p[i].set),
 296                                 FN(EL,copy)(pw1->p[i].FIELD));
 297
 298         for (i = 0; i < pw2->n; ++i)
 299                 res = FN(PW,add_piece)(res,
 300                                 isl_set_copy(pw2->p[i].set),
 301                                 FN(EL,copy)(pw2->p[i].FIELD));
 302
 303         FN(PW,free)(pw1);
 304         FN(PW,free)(pw2);
 305
 306         return res;
 307 error:
 308         FN(PW,free)(pw1);
 309         FN(PW,free)(pw2);
 310         return NULL;
 311 }
 312
 313 __isl_give isl_qpolynomial *FN(PW,eval)(__isl_take PW *pw,
 314         __isl_take isl_point *pnt)
 315 {
 316         int i;
 317         int found = 0;
 318         isl_ctx *ctx;
 319         isl_dim *pnt_dim = NULL;
 320         isl_qpolynomial *qp;
 321
 322         if (!pw || !pnt)
 323                 goto error;
 324         ctx = isl_point_get_ctx(pnt);
 325         pnt_dim = isl_point_get_dim(pnt);
 326         isl_assert(ctx, isl_dim_equal(pnt_dim, pw->dim), goto error);
 327
 328         for (i = 0; i < pw->n; ++i) {
 329                 found = isl_set_contains_point(pw->p[i].set, pnt);
 330                 if (found < 0)
 331                         goto error;
 332                 if (found)
 333                         break;
 334         }
 335         if (found)
 336                 qp = FN(EL,eval)(FN(EL,copy)(pw->p[i].FIELD),
 337                                             isl_point_copy(pnt));
 338         else
 339                 qp = isl_qpolynomial_zero(isl_dim_copy(pw->dim));
 340         FN(PW,free)(pw);
 341         isl_dim_free(pnt_dim);
 342         isl_point_free(pnt);
 343         return qp;
 344 error:
 345         FN(PW,free)(pw);
 346         isl_dim_free(pnt_dim);
 347         isl_point_free(pnt);
 348         return NULL;
 349 }
 350
 351 __isl_give isl_set *FN(PW,domain)(__isl_take PW *pw)
 352 {
 353         int i;
 354         isl_set *dom;
 355
 356         if (!pw)
 357                 return NULL;
 358
 359         dom = isl_set_empty(isl_dim_copy(pw->dim));
 360         for (i = 0; i < pw->n; ++i)
 361                 dom = isl_set_union_disjoint(dom, isl_set_copy(pw->p[i].set));
 362
 363         FN(PW,free)(pw);
 364
 365         return dom;
 366 }
 367
 368 __isl_give PW *FN(PW,intersect_domain)(__isl_take PW *pw, __isl_take isl_set *set)
 369 {
 370         int i;
 371
 372         if (!pw || !set)
 373                 goto error;
 374
 375         if (pw->n == 0) {
 376                 isl_set_free(set);
 377                 return pw;
 378         }
 379
 380         pw = FN(PW,cow)(pw);
 381         if (!pw)
 382                 goto error;
 383
 384         for (i = pw->n - 1; i >= 0; --i) {
 385                 isl_basic_set *aff;
 386                 pw->p[i].set = isl_set_intersect(pw->p[i].set, isl_set_copy(set));
 387                 if (!pw->p[i].set)
 388                         goto error;
 389                 aff = isl_set_affine_hull(isl_set_copy(pw->p[i].set));
 390                 pw->p[i].FIELD = FN(EL,substitute_equalities)(pw->p[i].FIELD,
 391                                                                 aff);
 392                 if (isl_set_plain_is_empty(pw->p[i].set)) {
 393                         isl_set_free(pw->p[i].set);
 394                         FN(EL,free)(pw->p[i].FIELD);
 395                         if (i != pw->n - 1)
 396                                 pw->p[i] = pw->p[pw->n - 1];
 397                         pw->n--;
 398                 }
 399         }
 400
 401         isl_set_free(set);
 402         return pw;
 403 error:
 404         isl_set_free(set);
 405         FN(PW,free)(pw);
 406         return NULL;
 407 }
 408
 409 __isl_give PW *FN(PW,gist)(__isl_take PW *pw, __isl_take isl_set *context)
 410 {
 411         int i;
 412         isl_basic_set *hull = NULL;
 413
 414         if (!pw || !context)
 415                 goto error;
 416
 417         if (pw->n == 0) {
 418                 isl_set_free(context);
 419                 return pw;
 420         }
 421
 422         context = isl_set_compute_divs(context);
 423         hull = isl_set_simple_hull(isl_set_copy(context));
 424
 425         pw = FN(PW,cow)(pw);
 426         if (!pw)
 427                 goto error;
 428
 429         for (i = pw->n - 1; i >= 0; --i) {
 430                 pw->p[i].set = isl_set_intersect(pw->p[i].set,
 431                                                  isl_set_copy(context));
 432                 if (!pw->p[i].set)
 433                         goto error;
 434                 pw->p[i].FIELD = FN(EL,gist)(pw->p[i].FIELD,
 435                                              isl_set_copy(pw->p[i].set));
 436                 pw->p[i].set = isl_set_gist_basic_set(pw->p[i].set,
 437                                                 isl_basic_set_copy(hull));
 438                 if (!pw->p[i].set)
 439                         goto error;
 440                 if (isl_set_plain_is_empty(pw->p[i].set)) {
 441                         isl_set_free(pw->p[i].set);
 442                         FN(EL,free)(pw->p[i].FIELD);
 443                         if (i != pw->n - 1)
 444                                 pw->p[i] = pw->p[pw->n - 1];
 445                         pw->n--;
 446                 }
 447         }
 448
 449         isl_basic_set_free(hull);
 450         isl_set_free(context);
 451
 452         return pw;
 453 error:
 454         FN(PW,free)(pw);
 455         isl_basic_set_free(hull);
 456         isl_set_free(context);
 457         return NULL;
 458 }
 459
 460 __isl_give PW *FN(PW,coalesce)(__isl_take PW *pw)
 461 {
 462         int i, j;
 463
 464         if (!pw)
 465                 return NULL;
 466         if (pw->n == 0)
 467                 return pw;
 468
 469         for (i = pw->n - 1; i >= 0; --i) {
 470                 for (j = i - 1; j >= 0; --j) {
 471                         if (!FN(EL,plain_is_equal)(pw->p[i].FIELD,
 472                                                         pw->p[j].FIELD))
 473                                 continue;
 474                         pw->p[j].set = isl_set_union(pw->p[j].set,
 475                                                         pw->p[i].set);
 476                         FN(EL,free)(pw->p[i].FIELD);
 477                         if (i != pw->n - 1)
 478                                 pw->p[i] = pw->p[pw->n - 1];
 479                         pw->n--;
 480                         break;
 481                 }
 482                 if (j >= 0)
 483                         continue;
 484                 pw->p[i].set = isl_set_coalesce(pw->p[i].set);
 485                 if (!pw->p[i].set)
 486                         goto error;
 487         }
 488
 489         return pw;
 490 error:
 491         FN(PW,free)(pw);
 492         return NULL;
 493 }
 494
 495 isl_ctx *FN(PW,get_ctx)(__isl_keep PW *pw)
 496 {
 497         return pw ? isl_dim_get_ctx(pw->dim) : NULL;
 498 }
 499
 500 int FN(PW,involves_dims)(__isl_keep PW *pw, enum isl_dim_type type,
 501         unsigned first, unsigned n)
 502 {
 503         int i;
 504
 505         if (!pw)
 506                 return -1;
 507         if (pw->n == 0 || n == 0)
 508                 return 0;
 509         for (i = 0; i < pw->n; ++i) {
 510                 int involves = FN(EL,involves_dims)(pw->p[i].FIELD,
 511                                                         type, first, n);
 512                 if (involves < 0 || involves)
 513                         return involves;
 514                 involves = isl_set_involves_dims(pw->p[i].set, type, first, n);
 515                 if (involves < 0 || involves)
 516                         return involves;
 517         }
 518         return 0;
 519 }
 520
 521 __isl_give PW *FN(PW,set_dim_name)(__isl_take PW *pw,
 522         enum isl_dim_type type, unsigned pos, const char *s)
 523 {
 524         int i;
 525
 526         pw = FN(PW,cow)(pw);
 527         if (!pw)
 528                 return NULL;
 529
 530         pw->dim = isl_dim_set_name(pw->dim, type, pos, s);
 531         if (!pw->dim)
 532                 goto error;
 533
 534         for (i = 0; i < pw->n; ++i) {
 535                 pw->p[i].set = isl_set_set_dim_name(pw->p[i].set, type, pos, s);
 536                 if (!pw->p[i].set)
 537                         goto error;
 538                 pw->p[i].FIELD = FN(EL,set_dim_name)(pw->p[i].FIELD, type, pos, s);
 539                 if (!pw->p[i].FIELD)
 540                         goto error;
 541         }
 542
 543         return pw;
 544 error:
 545         FN(PW,free)(pw);
 546         return NULL;
 547 }
 548
 549 __isl_give PW *FN(PW,drop_dims)(__isl_take PW *pw,
 550         enum isl_dim_type type, unsigned first, unsigned n)
 551 {
 552         int i;
 553
 554         if (!pw)
 555                 return NULL;
 556         if (n == 0 && !isl_dim_get_tuple_name(pw->dim, type))
 557                 return pw;
 558
 559         pw = FN(PW,cow)(pw);
 560         if (!pw)
 561                 return NULL;
 562         pw->dim = isl_dim_drop(pw->dim, type, first, n);
 563         if (!pw->dim)
 564                 goto error;
 565         for (i = 0; i < pw->n; ++i) {
 566                 pw->p[i].set = isl_set_drop(pw->p[i].set, type, first, n);
 567                 if (!pw->p[i].set)
 568                         goto error;
 569                 pw->p[i].FIELD = FN(EL,drop_dims)(pw->p[i].FIELD, type, first, n);
 570                 if (!pw->p[i].FIELD)
 571                         goto error;
 572         }
 573
 574         return pw;
 575 error:
 576         FN(PW,free)(pw);
 577         return NULL;
 578 }
 579
 580 __isl_give PW *FN(PW,insert_dims)(__isl_take PW *pw, enum isl_dim_type type,
 581         unsigned first, unsigned n)
 582 {
 583         int i;
 584
 585         if (!pw)
 586                 return NULL;
 587         if (n == 0 && !isl_dim_is_named_or_nested(pw->dim, type))
 588                 return pw;
 589
 590         pw = FN(PW,cow)(pw);
 591         if (!pw)
 592                 return NULL;
 593
 594         pw->dim = isl_dim_insert(pw->dim, type, first, n);
 595         if (!pw->dim)
 596                 goto error;
 597
 598         for (i = 0; i < pw->n; ++i) {
 599                 pw->p[i].set = isl_set_insert(pw->p[i].set, type, first, n);
 600                 if (!pw->p[i].set)
 601                         goto error;
 602                 pw->p[i].FIELD = FN(EL,insert_dims)(pw->p[i].FIELD,
 603                                                                 type, first, n);
 604                 if (!pw->p[i].FIELD)
 605                         goto error;
 606         }
 607
 608         return pw;
 609 error:
 610         FN(PW,free)(pw);
 611         return NULL;
 612 }
 613
 614 __isl_give PW *FN(PW,fix_dim)(__isl_take PW *pw,
 615         enum isl_dim_type type, unsigned pos, isl_int v)
 616 {
 617         int i;
 618
 619         if (!pw)
 620                 return NULL;
 621
 622         pw = FN(PW,cow)(pw);
 623         if (!pw)
 624                 return NULL;
 625         for (i = 0; i < pw->n; ++i) {
 626                 pw->p[i].set = isl_set_fix(pw->p[i].set, type, pos, v);
 627                 if (!pw->p[i].set)
 628                         goto error;
 629         }
 630
 631         return pw;
 632 error:
 633         FN(PW,free)(pw);
 634         return NULL;
 635 }
 636
 637 unsigned FN(PW,dim)(__isl_keep PW *pw, enum isl_dim_type type)
 638 {
 639         return pw ? isl_dim_size(pw->dim, type) : 0;
 640 }
 641
 642 __isl_give PW *FN(PW,split_dims)(__isl_take PW *pw,
 643         enum isl_dim_type type, unsigned first, unsigned n)
 644 {
 645         int i;
 646
 647         if (!pw)
 648                 return NULL;
 649         if (n == 0)
 650                 return pw;
 651
 652         pw = FN(PW,cow)(pw);
 653         if (!pw)
 654                 return NULL;
 655         if (!pw->dim)
 656                 goto error;
 657         for (i = 0; i < pw->n; ++i) {
 658                 pw->p[i].set = isl_set_split_dims(pw->p[i].set, type, first, n);
 659                 if (!pw->p[i].set)
 660                         goto error;
 661         }
 662
 663         return pw;
 664 error:
 665         FN(PW,free)(pw);
 666         return NULL;
 667 }
 668
 669 /* Compute the maximal value attained by the piecewise quasipolynomial
 670  * on its domain or zero if the domain is empty.
 671  * In the worst case, the domain is scanned completely,
 672  * so the domain is assumed to be bounded.
 673  */
 674 __isl_give isl_qpolynomial *FN(PW,opt)(__isl_take PW *pw, int max)
 675 {
 676         int i;
 677         isl_qpolynomial *opt;
 678
 679         if (!pw)
 680                 return NULL;
 681
 682         if (pw->n == 0) {
 683                 isl_dim *dim = isl_dim_copy(pw->dim);
 684                 FN(PW,free)(pw);
 685                 return isl_qpolynomial_zero(dim);
 686         }
 687
 688         opt = FN(EL,opt_on_domain)(FN(EL,copy)(pw->p[0].FIELD),
 689                                         isl_set_copy(pw->p[0].set), max);
 690         for (i = 1; i < pw->n; ++i) {
 691                 isl_qpolynomial *opt_i;
 692                 opt_i = FN(EL,opt_on_domain)(FN(EL,copy)(pw->p[i].FIELD),
 693                                                 isl_set_copy(pw->p[i].set), max);
 694                 if (max)
 695                         opt = isl_qpolynomial_max_cst(opt, opt_i);
 696                 else
 697                         opt = isl_qpolynomial_min_cst(opt, opt_i);
 698         }
 699
 700         FN(PW,free)(pw);
 701         return opt;
 702 }
 703
 704 __isl_give isl_qpolynomial *FN(PW,max)(__isl_take PW *pw)
 705 {
 706         return FN(PW,opt)(pw, 1);
 707 }
 708
 709 __isl_give isl_qpolynomial *FN(PW,min)(__isl_take PW *pw)
 710 {
 711         return FN(PW,opt)(pw, 0);
 712 }
 713
 714 __isl_give isl_dim *FN(PW,get_dim)(__isl_keep PW *pw)
 715 {
 716         return pw ? isl_dim_copy(pw->dim) : NULL;
 717 }
 718
 719 __isl_give PW *FN(PW,reset_dim)(__isl_take PW *pw, __isl_take isl_dim *dim)
 720 {
 721         int i;
 722
 723         pw = FN(PW,cow)(pw);
 724         if (!pw || !dim)
 725                 goto error;
 726
 727         for (i = 0; i < pw->n; ++i) {
 728                 pw->p[i].set = isl_set_reset_dim(pw->p[i].set,
 729                                                  isl_dim_copy(dim));
 730                 if (!pw->p[i].set)
 731                         goto error;
 732                 pw->p[i].FIELD = FN(EL,reset_dim)(pw->p[i].FIELD,
 733                                                   isl_dim_copy(dim));
 734                 if (!pw->p[i].FIELD)
 735                         goto error;
 736         }
 737         isl_dim_free(pw->dim);
 738         pw->dim = dim;
 739
 740         return pw;
 741 error:
 742         isl_dim_free(dim);
 743         FN(PW,free)(pw);
 744         return NULL;
 745 }
 746
 747 int FN(PW,has_equal_dim)(__isl_keep PW *pw1, __isl_keep PW *pw2)
 748 {
 749         if (!pw1 || !pw2)
 750                 return -1;
 751
 752         return isl_dim_equal(pw1->dim, pw2->dim);
 753 }
 754
 755 __isl_give PW *FN(PW,morph)(__isl_take PW *pw, __isl_take isl_morph *morph)
 756 {
 757         int i;
 758         isl_ctx *ctx;
 759
 760         if (!pw || !morph)
 761                 goto error;
 762
 763         ctx = isl_dim_get_ctx(pw->dim);
 764         isl_assert(ctx, isl_dim_equal(pw->dim, morph->dom->dim),
 765                 goto error);
 766
 767         pw = FN(PW,cow)(pw);
 768         if (!pw)
 769                 goto error;
 770         isl_dim_free(pw->dim);
 771         pw->dim = isl_dim_copy(morph->ran->dim);
 772         if (!pw->dim)
 773                 goto error;
 774
 775         for (i = 0; i < pw->n; ++i) {
 776                 pw->p[i].set = isl_morph_set(isl_morph_copy(morph), pw->p[i].set);
 777                 if (!pw->p[i].set)
 778                         goto error;
 779                 pw->p[i].FIELD = FN(EL,morph)(pw->p[i].FIELD,
 780                                                 isl_morph_copy(morph));
 781                 if (!pw->p[i].FIELD)
 782                         goto error;
 783         }
 784
 785         isl_morph_free(morph);
 786
 787         return pw;
 788 error:
 789         FN(PW,free)(pw);
 790         isl_morph_free(morph);
 791         return NULL;
 792 }
 793
 794 int FN(PW,foreach_piece)(__isl_keep PW *pw,
 795         int (*fn)(__isl_take isl_set *set, __isl_take EL *el, void *user),
 796         void *user)
 797 {
 798         int i;
 799
 800         if (!pw)
 801                 return -1;
 802
 803         for (i = 0; i < pw->n; ++i)
 804                 if (fn(isl_set_copy(pw->p[i].set),
 805                                 FN(EL,copy)(pw->p[i].FIELD), user) < 0)
 806                         return -1;
 807
 808         return 0;
 809 }
 810
 811 static int any_divs(__isl_keep isl_set *set)
 812 {
 813         int i;
 814
 815         if (!set)
 816                 return -1;
 817
 818         for (i = 0; i < set->n; ++i)
 819                 if (set->p[i]->n_div > 0)
 820                         return 1;
 821
 822         return 0;
 823 }
 824
 825 static int foreach_lifted_subset(__isl_take isl_set *set, __isl_take EL *el,
 826         int (*fn)(__isl_take isl_set *set, __isl_take EL *el,
 827                     void *user), void *user)
 828 {
 829         int i;
 830
 831         if (!set || !el)
 832                 goto error;
 833
 834         for (i = 0; i < set->n; ++i) {
 835                 isl_set *lift;
 836                 EL *copy;
 837
 838                 lift = isl_set_from_basic_set(isl_basic_set_copy(set->p[i]));
 839                 lift = isl_set_lift(lift);
 840
 841                 copy = FN(EL,copy)(el);
 842                 copy = FN(EL,lift)(copy, isl_set_get_dim(lift));
 843
 844                 if (fn(lift, copy, user) < 0)
 845                         goto error;
 846         }
 847
 848         isl_set_free(set);
 849         FN(EL,free)(el);
 850
 851         return 0;
 852 error:
 853         isl_set_free(set);
 854         FN(EL,free)(el);
 855         return -1;
 856 }
 857
 858 int FN(PW,foreach_lifted_piece)(__isl_keep PW *pw,
 859         int (*fn)(__isl_take isl_set *set, __isl_take EL *el,
 860                     void *user), void *user)
 861 {
 862         int i;
 863
 864         if (!pw)
 865                 return -1;
 866
 867         for (i = 0; i < pw->n; ++i) {
 868                 isl_set *set;
 869                 EL *el;
 870
 871                 set = isl_set_copy(pw->p[i].set);
 872                 el = FN(EL,copy)(pw->p[i].FIELD);
 873                 if (!any_divs(set)) {
 874                         if (fn(set, el, user) < 0)
 875                                 return -1;
 876                         continue;
 877                 }
 878                 if (foreach_lifted_subset(set, el, fn, user) < 0)
 879                         return -1;
 880         }
 881
 882         return 0;
 883 }
 884
 885 __isl_give PW *FN(PW,move_dims)(__isl_take PW *pw,
 886         enum isl_dim_type dst_type, unsigned dst_pos,
 887         enum isl_dim_type src_type, unsigned src_pos, unsigned n)
 888 {
 889         int i;
 890
 891         pw = FN(PW,cow)(pw);
 892         if (!pw)
 893                 return NULL;
 894
 895         pw->dim = isl_dim_move(pw->dim, dst_type, dst_pos, src_type, src_pos, n);
 896         if (!pw->dim)
 897                 goto error;
 898
 899         for (i = 0; i < pw->n; ++i) {
 900                 pw->p[i].set = isl_set_move_dims(pw->p[i].set,
 901                                                 dst_type, dst_pos,
 902                                                 src_type, src_pos, n);
 903                 if (!pw->p[i].set)
 904                         goto error;
 905                 pw->p[i].FIELD = FN(EL,move_dims)(pw->p[i].FIELD,
 906                                         dst_type, dst_pos, src_type, src_pos, n);
 907                 if (!pw->p[i].FIELD)
 908                         goto error;
 909         }
 910
 911         return pw;
 912 error:
 913         FN(PW,free)(pw);
 914         return NULL;
 915 }
 916
 917 __isl_give PW *FN(PW,realign)(__isl_take PW *pw, __isl_take isl_reordering *exp)
 918 {
 919         int i;
 920
 921         pw = FN(PW,cow)(pw);
 922         if (!pw || !exp)
 923                 return NULL;
 924
 925         for (i = 0; i < pw->n; ++i) {
 926                 pw->p[i].set = isl_set_realign(pw->p[i].set,
 927                                                     isl_reordering_copy(exp));
 928                 if (!pw->p[i].set)
 929                         goto error;
 930                 pw->p[i].FIELD = FN(EL,realign)(pw->p[i].FIELD,
 931                                                     isl_reordering_copy(exp));
 932                 if (!pw->p[i].FIELD)
 933                         goto error;
 934         }
 935
 936         pw = FN(PW,reset_dim)(pw, isl_dim_copy(exp->dim));
 937
 938         isl_reordering_free(exp);
 939         return pw;
 940 error:
 941         isl_reordering_free(exp);
 942         FN(PW,free)(pw);
 943         return NULL;
 944 }
 945
 946 __isl_give PW *FN(PW,mul_isl_int)(__isl_take PW *pw, isl_int v)
 947 {
 948         int i;
 949
 950         if (isl_int_is_one(v))
 951                 return pw;
 952         if (pw && isl_int_is_zero(v)) {
 953                 PW *zero;
 954                 isl_dim *dim = FN(PW,get_dim)(pw);
 955 #ifdef HAS_TYPE
 956                 zero = FN(PW,zero)(dim, pw->type);
 957 #else
 958                 zero = FN(PW,zero)(dim);
 959 #endif
 960                 FN(PW,free)(pw);
 961                 return zero;
 962         }
 963         pw = FN(PW,cow)(pw);
 964         if (!pw)
 965                 return NULL;
 966         if (pw->n == 0)
 967                 return pw;
 968
 969 #ifdef HAS_TYPE
 970         if (isl_int_is_neg(v))
 971                 pw->type = isl_fold_type_negate(pw->type);
 972 #endif
 973         for (i = 0; i < pw->n; ++i) {
 974                 pw->p[i].FIELD = FN(EL,scale)(pw->p[i].FIELD, v);
 975                 if (!pw->p[i].FIELD)
 976                         goto error;
 977         }
 978
 979         return pw;
 980 error:
 981         FN(PW,free)(pw);
 982         return NULL;
 983 }