isl_output.c

   1 /*
   2  * Copyright 2008-2009 Katholieke Universiteit Leuven
   3  * Copyright 2010      INRIA Saclay
   4  *
   5  * Use of this software is governed by the GNU LGPLv2.1 license
   6  *
   7  * Written by Sven Verdoolaege, K.U.Leuven, Departement
   8  * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
   9  * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,
  10  * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France
  11  */
  12
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <isl_set.h>
  16 #include <isl_seq.h>
  17 #include <isl_polynomial_private.h>
  18 #include <isl_printer_private.h>
  19 #include <isl_dim_private.h>
  20 #include <isl_map_private.h>
  21
  22 static const char *s_to[2] = { " -> ", " \\to " };
  23 static const char *s_and[2] = { " and ", " \\wedge " };
  24 static const char *s_or[2] = { " or ", " \\vee " };
  25 static const char *s_le[2] = { "<=", "\\le" };
  26 static const char *s_ge[2] = { ">=", "\\ge" };
  27 static const char *s_open_set[2] = { "{ ", "\\{\\, " };
  28 static const char *s_close_set[2] = { " }", " \\,\\}" };
  29 static const char *s_open_list[2] = { "[", "(" };
  30 static const char *s_close_list[2] = { "]", ")" };
  31 static const char *s_such_that[2] = { " : ", " \\mid " };
  32 static const char *s_open_exists[2] = { "exists (", "\\exists \\, " };
  33 static const char *s_close_exists[2] = { ")", "" };
  34 static const char *s_div_prefix[2] = { "e", "\\alpha_" };
  35 static const char *s_param_prefix[2] = { "p", "p_" };
  36 static const char *s_input_prefix[2] = { "i", "i_" };
  37 static const char *s_output_prefix[2] = { "o", "o_" };
  38
  39 static __isl_give isl_printer *print_constraint_polylib(
  40         struct isl_basic_map *bmap, int ineq, int n, __isl_take isl_printer *p)
  41 {
  42         int i;
  43         unsigned n_in = isl_basic_map_dim(bmap, isl_dim_in);
  44         unsigned n_out = isl_basic_map_dim(bmap, isl_dim_out);
  45         unsigned nparam = isl_basic_map_dim(bmap, isl_dim_param);
  46         isl_int *c = ineq ? bmap->ineq[n] : bmap->eq[n];
  47
  48         p = isl_printer_start_line(p);
  49         p = isl_printer_print_int(p, ineq);
  50         for (i = 0; i < n_out; ++i) {
  51                 p = isl_printer_print_str(p, " ");
  52                 p = isl_printer_print_isl_int(p, c[1+nparam+n_in+i]);
  53         }
  54         for (i = 0; i < n_in; ++i) {
  55                 p = isl_printer_print_str(p, " ");
  56                 p = isl_printer_print_isl_int(p, c[1+nparam+i]);
  57         }
  58         for (i = 0; i < bmap->n_div; ++i) {
  59                 p = isl_printer_print_str(p, " ");
  60                 p = isl_printer_print_isl_int(p, c[1+nparam+n_in+n_out+i]);
  61         }
  62         for (i = 0; i < nparam; ++i) {
  63                 p = isl_printer_print_str(p, " ");
  64                 p = isl_printer_print_isl_int(p, c[1+i]);
  65         }
  66         p = isl_printer_print_str(p, " ");
  67         p = isl_printer_print_isl_int(p, c[0]);
  68         p = isl_printer_end_line(p);
  69         return p;
  70 }
  71
  72 static __isl_give isl_printer *print_constraints_polylib(
  73         struct isl_basic_map *bmap, __isl_take isl_printer *p)
  74 {
  75         int i;
  76
  77         p = isl_printer_set_isl_int_width(p, 5);
  78
  79         for (i = 0; i < bmap->n_eq; ++i)
  80                 p = print_constraint_polylib(bmap, 0, i, p);
  81         for (i = 0; i < bmap->n_ineq; ++i)
  82                 p = print_constraint_polylib(bmap, 1, i, p);
  83
  84         return p;
  85 }
  86
  87 static __isl_give isl_printer *bset_print_constraints_polylib(
  88         struct isl_basic_set *bset, __isl_take isl_printer *p)
  89 {
  90         return print_constraints_polylib((struct isl_basic_map *)bset, p);
  91 }
  92
  93 static __isl_give isl_printer *isl_basic_map_print_polylib(
  94         __isl_keep isl_basic_map *bmap, __isl_take isl_printer *p)
  95 {
  96         unsigned total = isl_basic_map_total_dim(bmap);
  97         p = isl_printer_start_line(p);
  98         p = isl_printer_print_int(p, bmap->n_eq + bmap->n_ineq);
  99         p = isl_printer_print_str(p, " ");
 100         p = isl_printer_print_int(p, 1 + total + 1);
 101         p = isl_printer_end_line(p);
 102         return print_constraints_polylib(bmap, p);
 103 }
 104
 105 static __isl_give isl_printer *isl_basic_set_print_polylib(
 106         __isl_keep isl_basic_set *bset, __isl_take isl_printer *p)
 107 {
 108         return isl_basic_map_print_polylib((struct isl_basic_map *)bset, p);
 109 }
 110
 111 static __isl_give isl_printer *isl_map_print_polylib(__isl_keep isl_map *map,
 112         __isl_take isl_printer *p)
 113 {
 114         int i;
 115
 116         p = isl_printer_start_line(p);
 117         p = isl_printer_print_int(p, map->n);
 118         p = isl_printer_end_line(p);
 119         for (i = 0; i < map->n; ++i) {
 120                 p = isl_printer_start_line(p);
 121                 p = isl_printer_end_line(p);
 122                 p = isl_basic_map_print_polylib(map->p[i], p);
 123         }
 124         return p;
 125 }
 126
 127 static __isl_give isl_printer *isl_set_print_polylib(__isl_keep isl_set *set,
 128         __isl_take isl_printer *p)
 129 {
 130         return isl_map_print_polylib((struct isl_map *)set, p);
 131 }
 132
 133 static int count_same_name(__isl_keep isl_dim *dim,
 134         enum isl_dim_type type, unsigned pos, const char *name)
 135 {
 136         enum isl_dim_type t;
 137         unsigned p, s;
 138         int count = 0;
 139
 140         for (t = isl_dim_param; t <= type && t <= isl_dim_out; ++t) {
 141                 s = t == type ? pos : isl_dim_size(dim, t);
 142                 for (p = 0; p < s; ++p) {
 143                         const char *n = isl_dim_get_name(dim, t, p);
 144                         if (n && !strcmp(n, name))
 145                                 count++;
 146                 }
 147         }
 148         return count;
 149 }
 150
 151 static __isl_give isl_printer *print_name(__isl_keep isl_dim *dim,
 152         __isl_take isl_printer *p, enum isl_dim_type type, unsigned pos,
 153         int set, int latex)
 154 {
 155         const char *name;
 156         char buffer[20];
 157         int primes;
 158
 159         name = type == isl_dim_div ? NULL : isl_dim_get_name(dim, type, pos);
 160
 161         if (!name) {
 162                 const char *prefix;
 163                 if (type == isl_dim_param)
 164                         prefix = s_param_prefix[latex];
 165                 else if (type == isl_dim_div)
 166                         prefix = s_div_prefix[latex];
 167                 else if (set || type == isl_dim_in)
 168                         prefix = s_input_prefix[latex];
 169                 else
 170                         prefix = s_output_prefix[latex];
 171                 snprintf(buffer, sizeof(buffer), "%s%d", prefix, pos);
 172                 name = buffer;
 173         }
 174         primes = count_same_name(dim, name == buffer ? isl_dim_div : type,
 175                                  pos, name);
 176         p = isl_printer_print_str(p, name);
 177         while (primes-- > 0)
 178                 p = isl_printer_print_str(p, "'");
 179         return p;
 180 }
 181
 182 static enum isl_dim_type pos2type(__isl_keep isl_dim *dim, unsigned *pos)
 183 {
 184         enum isl_dim_type type;
 185         unsigned n_in = isl_dim_size(dim, isl_dim_in);
 186         unsigned n_out = isl_dim_size(dim, isl_dim_out);
 187         unsigned nparam = isl_dim_size(dim, isl_dim_param);
 188
 189         if (*pos < 1 + nparam) {
 190                 type = isl_dim_param;
 191                 *pos -= 1;
 192         } else if (*pos < 1 + nparam + n_in) {
 193                 type = isl_dim_in;
 194                 *pos -= 1 + nparam;
 195         } else if (*pos < 1 + nparam + n_in + n_out) {
 196                 type = isl_dim_out;
 197                 *pos -= 1 + nparam + n_in;
 198         } else {
 199                 type = isl_dim_div;
 200                 *pos -= 1 + nparam + n_in + n_out;
 201         }
 202
 203         return type;
 204 }
 205
 206 static __isl_give isl_printer *print_term(__isl_keep isl_dim *dim,
 207         isl_int c, unsigned pos, __isl_take isl_printer *p, int set, int latex)
 208 {
 209         enum isl_dim_type type;
 210
 211         if (pos == 0)
 212                 return isl_printer_print_isl_int(p, c);
 213
 214         if (isl_int_is_one(c))
 215                 ;
 216         else if (isl_int_is_negone(c))
 217                 p = isl_printer_print_str(p, "-");
 218         else
 219                 p = isl_printer_print_isl_int(p, c);
 220         type = pos2type(dim, &pos);
 221         p = print_name(dim, p, type, pos, set, latex);
 222         return p;
 223 }
 224
 225 static __isl_give isl_printer *print_affine_of_len(__isl_keep isl_dim *dim,
 226         __isl_take isl_printer *p, isl_int *c, int len, int set)
 227 {
 228         int i;
 229         int first;
 230
 231         for (i = 0, first = 1; i < len; ++i) {
 232                 int flip = 0;
 233                 if (isl_int_is_zero(c[i]))
 234                         continue;
 235                 if (!first) {
 236                         if (isl_int_is_neg(c[i])) {
 237                                 flip = 1;
 238                                 isl_int_neg(c[i], c[i]);
 239                                 p = isl_printer_print_str(p, " - ");
 240                         } else
 241                                 p = isl_printer_print_str(p, " + ");
 242                 }
 243                 first = 0;
 244                 p = print_term(dim, c[i], i, p, set, 0);
 245                 if (flip)
 246                         isl_int_neg(c[i], c[i]);
 247         }
 248         if (first)
 249                 p = isl_printer_print_str(p, "0");
 250         return p;
 251 }
 252
 253 static __isl_give isl_printer *print_affine(__isl_keep isl_basic_map *bmap,
 254         __isl_keep isl_dim *dim, __isl_take isl_printer *p, isl_int *c, int set)
 255 {
 256         unsigned len = 1 + isl_basic_map_total_dim(bmap);
 257         return print_affine_of_len(dim, p, c, len, set);
 258 }
 259
 260 static int defining_equality(__isl_keep isl_basic_map *eq,
 261         enum isl_dim_type type, int pos)
 262 {
 263         int i;
 264         unsigned total;
 265
 266         if (!eq)
 267                 return -1;
 268
 269         pos += isl_dim_offset(eq->dim, type);
 270         total = isl_basic_map_total_dim(eq);
 271
 272         for (i = 0; i < eq->n_eq; ++i) {
 273                 if (isl_seq_last_non_zero(eq->eq[i] + 1, total) != pos)
 274                         continue;
 275                 if (isl_int_is_one(eq->eq[i][1 + pos]))
 276                         isl_seq_neg(eq->eq[i], eq->eq[i], 1 + total);
 277                 return i;
 278         }
 279
 280         return -1;
 281 }
 282
 283 static __isl_give isl_printer *print_var_list(__isl_keep isl_dim *dim,
 284         __isl_take isl_printer *p, enum isl_dim_type type, int set, int latex,
 285         __isl_keep isl_basic_map *eq)
 286 {
 287         int i, j;
 288
 289         for (i = 0; i < isl_dim_size(dim, type); ++i) {
 290                 if (i)
 291                         p = isl_printer_print_str(p, ", ");
 292                 j = defining_equality(eq, type, i);
 293                 if (j >= 0) {
 294                         int pos = 1 + isl_dim_offset(dim, type) + i;
 295                         p = print_affine_of_len(dim, p, eq->eq[j], pos, set);
 296                 } else
 297                         p = print_name(dim, p, type, i, set, latex);
 298         }
 299         return p;
 300 }
 301
 302 static __isl_give isl_printer *print_tuple(__isl_keep isl_dim *dim,
 303         __isl_take isl_printer *p, enum isl_dim_type type, int set, int latex,
 304         __isl_keep isl_basic_map *eq)
 305 {
 306         unsigned n = isl_dim_size(dim, type);
 307         if (!latex || n != 1)
 308                 p = isl_printer_print_str(p, s_open_list[latex]);
 309         p = print_var_list(dim, p, type, set, latex, eq);
 310         if (!latex || n != 1)
 311                 p = isl_printer_print_str(p, s_close_list[latex]);
 312         return p;
 313 }
 314
 315 static __isl_give isl_printer *print_omega_parameters(__isl_keep isl_dim *dim,
 316         __isl_take isl_printer *p)
 317 {
 318         if (isl_dim_size(dim, isl_dim_param) == 0)
 319                 return p;
 320
 321         p = isl_printer_start_line(p);
 322         p = isl_printer_print_str(p, "symbolic ");
 323         p = print_var_list(dim, p, isl_dim_param, 0, 0, NULL);
 324         p = isl_printer_print_str(p, ";");
 325         p = isl_printer_end_line(p);
 326         return p;
 327 }
 328
 329 static __isl_give isl_printer *print_constraint(struct isl_basic_map *bmap,
 330         __isl_keep isl_dim *dim, __isl_take isl_printer *p,
 331         isl_int *c, int last, const char *op, int first_constraint, int set,
 332         int latex)
 333 {
 334         if (!first_constraint)
 335                 p = isl_printer_print_str(p, s_and[latex]);
 336
 337         isl_int_abs(c[last], c[last]);
 338
 339         p = print_term(dim, c[last], last, p, set, latex);
 340
 341         p = isl_printer_print_str(p, " ");
 342         p = isl_printer_print_str(p, op);
 343         p = isl_printer_print_str(p, " ");
 344
 345         isl_int_set_si(c[last], 0);
 346         p = print_affine(bmap, dim, p, c, set);
 347
 348         return p;
 349 }
 350
 351 static __isl_give isl_printer *print_constraints(__isl_keep isl_basic_map *bmap,
 352         __isl_keep isl_dim *dim, __isl_take isl_printer *p, int set, int latex)
 353 {
 354         int i;
 355         struct isl_vec *c;
 356         unsigned total = isl_basic_map_total_dim(bmap);
 357
 358         c = isl_vec_alloc(bmap->ctx, 1 + total);
 359         if (!c)
 360                 goto error;
 361
 362         for (i = bmap->n_eq - 1; i >= 0; --i) {
 363                 int l = isl_seq_last_non_zero(bmap->eq[i], 1 + total);
 364                 isl_assert(bmap->ctx, l >= 0, goto error);
 365                 if (isl_int_is_neg(bmap->eq[i][l]))
 366                         isl_seq_cpy(c->el, bmap->eq[i], 1 + total);
 367                 else
 368                         isl_seq_neg(c->el, bmap->eq[i], 1 + total);
 369                 p = print_constraint(bmap, dim, p, c->el, l,
 370                                     "=", i == bmap->n_eq - 1, set, latex);
 371         }
 372         for (i = 0; i < bmap->n_ineq; ++i) {
 373                 int l = isl_seq_last_non_zero(bmap->ineq[i], 1 + total);
 374                 int s;
 375                 const char *op;
 376                 if (l < 0)
 377                         continue;
 378                 s = isl_int_sgn(bmap->ineq[i][l]);
 379                 if (s < 0)
 380                         isl_seq_cpy(c->el, bmap->ineq[i], 1 + total);
 381                 else
 382                         isl_seq_neg(c->el, bmap->ineq[i], 1 + total);
 383                 op = s < 0 ? s_le[latex] : s_ge[latex];
 384                 p = print_constraint(bmap, dim, p, c->el, l,
 385                                         op, !bmap->n_eq && !i, set, latex);
 386         }
 387
 388         isl_vec_free(c);
 389
 390         return p;
 391 error:
 392         isl_printer_free(p);
 393         return NULL;
 394 }
 395
 396 static __isl_give isl_printer *print_omega_constraints(
 397         __isl_keep isl_basic_map *bmap, __isl_take isl_printer *p, int set)
 398 {
 399         if (bmap->n_eq + bmap->n_ineq == 0)
 400                 return p;
 401
 402         p = isl_printer_print_str(p, ": ");
 403         if (bmap->n_div > 0) {
 404                 int i;
 405                 p = isl_printer_print_str(p, "exists (");
 406                 for (i = 0; i < bmap->n_div; ++i) {
 407                         if (i)
 408                                 p = isl_printer_print_str(p, ", ");
 409                         p = print_name(bmap->dim, p, isl_dim_div, i, 0, 0);
 410                 }
 411                 p = isl_printer_print_str(p, ": ");
 412         }
 413         p = print_constraints(bmap, bmap->dim, p, set, 0);
 414         if (bmap->n_div > 0)
 415                 p = isl_printer_print_str(p, ")");
 416         return p;
 417 }
 418
 419 static __isl_give isl_printer *basic_map_print_omega(
 420         __isl_keep isl_basic_map *bmap, __isl_take isl_printer *p)
 421 {
 422         p = isl_printer_print_str(p, "{ [");
 423         p = print_var_list(bmap->dim, p, isl_dim_in, 0, 0, NULL);
 424         p = isl_printer_print_str(p, "] -> [");
 425         p = print_var_list(bmap->dim, p, isl_dim_out, 0, 0, NULL);
 426         p = isl_printer_print_str(p, "] ");
 427         p = print_omega_constraints(bmap, p, 0);
 428         p = isl_printer_print_str(p, " }");
 429         return p;
 430 }
 431
 432 static __isl_give isl_printer *isl_basic_map_print_omega(
 433         __isl_keep isl_basic_map *bmap, __isl_take isl_printer *p)
 434 {
 435         p = print_omega_parameters(bmap->dim, p);
 436
 437         p = isl_printer_start_line(p);
 438         p = basic_map_print_omega(bmap, p);
 439         p = isl_printer_end_line(p);
 440         return p;
 441 }
 442
 443 static __isl_give isl_printer *basic_set_print_omega(
 444         __isl_keep isl_basic_set *bset, __isl_take isl_printer *p)
 445 {
 446         p = isl_printer_print_str(p, "{ [");
 447         p = print_var_list(bset->dim, p, isl_dim_set, 1, 0, NULL);
 448         p = isl_printer_print_str(p, "] ");
 449         p = print_omega_constraints((isl_basic_map *)bset, p, 1);
 450         p = isl_printer_print_str(p, " }");
 451         return p;
 452 }
 453
 454 static __isl_give isl_printer *isl_basic_set_print_omega(
 455         __isl_keep isl_basic_set *bset, __isl_take isl_printer *p)
 456 {
 457         p = print_omega_parameters(bset->dim, p);
 458
 459         p = isl_printer_start_line(p);
 460         p = basic_set_print_omega(bset, p);
 461         p = isl_printer_end_line(p);
 462         return p;
 463 }
 464
 465 static __isl_give isl_printer *isl_map_print_omega(__isl_keep isl_map *map,
 466         __isl_take isl_printer *p)
 467 {
 468         int i;
 469
 470         p = print_omega_parameters(map->dim, p);
 471
 472         p = isl_printer_start_line(p);
 473         for (i = 0; i < map->n; ++i) {
 474                 if (i)
 475                         p = isl_printer_print_str(p, " union ");
 476                 p = basic_map_print_omega(map->p[i], p);
 477         }
 478         p = isl_printer_end_line(p);
 479         return p;
 480 }
 481
 482 static __isl_give isl_printer *isl_set_print_omega(__isl_keep isl_set *set,
 483         __isl_take isl_printer *p)
 484 {
 485         int i;
 486
 487         p = print_omega_parameters(set->dim, p);
 488
 489         p = isl_printer_start_line(p);
 490         for (i = 0; i < set->n; ++i) {
 491                 if (i)
 492                         p = isl_printer_print_str(p, " union ");
 493                 p = basic_set_print_omega(set->p[i], p);
 494         }
 495         p = isl_printer_end_line(p);
 496         return p;
 497 }
 498
 499 static __isl_give isl_printer *print_disjunct(__isl_keep isl_basic_map *bmap,
 500         __isl_keep isl_dim *dim, __isl_take isl_printer *p, int set, int latex)
 501 {
 502         if (bmap->n_div > 0) {
 503                 int i;
 504                 p = isl_printer_print_str(p, s_open_exists[latex]);
 505                 for (i = 0; i < bmap->n_div; ++i) {
 506                         if (i)
 507                                 p = isl_printer_print_str(p, ", ");
 508                         p = print_name(dim, p, isl_dim_div, i, 0, latex);
 509                         if (latex || isl_int_is_zero(bmap->div[i][0]))
 510                                 continue;
 511                         p = isl_printer_print_str(p, " = [(");
 512                         p = print_affine(bmap, dim, p, bmap->div[i] + 1, set);
 513                         p = isl_printer_print_str(p, ")/");
 514                         p = isl_printer_print_isl_int(p, bmap->div[i][0]);
 515                         p = isl_printer_print_str(p, "]");
 516                 }
 517                 p = isl_printer_print_str(p, ": ");
 518         }
 519
 520         p = print_constraints(bmap, dim, p, set, latex);
 521
 522         if (bmap->n_div > 0)
 523                 p = isl_printer_print_str(p, s_close_exists[latex]);
 524         return p;
 525 }
 526
 527 static __isl_give isl_printer *isl_basic_map_print_isl(
 528         __isl_keep isl_basic_map *bmap, __isl_take isl_printer *p, int latex)
 529 {
 530         int i;
 531
 532         p = isl_printer_start_line(p);
 533         if (isl_basic_map_dim(bmap, isl_dim_param) > 0) {
 534                 p = print_tuple(bmap->dim, p, isl_dim_param, 0, latex, NULL);
 535                 p = isl_printer_print_str(p, " -> ");
 536         }
 537         p = isl_printer_print_str(p, "{ ");
 538         p = print_tuple(bmap->dim, p, isl_dim_in, 0, latex, NULL);
 539         p = isl_printer_print_str(p, " -> ");
 540         p = print_tuple(bmap->dim, p, isl_dim_out, 0, latex, NULL);
 541         p = isl_printer_print_str(p, " : ");
 542         p = print_disjunct(bmap, bmap->dim, p, 0, latex);
 543         p = isl_printer_print_str(p, " }");
 544         p = isl_printer_end_line(p);
 545         return p;
 546 }
 547
 548 static __isl_give isl_printer *isl_basic_set_print_isl(
 549         __isl_keep isl_basic_set *bset, __isl_take isl_printer *p, int latex)
 550 {
 551         int i;
 552
 553         p = isl_printer_start_line(p);
 554         if (isl_basic_set_dim(bset, isl_dim_param) > 0) {
 555                 p = print_tuple(bset->dim, p, isl_dim_param, 0, latex, NULL);
 556                 p = isl_printer_print_str(p, " -> ");
 557         }
 558         p = isl_printer_print_str(p, "{ ");
 559         p = print_tuple(bset->dim, p, isl_dim_set, 1, latex, NULL);
 560         p = isl_printer_print_str(p, " : ");
 561         p = print_disjunct((isl_basic_map *)bset, bset->dim, p, 1, latex);
 562         p = isl_printer_print_str(p, " }");
 563         p = isl_printer_end_line(p);
 564         return p;
 565 }
 566
 567 static __isl_give isl_printer *print_disjuncts(__isl_keep isl_map *map,
 568         __isl_take isl_printer *p, int set, int latex)
 569 {
 570         int i;
 571
 572         if (isl_map_fast_is_universe(map))
 573                 return p;
 574
 575         p = isl_printer_print_str(p, s_such_that[latex]);
 576         if (map->n == 0)
 577                 p = isl_printer_print_str(p, "1 = 0");
 578         for (i = 0; i < map->n; ++i) {
 579                 if (i)
 580                         p = isl_printer_print_str(p, s_or[latex]);
 581                 if (map->n > 1 && map->p[i]->n_eq + map->p[i]->n_ineq > 1)
 582                         p = isl_printer_print_str(p, "(");
 583                 p = print_disjunct(map->p[i], map->dim, p, set, latex);
 584                 if (map->n > 1 && map->p[i]->n_eq + map->p[i]->n_ineq > 1)
 585                         p = isl_printer_print_str(p, ")");
 586         }
 587         return p;
 588 }
 589
 590 struct isl_aff_split {
 591         isl_basic_map *aff;
 592         isl_map *map;
 593 };
 594
 595 static void free_split(__isl_take struct isl_aff_split *split, int n)
 596 {
 597         int i;
 598
 599         if (!split)
 600                 return;
 601
 602         for (i = 0; i < n; ++i) {
 603                 isl_basic_map_free(split[i].aff);
 604                 isl_map_free(split[i].map);
 605         }
 606
 607         free(split);
 608 }
 609
 610 static __isl_give isl_basic_map *get_aff(__isl_take isl_basic_map *bmap)
 611 {
 612         int i, j;
 613         unsigned nparam, n_in, n_out, total;
 614
 615         bmap = isl_basic_map_cow(bmap);
 616         if (!bmap)
 617                 return NULL;
 618         if (isl_basic_map_free_inequality(bmap, bmap->n_ineq) < 0)
 619                 goto error;
 620
 621         nparam = isl_basic_map_dim(bmap, isl_dim_param);
 622         n_in = isl_basic_map_dim(bmap, isl_dim_in);
 623         n_out = isl_basic_map_dim(bmap, isl_dim_out);
 624         total = isl_basic_map_dim(bmap, isl_dim_all);
 625         for (i = bmap->n_eq - 1; i >= 0; --i) {
 626                 j = isl_seq_last_non_zero(bmap->eq[i] + 1, total);
 627                 if (j >= nparam && j < nparam + n_in + n_out &&
 628                     (isl_int_is_one(bmap->eq[i][1 + j]) ||
 629                      isl_int_is_negone(bmap->eq[i][1 + j])))
 630                         continue;
 631                 if (isl_basic_map_drop_equality(bmap, i) < 0)
 632                         goto error;
 633         }
 634
 635         bmap = isl_basic_map_finalize(bmap);
 636
 637         return bmap;
 638 error:
 639         isl_basic_map_free(bmap);
 640         return NULL;
 641 }
 642
 643 static int aff_split_cmp(const void *p1, const void *p2)
 644 {
 645         const struct isl_aff_split *s1, *s2;
 646         s1 = (const struct isl_aff_split *) p1;
 647         s2 = (const struct isl_aff_split *) p2;
 648
 649         return isl_basic_map_fast_cmp(s1->aff, s2->aff);
 650 }
 651
 652 static __isl_give isl_basic_map *drop_aff(__isl_take isl_basic_map *bmap,
 653         __isl_keep isl_basic_map *aff)
 654 {
 655         int i, j;
 656         unsigned total;
 657
 658         if (!bmap || !aff)
 659                 goto error;
 660
 661         total = isl_dim_total(bmap->dim);
 662
 663         for (i = bmap->n_eq - 1; i >= 0; --i) {
 664                 if (isl_seq_first_non_zero(bmap->eq[i] + 1 + total,
 665                                             bmap->n_div) != -1)
 666                         continue;
 667                 for (j = 0; j < aff->n_eq; ++j) {
 668                         if (!isl_seq_eq(bmap->eq[i], aff->eq[j], 1 + total) &&
 669                             !isl_seq_is_neg(bmap->eq[i], aff->eq[j], 1 + total))
 670                                 continue;
 671                         if (isl_basic_map_drop_equality(bmap, i) < 0)
 672                                 goto error;
 673                         break;
 674                 }
 675         }
 676
 677         return bmap;
 678 error:
 679         isl_basic_map_free(bmap);
 680         return NULL;
 681 }
 682
 683 static __isl_give struct isl_aff_split *split_aff(__isl_keep isl_map *map)
 684 {
 685         int i, n;
 686         struct isl_aff_split *split;
 687
 688         split = isl_calloc_array(map->isl, struct isl_aff_split, map->n);
 689         if (!split)
 690                 return NULL;
 691
 692         for (i = 0; i < map->n; ++i) {
 693                 isl_basic_map *bmap;
 694                 split[i].aff = get_aff(isl_basic_map_copy(map->p[i]));
 695                 bmap = isl_basic_map_copy(map->p[i]);
 696                 bmap = isl_basic_map_cow(bmap);
 697                 bmap = drop_aff(bmap, split[i].aff);
 698                 split[i].map = isl_map_from_basic_map(bmap);
 699                 if (!split[i].aff || !split[i].map)
 700                         goto error;
 701         }
 702
 703         qsort(split, map->n, sizeof(struct isl_aff_split), &aff_split_cmp);
 704
 705         n = map->n;
 706         for (i = n - 1; i >= 1; --i) {
 707                 if (!isl_basic_map_fast_is_equal(split[i - 1].aff,
 708                                                  split[i].aff))
 709                         continue;
 710                 isl_basic_map_free(split[i].aff);
 711                 split[i - 1].map = isl_map_union(split[i - 1].map,
 712                                                  split[i].map);
 713                 if (i != n - 1)
 714                         split[i] = split[n - 1];
 715                 split[n - 1].aff = NULL;
 716                 split[n - 1].map = NULL;
 717                 --n;
 718         }
 719
 720         return split;
 721 error:
 722         free_split(split, map->n);
 723         return NULL;
 724 }
 725
 726 static __isl_give isl_printer *print_split_map(__isl_take isl_printer *p,
 727         struct isl_aff_split *split, int n, int set)
 728 {
 729         int i;
 730
 731         for (i = 0; i < n; ++i) {
 732                 isl_dim *dim;
 733
 734                 if (!split[i].map)
 735                         break;
 736                 dim = split[i].map->dim;
 737                 if (i)
 738                         p = isl_printer_print_str(p, "; ");
 739                 if (set)
 740                         p = print_tuple(dim, p, isl_dim_set, 1, 0, split[i].aff);
 741                 else {
 742                         p = print_tuple(dim, p, isl_dim_in, 0, 0, split[i].aff);
 743                         p = isl_printer_print_str(p, s_to[0]);
 744                         p = print_tuple(dim, p, isl_dim_out, 0, 0, split[i].aff);
 745                 }
 746                 p = print_disjuncts(split[i].map, p, set, 0);
 747         }
 748
 749         return p;
 750 }
 751
 752 static __isl_give isl_printer *isl_map_print_isl(__isl_keep isl_map *map,
 753         __isl_take isl_printer *p, int set)
 754 {
 755         struct isl_aff_split *split = NULL;
 756
 757         if (map->n > 0)
 758                 split = split_aff(map);
 759         if (isl_map_dim(map, isl_dim_param) > 0) {
 760                 p = print_tuple(map->dim, p, isl_dim_param, set, 0, NULL);
 761                 p = isl_printer_print_str(p, s_to[0]);
 762         }
 763         p = isl_printer_print_str(p, s_open_set[0]);
 764         if (split) {
 765                 p = print_split_map(p, split, map->n, set);
 766         } else {
 767                 if (set)
 768                         p = print_tuple(map->dim, p, isl_dim_set, 1, 0, NULL);
 769                 else {
 770                         p = print_tuple(map->dim, p, isl_dim_in, 0, 0, NULL);
 771                         p = isl_printer_print_str(p, s_to[0]);
 772                         p = print_tuple(map->dim, p, isl_dim_out, 0, 0, NULL);
 773                 }
 774                 p = print_disjuncts(map, p, set, 0);
 775         }
 776         p = isl_printer_print_str(p, s_close_set[0]);
 777         free_split(split, map->n);
 778         return p;
 779 }
 780
 781 static __isl_give isl_printer *print_latex_map(__isl_keep isl_map *map,
 782         __isl_take isl_printer *p, __isl_keep isl_basic_map *aff, int set)
 783 {
 784         if (isl_map_dim(map, isl_dim_param) > 0) {
 785                 p = print_tuple(map->dim, p, isl_dim_param, set, 1, NULL);
 786                 p = isl_printer_print_str(p, s_to[1]);
 787         }
 788         p = isl_printer_print_str(p, s_open_set[1]);
 789         if (set)
 790                 p = print_tuple(map->dim, p, isl_dim_set, 1, 1, aff);
 791         else {
 792                 p = print_tuple(map->dim, p, isl_dim_in, 0, 1, aff);
 793                 p = isl_printer_print_str(p, s_to[1]);
 794                 p = print_tuple(map->dim, p, isl_dim_out, 0, 1, aff);
 795         }
 796         p = print_disjuncts(map, p, set, 1);
 797         p = isl_printer_print_str(p, s_close_set[1]);
 798
 799         return p;
 800 }
 801
 802 static __isl_give isl_printer *isl_map_print_latex(__isl_keep isl_map *map,
 803         __isl_take isl_printer *p, int set)
 804 {
 805         int i;
 806         struct isl_aff_split *split = NULL;
 807
 808         if (map->n > 0)
 809                 split = split_aff(map);
 810
 811         if (!split)
 812                 return print_latex_map(map, p, NULL, set);
 813
 814         for (i = 0; i < map->n; ++i) {
 815                 if (!split[i].map)
 816                         break;
 817                 if (i)
 818                         p = isl_printer_print_str(p, " \\cup ");
 819                 p = print_latex_map(split[i].map, p, split[i].aff, set);
 820         }
 821
 822         free_split(split, map->n);
 823         return p;
 824 }
 825
 826 __isl_give isl_printer *isl_printer_print_basic_map(__isl_take isl_printer *p,
 827         __isl_keep isl_basic_map *bmap)
 828 {
 829         if (!p || !bmap)
 830                 goto error;
 831         if (p->output_format == ISL_FORMAT_ISL)
 832                 return isl_basic_map_print_isl(bmap, p, 0);
 833         else if (p->output_format == ISL_FORMAT_OMEGA)
 834                 return isl_basic_map_print_omega(bmap, p);
 835         isl_assert(bmap->ctx, 0, goto error);
 836 error:
 837         isl_printer_free(p);
 838         return NULL;
 839 }
 840
 841 void isl_basic_map_print(__isl_keep isl_basic_map *bmap, FILE *out, int indent,
 842         const char *prefix, const char *suffix, unsigned output_format)
 843 {
 844         isl_printer *printer;
 845
 846         if (!bmap)
 847                 return;
 848
 849         printer = isl_printer_to_file(bmap->ctx, out);
 850         printer = isl_printer_set_indent(printer, indent);
 851         printer = isl_printer_set_prefix(printer, prefix);
 852         printer = isl_printer_set_suffix(printer, suffix);
 853         printer = isl_printer_set_output_format(printer, output_format);
 854         isl_printer_print_basic_map(printer, bmap);
 855
 856         isl_printer_free(printer);
 857 }
 858
 859 __isl_give isl_printer *isl_printer_print_basic_set(__isl_take isl_printer *p,
 860         __isl_keep isl_basic_set *bset)
 861 {
 862         if (!p || !bset)
 863                 goto error;
 864
 865         if (p->output_format == ISL_FORMAT_ISL)
 866                 return isl_basic_set_print_isl(bset, p, 0);
 867         else if (p->output_format == ISL_FORMAT_POLYLIB)
 868                 return isl_basic_set_print_polylib(bset, p);
 869         else if (p->output_format == ISL_FORMAT_POLYLIB_CONSTRAINTS)
 870                 return bset_print_constraints_polylib(bset, p);
 871         else if (p->output_format == ISL_FORMAT_OMEGA)
 872                 return isl_basic_set_print_omega(bset, p);
 873         isl_assert(p->ctx, 0, goto error);
 874 error:
 875         isl_printer_free(p);
 876         return NULL;
 877 }
 878
 879 void isl_basic_set_print(struct isl_basic_set *bset, FILE *out, int indent,
 880         const char *prefix, const char *suffix, unsigned output_format)
 881 {
 882         isl_printer *printer;
 883
 884         if (!bset)
 885                 return;
 886
 887         printer = isl_printer_to_file(bset->ctx, out);
 888         printer = isl_printer_set_indent(printer, indent);
 889         printer = isl_printer_set_prefix(printer, prefix);
 890         printer = isl_printer_set_suffix(printer, suffix);
 891         printer = isl_printer_set_output_format(printer, output_format);
 892         isl_printer_print_basic_set(printer, bset);
 893
 894         isl_printer_free(printer);
 895 }
 896
 897 __isl_give isl_printer *isl_printer_print_set(__isl_take isl_printer *p,
 898         __isl_keep isl_set *set)
 899 {
 900         if (!p || !set)
 901                 goto error;
 902         if (p->output_format == ISL_FORMAT_ISL)
 903                 return isl_map_print_isl((isl_map *)set, p, 1);
 904         else if (p->output_format == ISL_FORMAT_POLYLIB)
 905                 return isl_set_print_polylib(set, p);
 906         else if (p->output_format == ISL_FORMAT_OMEGA)
 907                 return isl_set_print_omega(set, p);
 908         else if (p->output_format == ISL_FORMAT_LATEX)
 909                 return isl_map_print_latex((isl_map *)set, p, 1);
 910         isl_assert(set->ctx, 0, goto error);
 911 error:
 912         isl_printer_free(p);
 913         return NULL;
 914 }
 915
 916 void isl_set_print(struct isl_set *set, FILE *out, int indent,
 917         unsigned output_format)
 918 {
 919         isl_printer *printer;
 920
 921         if (!set)
 922                 return;
 923
 924         printer = isl_printer_to_file(set->ctx, out);
 925         printer = isl_printer_set_indent(printer, indent);
 926         printer = isl_printer_set_output_format(printer, output_format);
 927         printer = isl_printer_print_set(printer, set);
 928
 929         isl_printer_free(printer);
 930 }
 931
 932 __isl_give isl_printer *isl_printer_print_map(__isl_take isl_printer *p,
 933         __isl_keep isl_map *map)
 934 {
 935         if (!p || !map)
 936                 goto error;
 937
 938         if (p->output_format == ISL_FORMAT_ISL)
 939                 return isl_map_print_isl(map, p, 0);
 940         else if (p->output_format == ISL_FORMAT_POLYLIB)
 941                 return isl_map_print_polylib(map, p);
 942         else if (p->output_format == ISL_FORMAT_OMEGA)
 943                 return isl_map_print_omega(map, p);
 944         else if (p->output_format == ISL_FORMAT_LATEX)
 945                 return isl_map_print_latex(map, p, 0);
 946         isl_assert(map->ctx, 0, goto error);
 947 error:
 948         isl_printer_free(p);
 949         return NULL;
 950 }
 951
 952 void isl_map_print(__isl_keep isl_map *map, FILE *out, int indent,
 953         unsigned output_format)
 954 {
 955         isl_printer *printer;
 956
 957         if (!map)
 958                 return;
 959
 960         printer = isl_printer_to_file(map->ctx, out);
 961         printer = isl_printer_set_indent(printer, indent);
 962         printer = isl_printer_set_output_format(printer, output_format);
 963         printer = isl_printer_print_map(printer, map);
 964
 965         isl_printer_free(printer);
 966 }
 967
 968 static int upoly_rec_n_non_zero(__isl_keep struct isl_upoly_rec *rec)
 969 {
 970         int i;
 971         int n;
 972
 973         for (i = 0, n = 0; i < rec->n; ++i)
 974                 if (!isl_upoly_is_zero(rec->p[i]))
 975                         ++n;
 976
 977         return n;
 978 }
 979
 980 static __isl_give isl_printer *print_div(__isl_keep isl_dim *dim,
 981         __isl_keep isl_mat *div, int pos, __isl_take isl_printer *p)
 982 {
 983         int c = p->output_format == ISL_FORMAT_C;
 984         p = isl_printer_print_str(p, c ? "floord(" : "[(");
 985         p = print_affine_of_len(dim, p, div->row[pos] + 1, div->n_col - 1, 1);
 986         p = isl_printer_print_str(p, c ? ", " : ")/");
 987         p = isl_printer_print_isl_int(p, div->row[pos][0]);
 988         p = isl_printer_print_str(p, c ? ")" : "]");
 989         return p;
 990 }
 991
 992 static __isl_give isl_printer *upoly_print_cst(__isl_keep struct isl_upoly *up,
 993         __isl_take isl_printer *p, int first)
 994 {
 995         struct isl_upoly_cst *cst;
 996         int neg;
 997
 998         cst = isl_upoly_as_cst(up);
 999         if (!cst)
1000                 goto error;
1001         neg = !first && isl_int_is_neg(cst->n);
1002         if (!first)
1003                 p = isl_printer_print_str(p, neg ? " - " :  " + ");
1004         if (neg)
1005                 isl_int_neg(cst->n, cst->n);
1006         if (isl_int_is_zero(cst->d)) {
1007                 int sgn = isl_int_sgn(cst->n);
1008                 p = isl_printer_print_str(p, sgn < 0 ? "-infty" :
1009                                             sgn == 0 ? "NaN" : "infty");
1010         } else
1011                 p = isl_printer_print_isl_int(p, cst->n);
1012         if (neg)
1013                 isl_int_neg(cst->n, cst->n);
1014         if (!isl_int_is_zero(cst->d) && !isl_int_is_one(cst->d)) {
1015                 p = isl_printer_print_str(p, "/");
1016                 p = isl_printer_print_isl_int(p, cst->d);
1017         }
1018         return p;
1019 error:
1020         isl_printer_free(p);
1021         return NULL;
1022 }
1023
1024 static __isl_give isl_printer *print_base(__isl_take isl_printer *p,
1025         __isl_keep isl_dim *dim, __isl_keep isl_mat *div, int var)
1026 {
1027         unsigned total;
1028
1029         total = isl_dim_total(dim);
1030         if (var < total)
1031                 p = print_term(dim, dim->ctx->one, 1 + var, p, 1, 0);
1032         else
1033                 p = print_div(dim, div, var - total, p);
1034         return p;
1035 }
1036
1037 static __isl_give isl_printer *print_pow(__isl_take isl_printer *p,
1038         __isl_keep isl_dim *dim, __isl_keep isl_mat *div, int var, int exp)
1039 {
1040         p = print_base(p, dim, div, var);
1041         if (exp == 1)
1042                 return p;
1043         if (p->output_format == ISL_FORMAT_C) {
1044                 int i;
1045                 for (i = 1; i < exp; ++i) {
1046                         p = isl_printer_print_str(p, "*");
1047                         p = print_base(p, dim, div, var);
1048                 }
1049         } else {
1050                 p = isl_printer_print_str(p, "^");
1051                 p = isl_printer_print_int(p, exp);
1052         }
1053         return p;
1054 }
1055
1056 static __isl_give isl_printer *upoly_print(__isl_keep struct isl_upoly *up,
1057         __isl_keep isl_dim *dim, __isl_keep isl_mat *div,
1058         __isl_take isl_printer *p)
1059 {
1060         int i, n, first;
1061         struct isl_upoly_rec *rec;
1062
1063         if (!p || !up || !dim || !div)
1064                 goto error;
1065
1066         if (isl_upoly_is_cst(up))
1067                 return upoly_print_cst(up, p, 1);
1068
1069         rec = isl_upoly_as_rec(up);
1070         if (!rec)
1071                 goto error;
1072         n = upoly_rec_n_non_zero(rec);
1073         if (n > 1)
1074                 p = isl_printer_print_str(p, "(");
1075         for (i = 0, first = 1; i < rec->n; ++i) {
1076                 if (isl_upoly_is_zero(rec->p[i]))
1077                         continue;
1078                 if (isl_upoly_is_negone(rec->p[i])) {
1079                         if (!i)
1080                                 p = isl_printer_print_str(p, "-1");
1081                         else if (first)
1082                                 p = isl_printer_print_str(p, "-");
1083                         else
1084                                 p = isl_printer_print_str(p, " - ");
1085                 } else if (isl_upoly_is_cst(rec->p[i]) &&
1086                                 !isl_upoly_is_one(rec->p[i]))
1087                         p = upoly_print_cst(rec->p[i], p, first);
1088                 else {
1089                         if (!first)
1090                                 p = isl_printer_print_str(p, " + ");
1091                         if (i == 0 || !isl_upoly_is_one(rec->p[i]))
1092                                 p = upoly_print(rec->p[i], dim, div, p);
1093                 }
1094                 first = 0;
1095                 if (i == 0)
1096                         continue;
1097                 if (!isl_upoly_is_one(rec->p[i]) &&
1098                     !isl_upoly_is_negone(rec->p[i]))
1099                         p = isl_printer_print_str(p, " * ");
1100                 p = print_pow(p, dim, div, rec->up.var, i);
1101         }
1102         if (n > 1)
1103                 p = isl_printer_print_str(p, ")");
1104         return p;
1105 error:
1106         isl_printer_free(p);
1107         return NULL;
1108 }
1109
1110 __isl_give isl_printer *isl_printer_print_qpolynomial(__isl_take isl_printer *p,
1111         __isl_keep isl_qpolynomial *qp)
1112 {
1113         if (!p || !qp)
1114                 goto error;
1115         p = upoly_print(qp->upoly, qp->dim, qp->div, p);
1116         return p;
1117 error:
1118         isl_printer_free(p);
1119         return NULL;
1120 }
1121
1122 void isl_qpolynomial_print(__isl_keep isl_qpolynomial *qp, FILE *out,
1123         unsigned output_format)
1124 {
1125         isl_printer *p;
1126
1127         if  (!qp)
1128                 return;
1129
1130         isl_assert(qp->dim->ctx, output_format == ISL_FORMAT_ISL, return);
1131         p = isl_printer_to_file(qp->dim->ctx, out);
1132         p = isl_printer_print_qpolynomial(p, qp);
1133         isl_printer_free(p);
1134 }
1135
1136 static __isl_give isl_printer *qpolynomial_fold_print(
1137         __isl_keep isl_qpolynomial_fold *fold, __isl_take isl_printer *p)
1138 {
1139         int i;
1140
1141         if (fold->type == isl_fold_min)
1142                 p = isl_printer_print_str(p, "min");
1143         else if (fold->type == isl_fold_max)
1144                 p = isl_printer_print_str(p, "max");
1145         p = isl_printer_print_str(p, "(");
1146         for (i = 0; i < fold->n; ++i) {
1147                 if (i)
1148                         p = isl_printer_print_str(p, ", ");
1149                 p = isl_printer_print_qpolynomial(p, fold->qp[i]);
1150         }
1151         p = isl_printer_print_str(p, ")");
1152         return p;
1153 }
1154
1155 __isl_give isl_printer *isl_printer_print_qpolynomial_fold(
1156         __isl_take isl_printer *p, __isl_keep isl_qpolynomial_fold *fold)
1157 {
1158         if  (!p || !fold)
1159                 goto error;
1160         p = qpolynomial_fold_print(fold, p);
1161         return p;
1162 error:
1163         isl_printer_free(p);
1164         return NULL;
1165 }
1166
1167 void isl_qpolynomial_fold_print(__isl_keep isl_qpolynomial_fold *fold,
1168         FILE *out, unsigned output_format)
1169 {
1170         isl_printer *p;
1171
1172         if (!fold)
1173                 return;
1174
1175         isl_assert(fold->dim->ctx, output_format == ISL_FORMAT_ISL, return);
1176
1177         p = isl_printer_to_file(fold->dim->ctx, out);
1178         p = isl_printer_print_qpolynomial_fold(p, fold);
1179
1180         isl_printer_free(p);
1181 }
1182
1183 static __isl_give isl_printer *print_pw_qpolynomial_isl(
1184         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial *pwqp)
1185 {
1186         int i = 0;
1187
1188         if (!p || !pwqp)
1189                 goto error;
1190
1191         if (isl_dim_size(pwqp->dim, isl_dim_param) > 0) {
1192                 p = print_tuple(pwqp->dim, p, isl_dim_param, 0, 0, NULL);
1193                 p = isl_printer_print_str(p, " -> ");
1194         }
1195         p = isl_printer_print_str(p, "{ ");
1196         if (pwqp->n == 0) {
1197                 if (isl_dim_size(pwqp->dim, isl_dim_set) > 0) {
1198                         p = print_tuple(pwqp->dim, p, isl_dim_set, 1, 0, NULL);
1199                         p = isl_printer_print_str(p, " -> ");
1200                 }
1201                 p = isl_printer_print_str(p, "0");
1202         }
1203         for (i = 0; i < pwqp->n; ++i) {
1204                 if (i)
1205                         p = isl_printer_print_str(p, "; ");
1206                 if (isl_dim_size(pwqp->p[i].set->dim, isl_dim_set) > 0) {
1207                         p = print_tuple(pwqp->p[i].set->dim, p, isl_dim_set, 1, 0, NULL);
1208                         p = isl_printer_print_str(p, " -> ");
1209                 }
1210                 p = isl_printer_print_qpolynomial(p, pwqp->p[i].qp);
1211                 p = print_disjuncts((isl_map *)pwqp->p[i].set, p, 1, 0);
1212         }
1213         p = isl_printer_print_str(p, " }");
1214         return p;
1215 error:
1216         isl_printer_free(p);
1217         return NULL;
1218 }
1219
1220 void isl_pw_qpolynomial_print(__isl_keep isl_pw_qpolynomial *pwqp, FILE *out,
1221         unsigned output_format)
1222 {
1223         isl_printer *p;
1224
1225         if (!pwqp)
1226                 return;
1227
1228         p = isl_printer_to_file(pwqp->dim->ctx, out);
1229         p = isl_printer_set_output_format(p, output_format);
1230         p = isl_printer_print_pw_qpolynomial(p, pwqp);
1231
1232         isl_printer_free(p);
1233 }
1234
1235 static __isl_give isl_printer *print_pw_qpolynomial_fold_isl(
1236         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial_fold *pwf)
1237 {
1238         int i = 0;
1239
1240         if (isl_dim_size(pwf->dim, isl_dim_param) > 0) {
1241                 p = print_tuple(pwf->dim, p, isl_dim_param, 0, 0, NULL);
1242                 p = isl_printer_print_str(p, " -> ");
1243         }
1244         p = isl_printer_print_str(p, "{ ");
1245         if (pwf->n == 0) {
1246                 if (isl_dim_size(pwf->dim, isl_dim_set) > 0) {
1247                         p = print_tuple(pwf->dim, p, isl_dim_set, 0, 0, NULL);
1248                         p = isl_printer_print_str(p, " -> ");
1249                 }
1250                 p = isl_printer_print_str(p, "0");
1251         }
1252         for (i = 0; i < pwf->n; ++i) {
1253                 if (i)
1254                         p = isl_printer_print_str(p, "; ");
1255                 if (isl_dim_size(pwf->p[i].set->dim, isl_dim_set) > 0) {
1256                         p = print_tuple(pwf->p[i].set->dim, p, isl_dim_set, 0, 0, NULL);
1257                         p = isl_printer_print_str(p, " -> ");
1258                 }
1259                 p = qpolynomial_fold_print(pwf->p[i].fold, p);
1260                 p = print_disjuncts((isl_map *)pwf->p[i].set, p, 1, 0);
1261         }
1262         p = isl_printer_print_str(p, " }");
1263         return p;
1264 }
1265
1266 static __isl_give isl_printer *print_affine_c(__isl_take isl_printer *p,
1267         __isl_keep isl_basic_set *bset, isl_int *c);
1268
1269 static __isl_give isl_printer *print_name_c(__isl_take isl_printer *p,
1270         __isl_keep isl_basic_set *bset, enum isl_dim_type type, unsigned pos)
1271 {
1272         if (type == isl_dim_div) {
1273                 p = isl_printer_print_str(p, "floord(");
1274                 p = print_affine_c(p, bset, bset->div[pos] + 1);
1275                 p = isl_printer_print_str(p, ", ");
1276                 p = isl_printer_print_isl_int(p, bset->div[pos][0]);
1277                 p = isl_printer_print_str(p, ")");
1278         } else {
1279                 const char *name;
1280
1281                 name = isl_dim_get_name(bset->dim, type, pos);
1282                 if (!name)
1283                         name = "UNNAMED";
1284                 p = isl_printer_print_str(p, name);
1285         }
1286         return p;
1287 }
1288
1289 static __isl_give isl_printer *print_term_c(__isl_take isl_printer *p,
1290         __isl_keep isl_basic_set *bset, isl_int c, unsigned pos)
1291 {
1292         enum isl_dim_type type;
1293         unsigned nparam = isl_basic_set_dim(bset, isl_dim_param);
1294
1295         if (pos == 0)
1296                 return isl_printer_print_isl_int(p, c);
1297
1298         if (isl_int_is_one(c))
1299                 ;
1300         else if (isl_int_is_negone(c))
1301                 p = isl_printer_print_str(p, "-");
1302         else {
1303                 p = isl_printer_print_isl_int(p, c);
1304                 p = isl_printer_print_str(p, "*");
1305         }
1306         type = pos2type(bset->dim, &pos);
1307         p = print_name_c(p, bset, type, pos);
1308         return p;
1309 }
1310
1311 static __isl_give isl_printer *print_affine_c(__isl_take isl_printer *p,
1312         __isl_keep isl_basic_set *bset, isl_int *c)
1313 {
1314         int i;
1315         int first;
1316         unsigned len = 1 + isl_basic_set_total_dim(bset);
1317
1318         for (i = 0, first = 1; i < len; ++i) {
1319                 int flip = 0;
1320                 if (isl_int_is_zero(c[i]))
1321                         continue;
1322                 if (!first) {
1323                         if (isl_int_is_neg(c[i])) {
1324                                 flip = 1;
1325                                 isl_int_neg(c[i], c[i]);
1326                                 p = isl_printer_print_str(p, " - ");
1327                         } else
1328                                 p = isl_printer_print_str(p, " + ");
1329                 }
1330                 first = 0;
1331                 p = print_term_c(p, bset, c[i], i);
1332                 if (flip)
1333                         isl_int_neg(c[i], c[i]);
1334         }
1335         if (first)
1336                 p = isl_printer_print_str(p, "0");
1337         return p;
1338 }
1339
1340 static __isl_give isl_printer *print_constraint_c(__isl_take isl_printer *p,
1341         __isl_keep isl_basic_set *bset, isl_int *c, const char *op, int first)
1342 {
1343         if (!first)
1344                 p = isl_printer_print_str(p, " && ");
1345
1346         p = print_affine_c(p, bset, c);
1347         p = isl_printer_print_str(p, " ");
1348         p = isl_printer_print_str(p, op);
1349         p = isl_printer_print_str(p, " 0");
1350         return p;
1351 }
1352
1353 static __isl_give isl_printer *print_basic_set_c(__isl_take isl_printer *p,
1354         __isl_keep isl_basic_set *bset)
1355 {
1356         int i;
1357
1358         for (i = 0; i < bset->n_eq; ++i)
1359                 p = print_constraint_c(p, bset, bset->eq[i], "==", !i);
1360         for (i = 0; i < bset->n_ineq; ++i)
1361                 p = print_constraint_c(p, bset, bset->ineq[i], ">=",
1362                                         !bset->n_eq && !i);
1363         return p;
1364 }
1365
1366 static __isl_give isl_printer *print_set_c(__isl_take isl_printer *p,
1367         __isl_keep isl_set *set)
1368 {
1369         int i;
1370
1371         if (set->n == 0)
1372                 p = isl_printer_print_str(p, "0");
1373
1374         for (i = 0; i < set->n; ++i) {
1375                 if (i)
1376                         p = isl_printer_print_str(p, " || ");
1377                 if (set->n > 1)
1378                         p = isl_printer_print_str(p, "(");
1379                 p = print_basic_set_c(p, set->p[i]);
1380                 if (set->n > 1)
1381                         p = isl_printer_print_str(p, ")");
1382         }
1383         return p;
1384 }
1385
1386 static __isl_give isl_printer *print_qpolynomial_c(__isl_take isl_printer *p,
1387         __isl_keep isl_qpolynomial *qp)
1388 {
1389         isl_int den;
1390
1391         isl_int_init(den);
1392         isl_qpolynomial_get_den(qp, &den);
1393         if (!isl_int_is_one(den)) {
1394                 isl_qpolynomial *f;
1395                 p = isl_printer_print_str(p, "(");
1396                 qp = isl_qpolynomial_copy(qp);
1397                 f = isl_qpolynomial_rat_cst(isl_dim_copy(qp->dim),
1398                                                 den, qp->dim->ctx->one);
1399                 qp = isl_qpolynomial_mul(qp, f);
1400         }
1401         if (qp)
1402                 p = upoly_print(qp->upoly, qp->dim, qp->div, p);
1403         if (!isl_int_is_one(den)) {
1404                 p = isl_printer_print_str(p, ")/");
1405                 p = isl_printer_print_isl_int(p, den);
1406                 isl_qpolynomial_free(qp);
1407         }
1408         isl_int_clear(den);
1409         return p;
1410 }
1411
1412 static __isl_give isl_printer *print_pw_qpolynomial_c(
1413         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial *pwpq)
1414 {
1415         int i;
1416
1417         if (pwpq->n == 1 && isl_set_fast_is_universe(pwpq->p[0].set))
1418                 return print_qpolynomial_c(p, pwpq->p[0].qp);
1419
1420         for (i = 0; i < pwpq->n; ++i) {
1421                 p = isl_printer_print_str(p, "(");
1422                 p = print_set_c(p, pwpq->p[i].set);
1423                 p = isl_printer_print_str(p, ") ? (");
1424                 p = print_qpolynomial_c(p, pwpq->p[i].qp);
1425                 p = isl_printer_print_str(p, ") : ");
1426         }
1427
1428         p = isl_printer_print_str(p, "0");
1429         return p;
1430 }
1431
1432 __isl_give isl_printer *isl_printer_print_pw_qpolynomial(
1433         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial *pwqp)
1434 {
1435         if (!p || !pwqp)
1436                 goto error;
1437
1438         if (p->output_format == ISL_FORMAT_ISL)
1439                 return print_pw_qpolynomial_isl(p, pwqp);
1440         else if (p->output_format == ISL_FORMAT_C)
1441                 return print_pw_qpolynomial_c(p, pwqp);
1442         isl_assert(p->ctx, 0, goto error);
1443 error:
1444         isl_printer_free(p);
1445         return NULL;
1446 }
1447
1448 static __isl_give isl_printer *print_qpolynomial_fold_c(
1449         __isl_take isl_printer *p, __isl_keep isl_qpolynomial_fold *fold)
1450 {
1451         int i;
1452
1453         for (i = 0; i < fold->n - 1; ++i)
1454                 if (fold->type == isl_fold_min)
1455                         p = isl_printer_print_str(p, "min(");
1456                 else if (fold->type == isl_fold_max)
1457                         p = isl_printer_print_str(p, "max(");
1458
1459         for (i = 0; i < fold->n; ++i) {
1460                 if (i)
1461                         p = isl_printer_print_str(p, ", ");
1462                 p = print_qpolynomial_c(p, fold->qp[i]);
1463                 if (i)
1464                         p = isl_printer_print_str(p, ")");
1465         }
1466         return p;
1467 }
1468
1469 static __isl_give isl_printer *print_pw_qpolynomial_fold_c(
1470         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial_fold *pwf)
1471 {
1472         int i;
1473
1474         if (pwf->n == 1 && isl_set_fast_is_universe(pwf->p[0].set))
1475                 return print_qpolynomial_fold_c(p, pwf->p[0].fold);
1476
1477         for (i = 0; i < pwf->n; ++i) {
1478                 p = isl_printer_print_str(p, "(");
1479                 p = print_set_c(p, pwf->p[i].set);
1480                 p = isl_printer_print_str(p, ") ? (");
1481                 p = print_qpolynomial_fold_c(p, pwf->p[i].fold);
1482                 p = isl_printer_print_str(p, ") : ");
1483         }
1484
1485         p = isl_printer_print_str(p, "0");
1486         return p;
1487 }
1488
1489 __isl_give isl_printer *isl_printer_print_pw_qpolynomial_fold(
1490         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial_fold *pwf)
1491 {
1492         if (!p || !pwf)
1493                 goto error;
1494
1495         if (p->output_format == ISL_FORMAT_ISL)
1496                 return print_pw_qpolynomial_fold_isl(p, pwf);
1497         else if (p->output_format == ISL_FORMAT_C)
1498                 return print_pw_qpolynomial_fold_c(p, pwf);
1499         isl_assert(p->ctx, 0, goto error);
1500 error:
1501         isl_printer_free(p);
1502         return NULL;
1503 }
1504
1505 void isl_pw_qpolynomial_fold_print(__isl_keep isl_pw_qpolynomial_fold *pwf,
1506         FILE *out, unsigned output_format)
1507 {
1508         isl_printer *p;
1509
1510         if (!pwf)
1511                 return;
1512
1513         p = isl_printer_to_file(pwf->dim->ctx, out);
1514         p = isl_printer_set_output_format(p, output_format);
1515         p = isl_printer_print_pw_qpolynomial_fold(p, pwf);
1516
1517         isl_printer_free(p);
1518 }