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         const char *name = NULL;
 307         unsigned n = isl_dim_size(dim, type);
 308         if ((type == isl_dim_in || type == isl_dim_out)) {
 309                 name = isl_dim_get_tuple_name(dim, type);
 310                 if (name)
 311                         p = isl_printer_print_str(p, name);
 312         }
 313         if (!latex || n != 1 || name)
 314                 p = isl_printer_print_str(p, s_open_list[latex]);
 315         p = print_var_list(dim, p, type, set, latex, eq);
 316         if (!latex || n != 1 || name)
 317                 p = isl_printer_print_str(p, s_close_list[latex]);
 318         return p;
 319 }
 320
 321 static __isl_give isl_printer *print_omega_parameters(__isl_keep isl_dim *dim,
 322         __isl_take isl_printer *p)
 323 {
 324         if (isl_dim_size(dim, isl_dim_param) == 0)
 325                 return p;
 326
 327         p = isl_printer_start_line(p);
 328         p = isl_printer_print_str(p, "symbolic ");
 329         p = print_var_list(dim, p, isl_dim_param, 0, 0, NULL);
 330         p = isl_printer_print_str(p, ";");
 331         p = isl_printer_end_line(p);
 332         return p;
 333 }
 334
 335 static __isl_give isl_printer *print_constraint(struct isl_basic_map *bmap,
 336         __isl_keep isl_dim *dim, __isl_take isl_printer *p,
 337         isl_int *c, int last, const char *op, int first_constraint, int set,
 338         int latex)
 339 {
 340         if (!first_constraint)
 341                 p = isl_printer_print_str(p, s_and[latex]);
 342
 343         isl_int_abs(c[last], c[last]);
 344
 345         p = print_term(dim, c[last], last, p, set, latex);
 346
 347         p = isl_printer_print_str(p, " ");
 348         p = isl_printer_print_str(p, op);
 349         p = isl_printer_print_str(p, " ");
 350
 351         isl_int_set_si(c[last], 0);
 352         p = print_affine(bmap, dim, p, c, set);
 353
 354         return p;
 355 }
 356
 357 static __isl_give isl_printer *print_constraints(__isl_keep isl_basic_map *bmap,
 358         __isl_keep isl_dim *dim, __isl_take isl_printer *p, int set, int latex)
 359 {
 360         int i;
 361         struct isl_vec *c;
 362         unsigned total = isl_basic_map_total_dim(bmap);
 363
 364         c = isl_vec_alloc(bmap->ctx, 1 + total);
 365         if (!c)
 366                 goto error;
 367
 368         for (i = bmap->n_eq - 1; i >= 0; --i) {
 369                 int l = isl_seq_last_non_zero(bmap->eq[i], 1 + total);
 370                 isl_assert(bmap->ctx, l >= 0, goto error);
 371                 if (isl_int_is_neg(bmap->eq[i][l]))
 372                         isl_seq_cpy(c->el, bmap->eq[i], 1 + total);
 373                 else
 374                         isl_seq_neg(c->el, bmap->eq[i], 1 + total);
 375                 p = print_constraint(bmap, dim, p, c->el, l,
 376                                     "=", i == bmap->n_eq - 1, set, latex);
 377         }
 378         for (i = 0; i < bmap->n_ineq; ++i) {
 379                 int l = isl_seq_last_non_zero(bmap->ineq[i], 1 + total);
 380                 int s;
 381                 const char *op;
 382                 if (l < 0)
 383                         continue;
 384                 s = isl_int_sgn(bmap->ineq[i][l]);
 385                 if (s < 0)
 386                         isl_seq_cpy(c->el, bmap->ineq[i], 1 + total);
 387                 else
 388                         isl_seq_neg(c->el, bmap->ineq[i], 1 + total);
 389                 op = s < 0 ? s_le[latex] : s_ge[latex];
 390                 p = print_constraint(bmap, dim, p, c->el, l,
 391                                         op, !bmap->n_eq && !i, set, latex);
 392         }
 393
 394         isl_vec_free(c);
 395
 396         return p;
 397 error:
 398         isl_printer_free(p);
 399         return NULL;
 400 }
 401
 402 static __isl_give isl_printer *print_omega_constraints(
 403         __isl_keep isl_basic_map *bmap, __isl_take isl_printer *p, int set)
 404 {
 405         if (bmap->n_eq + bmap->n_ineq == 0)
 406                 return p;
 407
 408         p = isl_printer_print_str(p, ": ");
 409         if (bmap->n_div > 0) {
 410                 int i;
 411                 p = isl_printer_print_str(p, "exists (");
 412                 for (i = 0; i < bmap->n_div; ++i) {
 413                         if (i)
 414                                 p = isl_printer_print_str(p, ", ");
 415                         p = print_name(bmap->dim, p, isl_dim_div, i, 0, 0);
 416                 }
 417                 p = isl_printer_print_str(p, ": ");
 418         }
 419         p = print_constraints(bmap, bmap->dim, p, set, 0);
 420         if (bmap->n_div > 0)
 421                 p = isl_printer_print_str(p, ")");
 422         return p;
 423 }
 424
 425 static __isl_give isl_printer *basic_map_print_omega(
 426         __isl_keep isl_basic_map *bmap, __isl_take isl_printer *p)
 427 {
 428         p = isl_printer_print_str(p, "{ [");
 429         p = print_var_list(bmap->dim, p, isl_dim_in, 0, 0, NULL);
 430         p = isl_printer_print_str(p, "] -> [");
 431         p = print_var_list(bmap->dim, p, isl_dim_out, 0, 0, NULL);
 432         p = isl_printer_print_str(p, "] ");
 433         p = print_omega_constraints(bmap, p, 0);
 434         p = isl_printer_print_str(p, " }");
 435         return p;
 436 }
 437
 438 static __isl_give isl_printer *isl_basic_map_print_omega(
 439         __isl_keep isl_basic_map *bmap, __isl_take isl_printer *p)
 440 {
 441         p = print_omega_parameters(bmap->dim, p);
 442
 443         p = isl_printer_start_line(p);
 444         p = basic_map_print_omega(bmap, p);
 445         p = isl_printer_end_line(p);
 446         return p;
 447 }
 448
 449 static __isl_give isl_printer *basic_set_print_omega(
 450         __isl_keep isl_basic_set *bset, __isl_take isl_printer *p)
 451 {
 452         p = isl_printer_print_str(p, "{ [");
 453         p = print_var_list(bset->dim, p, isl_dim_set, 1, 0, NULL);
 454         p = isl_printer_print_str(p, "] ");
 455         p = print_omega_constraints((isl_basic_map *)bset, p, 1);
 456         p = isl_printer_print_str(p, " }");
 457         return p;
 458 }
 459
 460 static __isl_give isl_printer *isl_basic_set_print_omega(
 461         __isl_keep isl_basic_set *bset, __isl_take isl_printer *p)
 462 {
 463         p = print_omega_parameters(bset->dim, p);
 464
 465         p = isl_printer_start_line(p);
 466         p = basic_set_print_omega(bset, p);
 467         p = isl_printer_end_line(p);
 468         return p;
 469 }
 470
 471 static __isl_give isl_printer *isl_map_print_omega(__isl_keep isl_map *map,
 472         __isl_take isl_printer *p)
 473 {
 474         int i;
 475
 476         p = print_omega_parameters(map->dim, p);
 477
 478         p = isl_printer_start_line(p);
 479         for (i = 0; i < map->n; ++i) {
 480                 if (i)
 481                         p = isl_printer_print_str(p, " union ");
 482                 p = basic_map_print_omega(map->p[i], p);
 483         }
 484         p = isl_printer_end_line(p);
 485         return p;
 486 }
 487
 488 static __isl_give isl_printer *isl_set_print_omega(__isl_keep isl_set *set,
 489         __isl_take isl_printer *p)
 490 {
 491         int i;
 492
 493         p = print_omega_parameters(set->dim, p);
 494
 495         p = isl_printer_start_line(p);
 496         for (i = 0; i < set->n; ++i) {
 497                 if (i)
 498                         p = isl_printer_print_str(p, " union ");
 499                 p = basic_set_print_omega(set->p[i], p);
 500         }
 501         p = isl_printer_end_line(p);
 502         return p;
 503 }
 504
 505 static __isl_give isl_printer *print_disjunct(__isl_keep isl_basic_map *bmap,
 506         __isl_keep isl_dim *dim, __isl_take isl_printer *p, int set, int latex)
 507 {
 508         if (bmap->n_div > 0) {
 509                 int i;
 510                 p = isl_printer_print_str(p, s_open_exists[latex]);
 511                 for (i = 0; i < bmap->n_div; ++i) {
 512                         if (i)
 513                                 p = isl_printer_print_str(p, ", ");
 514                         p = print_name(dim, p, isl_dim_div, i, 0, latex);
 515                         if (latex || isl_int_is_zero(bmap->div[i][0]))
 516                                 continue;
 517                         p = isl_printer_print_str(p, " = [(");
 518                         p = print_affine(bmap, dim, p, bmap->div[i] + 1, set);
 519                         p = isl_printer_print_str(p, ")/");
 520                         p = isl_printer_print_isl_int(p, bmap->div[i][0]);
 521                         p = isl_printer_print_str(p, "]");
 522                 }
 523                 p = isl_printer_print_str(p, ": ");
 524         }
 525
 526         p = print_constraints(bmap, dim, p, set, latex);
 527
 528         if (bmap->n_div > 0)
 529                 p = isl_printer_print_str(p, s_close_exists[latex]);
 530         return p;
 531 }
 532
 533 static __isl_give isl_printer *isl_basic_map_print_isl(
 534         __isl_keep isl_basic_map *bmap, __isl_take isl_printer *p, int latex)
 535 {
 536         int i;
 537
 538         p = isl_printer_start_line(p);
 539         if (isl_basic_map_dim(bmap, isl_dim_param) > 0) {
 540                 p = print_tuple(bmap->dim, p, isl_dim_param, 0, latex, NULL);
 541                 p = isl_printer_print_str(p, " -> ");
 542         }
 543         p = isl_printer_print_str(p, "{ ");
 544         p = print_tuple(bmap->dim, p, isl_dim_in, 0, latex, NULL);
 545         p = isl_printer_print_str(p, " -> ");
 546         p = print_tuple(bmap->dim, p, isl_dim_out, 0, latex, NULL);
 547         p = isl_printer_print_str(p, " : ");
 548         p = print_disjunct(bmap, bmap->dim, p, 0, latex);
 549         p = isl_printer_print_str(p, " }");
 550         p = isl_printer_end_line(p);
 551         return p;
 552 }
 553
 554 static __isl_give isl_printer *isl_basic_set_print_isl(
 555         __isl_keep isl_basic_set *bset, __isl_take isl_printer *p, int latex)
 556 {
 557         int i;
 558
 559         p = isl_printer_start_line(p);
 560         if (isl_basic_set_dim(bset, isl_dim_param) > 0) {
 561                 p = print_tuple(bset->dim, p, isl_dim_param, 0, latex, NULL);
 562                 p = isl_printer_print_str(p, " -> ");
 563         }
 564         p = isl_printer_print_str(p, "{ ");
 565         p = print_tuple(bset->dim, p, isl_dim_set, 1, latex, NULL);
 566         p = isl_printer_print_str(p, " : ");
 567         p = print_disjunct((isl_basic_map *)bset, bset->dim, p, 1, latex);
 568         p = isl_printer_print_str(p, " }");
 569         p = isl_printer_end_line(p);
 570         return p;
 571 }
 572
 573 static __isl_give isl_printer *print_disjuncts(__isl_keep isl_map *map,
 574         __isl_take isl_printer *p, int set, int latex)
 575 {
 576         int i;
 577
 578         if (isl_map_fast_is_universe(map))
 579                 return p;
 580
 581         p = isl_printer_print_str(p, s_such_that[latex]);
 582         if (map->n == 0)
 583                 p = isl_printer_print_str(p, "1 = 0");
 584         for (i = 0; i < map->n; ++i) {
 585                 if (i)
 586                         p = isl_printer_print_str(p, s_or[latex]);
 587                 if (map->n > 1 && map->p[i]->n_eq + map->p[i]->n_ineq > 1)
 588                         p = isl_printer_print_str(p, "(");
 589                 p = print_disjunct(map->p[i], map->dim, p, set, latex);
 590                 if (map->n > 1 && map->p[i]->n_eq + map->p[i]->n_ineq > 1)
 591                         p = isl_printer_print_str(p, ")");
 592         }
 593         return p;
 594 }
 595
 596 struct isl_aff_split {
 597         isl_basic_map *aff;
 598         isl_map *map;
 599 };
 600
 601 static void free_split(__isl_take struct isl_aff_split *split, int n)
 602 {
 603         int i;
 604
 605         if (!split)
 606                 return;
 607
 608         for (i = 0; i < n; ++i) {
 609                 isl_basic_map_free(split[i].aff);
 610                 isl_map_free(split[i].map);
 611         }
 612
 613         free(split);
 614 }
 615
 616 static __isl_give isl_basic_map *get_aff(__isl_take isl_basic_map *bmap)
 617 {
 618         int i, j;
 619         unsigned nparam, n_in, n_out, total;
 620
 621         bmap = isl_basic_map_cow(bmap);
 622         if (!bmap)
 623                 return NULL;
 624         if (isl_basic_map_free_inequality(bmap, bmap->n_ineq) < 0)
 625                 goto error;
 626
 627         nparam = isl_basic_map_dim(bmap, isl_dim_param);
 628         n_in = isl_basic_map_dim(bmap, isl_dim_in);
 629         n_out = isl_basic_map_dim(bmap, isl_dim_out);
 630         total = isl_basic_map_dim(bmap, isl_dim_all);
 631         for (i = bmap->n_eq - 1; i >= 0; --i) {
 632                 j = isl_seq_last_non_zero(bmap->eq[i] + 1, total);
 633                 if (j >= nparam && j < nparam + n_in + n_out &&
 634                     (isl_int_is_one(bmap->eq[i][1 + j]) ||
 635                      isl_int_is_negone(bmap->eq[i][1 + j])))
 636                         continue;
 637                 if (isl_basic_map_drop_equality(bmap, i) < 0)
 638                         goto error;
 639         }
 640
 641         bmap = isl_basic_map_finalize(bmap);
 642
 643         return bmap;
 644 error:
 645         isl_basic_map_free(bmap);
 646         return NULL;
 647 }
 648
 649 static int aff_split_cmp(const void *p1, const void *p2)
 650 {
 651         const struct isl_aff_split *s1, *s2;
 652         s1 = (const struct isl_aff_split *) p1;
 653         s2 = (const struct isl_aff_split *) p2;
 654
 655         return isl_basic_map_fast_cmp(s1->aff, s2->aff);
 656 }
 657
 658 static __isl_give isl_basic_map *drop_aff(__isl_take isl_basic_map *bmap,
 659         __isl_keep isl_basic_map *aff)
 660 {
 661         int i, j;
 662         unsigned total;
 663
 664         if (!bmap || !aff)
 665                 goto error;
 666
 667         total = isl_dim_total(bmap->dim);
 668
 669         for (i = bmap->n_eq - 1; i >= 0; --i) {
 670                 if (isl_seq_first_non_zero(bmap->eq[i] + 1 + total,
 671                                             bmap->n_div) != -1)
 672                         continue;
 673                 for (j = 0; j < aff->n_eq; ++j) {
 674                         if (!isl_seq_eq(bmap->eq[i], aff->eq[j], 1 + total) &&
 675                             !isl_seq_is_neg(bmap->eq[i], aff->eq[j], 1 + total))
 676                                 continue;
 677                         if (isl_basic_map_drop_equality(bmap, i) < 0)
 678                                 goto error;
 679                         break;
 680                 }
 681         }
 682
 683         return bmap;
 684 error:
 685         isl_basic_map_free(bmap);
 686         return NULL;
 687 }
 688
 689 static __isl_give struct isl_aff_split *split_aff(__isl_keep isl_map *map)
 690 {
 691         int i, n;
 692         struct isl_aff_split *split;
 693
 694         split = isl_calloc_array(map->isl, struct isl_aff_split, map->n);
 695         if (!split)
 696                 return NULL;
 697
 698         for (i = 0; i < map->n; ++i) {
 699                 isl_basic_map *bmap;
 700                 split[i].aff = get_aff(isl_basic_map_copy(map->p[i]));
 701                 bmap = isl_basic_map_copy(map->p[i]);
 702                 bmap = isl_basic_map_cow(bmap);
 703                 bmap = drop_aff(bmap, split[i].aff);
 704                 split[i].map = isl_map_from_basic_map(bmap);
 705                 if (!split[i].aff || !split[i].map)
 706                         goto error;
 707         }
 708
 709         qsort(split, map->n, sizeof(struct isl_aff_split), &aff_split_cmp);
 710
 711         n = map->n;
 712         for (i = n - 1; i >= 1; --i) {
 713                 if (!isl_basic_map_fast_is_equal(split[i - 1].aff,
 714                                                  split[i].aff))
 715                         continue;
 716                 isl_basic_map_free(split[i].aff);
 717                 split[i - 1].map = isl_map_union(split[i - 1].map,
 718                                                  split[i].map);
 719                 if (i != n - 1)
 720                         split[i] = split[n - 1];
 721                 split[n - 1].aff = NULL;
 722                 split[n - 1].map = NULL;
 723                 --n;
 724         }
 725
 726         return split;
 727 error:
 728         free_split(split, map->n);
 729         return NULL;
 730 }
 731
 732 static __isl_give isl_printer *print_split_map(__isl_take isl_printer *p,
 733         struct isl_aff_split *split, int n, int set)
 734 {
 735         int i;
 736
 737         for (i = 0; i < n; ++i) {
 738                 isl_dim *dim;
 739
 740                 if (!split[i].map)
 741                         break;
 742                 dim = split[i].map->dim;
 743                 if (i)
 744                         p = isl_printer_print_str(p, "; ");
 745                 if (set)
 746                         p = print_tuple(dim, p, isl_dim_set, 1, 0, split[i].aff);
 747                 else {
 748                         p = print_tuple(dim, p, isl_dim_in, 0, 0, split[i].aff);
 749                         p = isl_printer_print_str(p, s_to[0]);
 750                         p = print_tuple(dim, p, isl_dim_out, 0, 0, split[i].aff);
 751                 }
 752                 p = print_disjuncts(split[i].map, p, set, 0);
 753         }
 754
 755         return p;
 756 }
 757
 758 static __isl_give isl_printer *isl_map_print_isl(__isl_keep isl_map *map,
 759         __isl_take isl_printer *p, int set)
 760 {
 761         struct isl_aff_split *split = NULL;
 762
 763         if (map->n > 0)
 764                 split = split_aff(map);
 765         if (isl_map_dim(map, isl_dim_param) > 0) {
 766                 p = print_tuple(map->dim, p, isl_dim_param, set, 0, NULL);
 767                 p = isl_printer_print_str(p, s_to[0]);
 768         }
 769         p = isl_printer_print_str(p, s_open_set[0]);
 770         if (split) {
 771                 p = print_split_map(p, split, map->n, set);
 772         } else {
 773                 if (set)
 774                         p = print_tuple(map->dim, p, isl_dim_set, 1, 0, NULL);
 775                 else {
 776                         p = print_tuple(map->dim, p, isl_dim_in, 0, 0, NULL);
 777                         p = isl_printer_print_str(p, s_to[0]);
 778                         p = print_tuple(map->dim, p, isl_dim_out, 0, 0, NULL);
 779                 }
 780                 p = print_disjuncts(map, p, set, 0);
 781         }
 782         p = isl_printer_print_str(p, s_close_set[0]);
 783         free_split(split, map->n);
 784         return p;
 785 }
 786
 787 static __isl_give isl_printer *print_latex_map(__isl_keep isl_map *map,
 788         __isl_take isl_printer *p, __isl_keep isl_basic_map *aff, int set)
 789 {
 790         if (isl_map_dim(map, isl_dim_param) > 0) {
 791                 p = print_tuple(map->dim, p, isl_dim_param, set, 1, NULL);
 792                 p = isl_printer_print_str(p, s_to[1]);
 793         }
 794         p = isl_printer_print_str(p, s_open_set[1]);
 795         if (set)
 796                 p = print_tuple(map->dim, p, isl_dim_set, 1, 1, aff);
 797         else {
 798                 p = print_tuple(map->dim, p, isl_dim_in, 0, 1, aff);
 799                 p = isl_printer_print_str(p, s_to[1]);
 800                 p = print_tuple(map->dim, p, isl_dim_out, 0, 1, aff);
 801         }
 802         p = print_disjuncts(map, p, set, 1);
 803         p = isl_printer_print_str(p, s_close_set[1]);
 804
 805         return p;
 806 }
 807
 808 static __isl_give isl_printer *isl_map_print_latex(__isl_keep isl_map *map,
 809         __isl_take isl_printer *p, int set)
 810 {
 811         int i;
 812         struct isl_aff_split *split = NULL;
 813
 814         if (map->n > 0)
 815                 split = split_aff(map);
 816
 817         if (!split)
 818                 return print_latex_map(map, p, NULL, set);
 819
 820         for (i = 0; i < map->n; ++i) {
 821                 if (!split[i].map)
 822                         break;
 823                 if (i)
 824                         p = isl_printer_print_str(p, " \\cup ");
 825                 p = print_latex_map(split[i].map, p, split[i].aff, set);
 826         }
 827
 828         free_split(split, map->n);
 829         return p;
 830 }
 831
 832 __isl_give isl_printer *isl_printer_print_basic_map(__isl_take isl_printer *p,
 833         __isl_keep isl_basic_map *bmap)
 834 {
 835         if (!p || !bmap)
 836                 goto error;
 837         if (p->output_format == ISL_FORMAT_ISL)
 838                 return isl_basic_map_print_isl(bmap, p, 0);
 839         else if (p->output_format == ISL_FORMAT_OMEGA)
 840                 return isl_basic_map_print_omega(bmap, p);
 841         isl_assert(bmap->ctx, 0, goto error);
 842 error:
 843         isl_printer_free(p);
 844         return NULL;
 845 }
 846
 847 void isl_basic_map_print(__isl_keep isl_basic_map *bmap, FILE *out, int indent,
 848         const char *prefix, const char *suffix, unsigned output_format)
 849 {
 850         isl_printer *printer;
 851
 852         if (!bmap)
 853                 return;
 854
 855         printer = isl_printer_to_file(bmap->ctx, out);
 856         printer = isl_printer_set_indent(printer, indent);
 857         printer = isl_printer_set_prefix(printer, prefix);
 858         printer = isl_printer_set_suffix(printer, suffix);
 859         printer = isl_printer_set_output_format(printer, output_format);
 860         isl_printer_print_basic_map(printer, bmap);
 861
 862         isl_printer_free(printer);
 863 }
 864
 865 __isl_give isl_printer *isl_printer_print_basic_set(__isl_take isl_printer *p,
 866         __isl_keep isl_basic_set *bset)
 867 {
 868         if (!p || !bset)
 869                 goto error;
 870
 871         if (p->output_format == ISL_FORMAT_ISL)
 872                 return isl_basic_set_print_isl(bset, p, 0);
 873         else if (p->output_format == ISL_FORMAT_POLYLIB)
 874                 return isl_basic_set_print_polylib(bset, p);
 875         else if (p->output_format == ISL_FORMAT_POLYLIB_CONSTRAINTS)
 876                 return bset_print_constraints_polylib(bset, p);
 877         else if (p->output_format == ISL_FORMAT_OMEGA)
 878                 return isl_basic_set_print_omega(bset, p);
 879         isl_assert(p->ctx, 0, goto error);
 880 error:
 881         isl_printer_free(p);
 882         return NULL;
 883 }
 884
 885 void isl_basic_set_print(struct isl_basic_set *bset, FILE *out, int indent,
 886         const char *prefix, const char *suffix, unsigned output_format)
 887 {
 888         isl_printer *printer;
 889
 890         if (!bset)
 891                 return;
 892
 893         printer = isl_printer_to_file(bset->ctx, out);
 894         printer = isl_printer_set_indent(printer, indent);
 895         printer = isl_printer_set_prefix(printer, prefix);
 896         printer = isl_printer_set_suffix(printer, suffix);
 897         printer = isl_printer_set_output_format(printer, output_format);
 898         isl_printer_print_basic_set(printer, bset);
 899
 900         isl_printer_free(printer);
 901 }
 902
 903 __isl_give isl_printer *isl_printer_print_set(__isl_take isl_printer *p,
 904         __isl_keep isl_set *set)
 905 {
 906         if (!p || !set)
 907                 goto error;
 908         if (p->output_format == ISL_FORMAT_ISL)
 909                 return isl_map_print_isl((isl_map *)set, p, 1);
 910         else if (p->output_format == ISL_FORMAT_POLYLIB)
 911                 return isl_set_print_polylib(set, p);
 912         else if (p->output_format == ISL_FORMAT_OMEGA)
 913                 return isl_set_print_omega(set, p);
 914         else if (p->output_format == ISL_FORMAT_LATEX)
 915                 return isl_map_print_latex((isl_map *)set, p, 1);
 916         isl_assert(set->ctx, 0, goto error);
 917 error:
 918         isl_printer_free(p);
 919         return NULL;
 920 }
 921
 922 void isl_set_print(struct isl_set *set, FILE *out, int indent,
 923         unsigned output_format)
 924 {
 925         isl_printer *printer;
 926
 927         if (!set)
 928                 return;
 929
 930         printer = isl_printer_to_file(set->ctx, out);
 931         printer = isl_printer_set_indent(printer, indent);
 932         printer = isl_printer_set_output_format(printer, output_format);
 933         printer = isl_printer_print_set(printer, set);
 934
 935         isl_printer_free(printer);
 936 }
 937
 938 __isl_give isl_printer *isl_printer_print_map(__isl_take isl_printer *p,
 939         __isl_keep isl_map *map)
 940 {
 941         if (!p || !map)
 942                 goto error;
 943
 944         if (p->output_format == ISL_FORMAT_ISL)
 945                 return isl_map_print_isl(map, p, 0);
 946         else if (p->output_format == ISL_FORMAT_POLYLIB)
 947                 return isl_map_print_polylib(map, p);
 948         else if (p->output_format == ISL_FORMAT_OMEGA)
 949                 return isl_map_print_omega(map, p);
 950         else if (p->output_format == ISL_FORMAT_LATEX)
 951                 return isl_map_print_latex(map, p, 0);
 952         isl_assert(map->ctx, 0, goto error);
 953 error:
 954         isl_printer_free(p);
 955         return NULL;
 956 }
 957
 958 void isl_map_print(__isl_keep isl_map *map, FILE *out, int indent,
 959         unsigned output_format)
 960 {
 961         isl_printer *printer;
 962
 963         if (!map)
 964                 return;
 965
 966         printer = isl_printer_to_file(map->ctx, out);
 967         printer = isl_printer_set_indent(printer, indent);
 968         printer = isl_printer_set_output_format(printer, output_format);
 969         printer = isl_printer_print_map(printer, map);
 970
 971         isl_printer_free(printer);
 972 }
 973
 974 static int upoly_rec_n_non_zero(__isl_keep struct isl_upoly_rec *rec)
 975 {
 976         int i;
 977         int n;
 978
 979         for (i = 0, n = 0; i < rec->n; ++i)
 980                 if (!isl_upoly_is_zero(rec->p[i]))
 981                         ++n;
 982
 983         return n;
 984 }
 985
 986 static __isl_give isl_printer *print_div(__isl_keep isl_dim *dim,
 987         __isl_keep isl_mat *div, int pos, __isl_take isl_printer *p)
 988 {
 989         int c = p->output_format == ISL_FORMAT_C;
 990         p = isl_printer_print_str(p, c ? "floord(" : "[(");
 991         p = print_affine_of_len(dim, p, div->row[pos] + 1, div->n_col - 1, 1);
 992         p = isl_printer_print_str(p, c ? ", " : ")/");
 993         p = isl_printer_print_isl_int(p, div->row[pos][0]);
 994         p = isl_printer_print_str(p, c ? ")" : "]");
 995         return p;
 996 }
 997
 998 static __isl_give isl_printer *upoly_print_cst(__isl_keep struct isl_upoly *up,
 999         __isl_take isl_printer *p, int first)
1000 {
1001         struct isl_upoly_cst *cst;
1002         int neg;
1003
1004         cst = isl_upoly_as_cst(up);
1005         if (!cst)
1006                 goto error;
1007         neg = !first && isl_int_is_neg(cst->n);
1008         if (!first)
1009                 p = isl_printer_print_str(p, neg ? " - " :  " + ");
1010         if (neg)
1011                 isl_int_neg(cst->n, cst->n);
1012         if (isl_int_is_zero(cst->d)) {
1013                 int sgn = isl_int_sgn(cst->n);
1014                 p = isl_printer_print_str(p, sgn < 0 ? "-infty" :
1015                                             sgn == 0 ? "NaN" : "infty");
1016         } else
1017                 p = isl_printer_print_isl_int(p, cst->n);
1018         if (neg)
1019                 isl_int_neg(cst->n, cst->n);
1020         if (!isl_int_is_zero(cst->d) && !isl_int_is_one(cst->d)) {
1021                 p = isl_printer_print_str(p, "/");
1022                 p = isl_printer_print_isl_int(p, cst->d);
1023         }
1024         return p;
1025 error:
1026         isl_printer_free(p);
1027         return NULL;
1028 }
1029
1030 static __isl_give isl_printer *print_base(__isl_take isl_printer *p,
1031         __isl_keep isl_dim *dim, __isl_keep isl_mat *div, int var)
1032 {
1033         unsigned total;
1034
1035         total = isl_dim_total(dim);
1036         if (var < total)
1037                 p = print_term(dim, dim->ctx->one, 1 + var, p, 1, 0);
1038         else
1039                 p = print_div(dim, div, var - total, p);
1040         return p;
1041 }
1042
1043 static __isl_give isl_printer *print_pow(__isl_take isl_printer *p,
1044         __isl_keep isl_dim *dim, __isl_keep isl_mat *div, int var, int exp)
1045 {
1046         p = print_base(p, dim, div, var);
1047         if (exp == 1)
1048                 return p;
1049         if (p->output_format == ISL_FORMAT_C) {
1050                 int i;
1051                 for (i = 1; i < exp; ++i) {
1052                         p = isl_printer_print_str(p, "*");
1053                         p = print_base(p, dim, div, var);
1054                 }
1055         } else {
1056                 p = isl_printer_print_str(p, "^");
1057                 p = isl_printer_print_int(p, exp);
1058         }
1059         return p;
1060 }
1061
1062 static __isl_give isl_printer *upoly_print(__isl_keep struct isl_upoly *up,
1063         __isl_keep isl_dim *dim, __isl_keep isl_mat *div,
1064         __isl_take isl_printer *p)
1065 {
1066         int i, n, first;
1067         struct isl_upoly_rec *rec;
1068
1069         if (!p || !up || !dim || !div)
1070                 goto error;
1071
1072         if (isl_upoly_is_cst(up))
1073                 return upoly_print_cst(up, p, 1);
1074
1075         rec = isl_upoly_as_rec(up);
1076         if (!rec)
1077                 goto error;
1078         n = upoly_rec_n_non_zero(rec);
1079         if (n > 1)
1080                 p = isl_printer_print_str(p, "(");
1081         for (i = 0, first = 1; i < rec->n; ++i) {
1082                 if (isl_upoly_is_zero(rec->p[i]))
1083                         continue;
1084                 if (isl_upoly_is_negone(rec->p[i])) {
1085                         if (!i)
1086                                 p = isl_printer_print_str(p, "-1");
1087                         else if (first)
1088                                 p = isl_printer_print_str(p, "-");
1089                         else
1090                                 p = isl_printer_print_str(p, " - ");
1091                 } else if (isl_upoly_is_cst(rec->p[i]) &&
1092                                 !isl_upoly_is_one(rec->p[i]))
1093                         p = upoly_print_cst(rec->p[i], p, first);
1094                 else {
1095                         if (!first)
1096                                 p = isl_printer_print_str(p, " + ");
1097                         if (i == 0 || !isl_upoly_is_one(rec->p[i]))
1098                                 p = upoly_print(rec->p[i], dim, div, p);
1099                 }
1100                 first = 0;
1101                 if (i == 0)
1102                         continue;
1103                 if (!isl_upoly_is_one(rec->p[i]) &&
1104                     !isl_upoly_is_negone(rec->p[i]))
1105                         p = isl_printer_print_str(p, " * ");
1106                 p = print_pow(p, dim, div, rec->up.var, i);
1107         }
1108         if (n > 1)
1109                 p = isl_printer_print_str(p, ")");
1110         return p;
1111 error:
1112         isl_printer_free(p);
1113         return NULL;
1114 }
1115
1116 __isl_give isl_printer *isl_printer_print_qpolynomial(__isl_take isl_printer *p,
1117         __isl_keep isl_qpolynomial *qp)
1118 {
1119         if (!p || !qp)
1120                 goto error;
1121         p = upoly_print(qp->upoly, qp->dim, qp->div, p);
1122         return p;
1123 error:
1124         isl_printer_free(p);
1125         return NULL;
1126 }
1127
1128 void isl_qpolynomial_print(__isl_keep isl_qpolynomial *qp, FILE *out,
1129         unsigned output_format)
1130 {
1131         isl_printer *p;
1132
1133         if  (!qp)
1134                 return;
1135
1136         isl_assert(qp->dim->ctx, output_format == ISL_FORMAT_ISL, return);
1137         p = isl_printer_to_file(qp->dim->ctx, out);
1138         p = isl_printer_print_qpolynomial(p, qp);
1139         isl_printer_free(p);
1140 }
1141
1142 static __isl_give isl_printer *qpolynomial_fold_print(
1143         __isl_keep isl_qpolynomial_fold *fold, __isl_take isl_printer *p)
1144 {
1145         int i;
1146
1147         if (fold->type == isl_fold_min)
1148                 p = isl_printer_print_str(p, "min");
1149         else if (fold->type == isl_fold_max)
1150                 p = isl_printer_print_str(p, "max");
1151         p = isl_printer_print_str(p, "(");
1152         for (i = 0; i < fold->n; ++i) {
1153                 if (i)
1154                         p = isl_printer_print_str(p, ", ");
1155                 p = isl_printer_print_qpolynomial(p, fold->qp[i]);
1156         }
1157         p = isl_printer_print_str(p, ")");
1158         return p;
1159 }
1160
1161 __isl_give isl_printer *isl_printer_print_qpolynomial_fold(
1162         __isl_take isl_printer *p, __isl_keep isl_qpolynomial_fold *fold)
1163 {
1164         if  (!p || !fold)
1165                 goto error;
1166         p = qpolynomial_fold_print(fold, p);
1167         return p;
1168 error:
1169         isl_printer_free(p);
1170         return NULL;
1171 }
1172
1173 void isl_qpolynomial_fold_print(__isl_keep isl_qpolynomial_fold *fold,
1174         FILE *out, unsigned output_format)
1175 {
1176         isl_printer *p;
1177
1178         if (!fold)
1179                 return;
1180
1181         isl_assert(fold->dim->ctx, output_format == ISL_FORMAT_ISL, return);
1182
1183         p = isl_printer_to_file(fold->dim->ctx, out);
1184         p = isl_printer_print_qpolynomial_fold(p, fold);
1185
1186         isl_printer_free(p);
1187 }
1188
1189 static __isl_give isl_printer *print_pw_qpolynomial_isl(
1190         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial *pwqp)
1191 {
1192         int i = 0;
1193
1194         if (!p || !pwqp)
1195                 goto error;
1196
1197         if (isl_dim_size(pwqp->dim, isl_dim_param) > 0) {
1198                 p = print_tuple(pwqp->dim, p, isl_dim_param, 0, 0, NULL);
1199                 p = isl_printer_print_str(p, " -> ");
1200         }
1201         p = isl_printer_print_str(p, "{ ");
1202         if (pwqp->n == 0) {
1203                 if (isl_dim_size(pwqp->dim, isl_dim_set) > 0) {
1204                         p = print_tuple(pwqp->dim, p, isl_dim_set, 1, 0, NULL);
1205                         p = isl_printer_print_str(p, " -> ");
1206                 }
1207                 p = isl_printer_print_str(p, "0");
1208         }
1209         for (i = 0; i < pwqp->n; ++i) {
1210                 if (i)
1211                         p = isl_printer_print_str(p, "; ");
1212                 if (isl_dim_size(pwqp->p[i].set->dim, isl_dim_set) > 0 ||
1213                     isl_dim_get_tuple_name(pwqp->p[i].set->dim, isl_dim_set)) {
1214                         p = print_tuple(pwqp->p[i].set->dim, p, isl_dim_set, 1, 0, NULL);
1215                         p = isl_printer_print_str(p, " -> ");
1216                 }
1217                 p = isl_printer_print_qpolynomial(p, pwqp->p[i].qp);
1218                 p = print_disjuncts((isl_map *)pwqp->p[i].set, p, 1, 0);
1219         }
1220         p = isl_printer_print_str(p, " }");
1221         return p;
1222 error:
1223         isl_printer_free(p);
1224         return NULL;
1225 }
1226
1227 void isl_pw_qpolynomial_print(__isl_keep isl_pw_qpolynomial *pwqp, FILE *out,
1228         unsigned output_format)
1229 {
1230         isl_printer *p;
1231
1232         if (!pwqp)
1233                 return;
1234
1235         p = isl_printer_to_file(pwqp->dim->ctx, out);
1236         p = isl_printer_set_output_format(p, output_format);
1237         p = isl_printer_print_pw_qpolynomial(p, pwqp);
1238
1239         isl_printer_free(p);
1240 }
1241
1242 static __isl_give isl_printer *print_pw_qpolynomial_fold_isl(
1243         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial_fold *pwf)
1244 {
1245         int i = 0;
1246
1247         if (isl_dim_size(pwf->dim, isl_dim_param) > 0) {
1248                 p = print_tuple(pwf->dim, p, isl_dim_param, 0, 0, NULL);
1249                 p = isl_printer_print_str(p, " -> ");
1250         }
1251         p = isl_printer_print_str(p, "{ ");
1252         if (pwf->n == 0) {
1253                 if (isl_dim_size(pwf->dim, isl_dim_set) > 0) {
1254                         p = print_tuple(pwf->dim, p, isl_dim_set, 0, 0, NULL);
1255                         p = isl_printer_print_str(p, " -> ");
1256                 }
1257                 p = isl_printer_print_str(p, "0");
1258         }
1259         for (i = 0; i < pwf->n; ++i) {
1260                 if (i)
1261                         p = isl_printer_print_str(p, "; ");
1262                 if (isl_dim_size(pwf->p[i].set->dim, isl_dim_set) > 0) {
1263                         p = print_tuple(pwf->p[i].set->dim, p, isl_dim_set, 0, 0, NULL);
1264                         p = isl_printer_print_str(p, " -> ");
1265                 }
1266                 p = qpolynomial_fold_print(pwf->p[i].fold, p);
1267                 p = print_disjuncts((isl_map *)pwf->p[i].set, p, 1, 0);
1268         }
1269         p = isl_printer_print_str(p, " }");
1270         return p;
1271 }
1272
1273 static __isl_give isl_printer *print_affine_c(__isl_take isl_printer *p,
1274         __isl_keep isl_basic_set *bset, isl_int *c);
1275
1276 static __isl_give isl_printer *print_name_c(__isl_take isl_printer *p,
1277         __isl_keep isl_basic_set *bset, enum isl_dim_type type, unsigned pos)
1278 {
1279         if (type == isl_dim_div) {
1280                 p = isl_printer_print_str(p, "floord(");
1281                 p = print_affine_c(p, bset, bset->div[pos] + 1);
1282                 p = isl_printer_print_str(p, ", ");
1283                 p = isl_printer_print_isl_int(p, bset->div[pos][0]);
1284                 p = isl_printer_print_str(p, ")");
1285         } else {
1286                 const char *name;
1287
1288                 name = isl_dim_get_name(bset->dim, type, pos);
1289                 if (!name)
1290                         name = "UNNAMED";
1291                 p = isl_printer_print_str(p, name);
1292         }
1293         return p;
1294 }
1295
1296 static __isl_give isl_printer *print_term_c(__isl_take isl_printer *p,
1297         __isl_keep isl_basic_set *bset, isl_int c, unsigned pos)
1298 {
1299         enum isl_dim_type type;
1300         unsigned nparam = isl_basic_set_dim(bset, isl_dim_param);
1301
1302         if (pos == 0)
1303                 return isl_printer_print_isl_int(p, c);
1304
1305         if (isl_int_is_one(c))
1306                 ;
1307         else if (isl_int_is_negone(c))
1308                 p = isl_printer_print_str(p, "-");
1309         else {
1310                 p = isl_printer_print_isl_int(p, c);
1311                 p = isl_printer_print_str(p, "*");
1312         }
1313         type = pos2type(bset->dim, &pos);
1314         p = print_name_c(p, bset, type, pos);
1315         return p;
1316 }
1317
1318 static __isl_give isl_printer *print_affine_c(__isl_take isl_printer *p,
1319         __isl_keep isl_basic_set *bset, isl_int *c)
1320 {
1321         int i;
1322         int first;
1323         unsigned len = 1 + isl_basic_set_total_dim(bset);
1324
1325         for (i = 0, first = 1; i < len; ++i) {
1326                 int flip = 0;
1327                 if (isl_int_is_zero(c[i]))
1328                         continue;
1329                 if (!first) {
1330                         if (isl_int_is_neg(c[i])) {
1331                                 flip = 1;
1332                                 isl_int_neg(c[i], c[i]);
1333                                 p = isl_printer_print_str(p, " - ");
1334                         } else
1335                                 p = isl_printer_print_str(p, " + ");
1336                 }
1337                 first = 0;
1338                 p = print_term_c(p, bset, c[i], i);
1339                 if (flip)
1340                         isl_int_neg(c[i], c[i]);
1341         }
1342         if (first)
1343                 p = isl_printer_print_str(p, "0");
1344         return p;
1345 }
1346
1347 static __isl_give isl_printer *print_constraint_c(__isl_take isl_printer *p,
1348         __isl_keep isl_basic_set *bset, isl_int *c, const char *op, int first)
1349 {
1350         if (!first)
1351                 p = isl_printer_print_str(p, " && ");
1352
1353         p = print_affine_c(p, bset, c);
1354         p = isl_printer_print_str(p, " ");
1355         p = isl_printer_print_str(p, op);
1356         p = isl_printer_print_str(p, " 0");
1357         return p;
1358 }
1359
1360 static __isl_give isl_printer *print_basic_set_c(__isl_take isl_printer *p,
1361         __isl_keep isl_basic_set *bset)
1362 {
1363         int i;
1364
1365         for (i = 0; i < bset->n_eq; ++i)
1366                 p = print_constraint_c(p, bset, bset->eq[i], "==", !i);
1367         for (i = 0; i < bset->n_ineq; ++i)
1368                 p = print_constraint_c(p, bset, bset->ineq[i], ">=",
1369                                         !bset->n_eq && !i);
1370         return p;
1371 }
1372
1373 static __isl_give isl_printer *print_set_c(__isl_take isl_printer *p,
1374         __isl_keep isl_set *set)
1375 {
1376         int i;
1377
1378         if (set->n == 0)
1379                 p = isl_printer_print_str(p, "0");
1380
1381         for (i = 0; i < set->n; ++i) {
1382                 if (i)
1383                         p = isl_printer_print_str(p, " || ");
1384                 if (set->n > 1)
1385                         p = isl_printer_print_str(p, "(");
1386                 p = print_basic_set_c(p, set->p[i]);
1387                 if (set->n > 1)
1388                         p = isl_printer_print_str(p, ")");
1389         }
1390         return p;
1391 }
1392
1393 static __isl_give isl_printer *print_qpolynomial_c(__isl_take isl_printer *p,
1394         __isl_keep isl_qpolynomial *qp)
1395 {
1396         isl_int den;
1397
1398         isl_int_init(den);
1399         isl_qpolynomial_get_den(qp, &den);
1400         if (!isl_int_is_one(den)) {
1401                 isl_qpolynomial *f;
1402                 p = isl_printer_print_str(p, "(");
1403                 qp = isl_qpolynomial_copy(qp);
1404                 f = isl_qpolynomial_rat_cst(isl_dim_copy(qp->dim),
1405                                                 den, qp->dim->ctx->one);
1406                 qp = isl_qpolynomial_mul(qp, f);
1407         }
1408         if (qp)
1409                 p = upoly_print(qp->upoly, qp->dim, qp->div, p);
1410         if (!isl_int_is_one(den)) {
1411                 p = isl_printer_print_str(p, ")/");
1412                 p = isl_printer_print_isl_int(p, den);
1413                 isl_qpolynomial_free(qp);
1414         }
1415         isl_int_clear(den);
1416         return p;
1417 }
1418
1419 static __isl_give isl_printer *print_pw_qpolynomial_c(
1420         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial *pwpq)
1421 {
1422         int i;
1423
1424         if (pwpq->n == 1 && isl_set_fast_is_universe(pwpq->p[0].set))
1425                 return print_qpolynomial_c(p, pwpq->p[0].qp);
1426
1427         for (i = 0; i < pwpq->n; ++i) {
1428                 p = isl_printer_print_str(p, "(");
1429                 p = print_set_c(p, pwpq->p[i].set);
1430                 p = isl_printer_print_str(p, ") ? (");
1431                 p = print_qpolynomial_c(p, pwpq->p[i].qp);
1432                 p = isl_printer_print_str(p, ") : ");
1433         }
1434
1435         p = isl_printer_print_str(p, "0");
1436         return p;
1437 }
1438
1439 __isl_give isl_printer *isl_printer_print_pw_qpolynomial(
1440         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial *pwqp)
1441 {
1442         if (!p || !pwqp)
1443                 goto error;
1444
1445         if (p->output_format == ISL_FORMAT_ISL)
1446                 return print_pw_qpolynomial_isl(p, pwqp);
1447         else if (p->output_format == ISL_FORMAT_C)
1448                 return print_pw_qpolynomial_c(p, pwqp);
1449         isl_assert(p->ctx, 0, goto error);
1450 error:
1451         isl_printer_free(p);
1452         return NULL;
1453 }
1454
1455 static __isl_give isl_printer *print_qpolynomial_fold_c(
1456         __isl_take isl_printer *p, __isl_keep isl_qpolynomial_fold *fold)
1457 {
1458         int i;
1459
1460         for (i = 0; i < fold->n - 1; ++i)
1461                 if (fold->type == isl_fold_min)
1462                         p = isl_printer_print_str(p, "min(");
1463                 else if (fold->type == isl_fold_max)
1464                         p = isl_printer_print_str(p, "max(");
1465
1466         for (i = 0; i < fold->n; ++i) {
1467                 if (i)
1468                         p = isl_printer_print_str(p, ", ");
1469                 p = print_qpolynomial_c(p, fold->qp[i]);
1470                 if (i)
1471                         p = isl_printer_print_str(p, ")");
1472         }
1473         return p;
1474 }
1475
1476 static __isl_give isl_printer *print_pw_qpolynomial_fold_c(
1477         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial_fold *pwf)
1478 {
1479         int i;
1480
1481         if (pwf->n == 1 && isl_set_fast_is_universe(pwf->p[0].set))
1482                 return print_qpolynomial_fold_c(p, pwf->p[0].fold);
1483
1484         for (i = 0; i < pwf->n; ++i) {
1485                 p = isl_printer_print_str(p, "(");
1486                 p = print_set_c(p, pwf->p[i].set);
1487                 p = isl_printer_print_str(p, ") ? (");
1488                 p = print_qpolynomial_fold_c(p, pwf->p[i].fold);
1489                 p = isl_printer_print_str(p, ") : ");
1490         }
1491
1492         p = isl_printer_print_str(p, "0");
1493         return p;
1494 }
1495
1496 __isl_give isl_printer *isl_printer_print_pw_qpolynomial_fold(
1497         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial_fold *pwf)
1498 {
1499         if (!p || !pwf)
1500                 goto error;
1501
1502         if (p->output_format == ISL_FORMAT_ISL)
1503                 return print_pw_qpolynomial_fold_isl(p, pwf);
1504         else if (p->output_format == ISL_FORMAT_C)
1505                 return print_pw_qpolynomial_fold_c(p, pwf);
1506         isl_assert(p->ctx, 0, goto error);
1507 error:
1508         isl_printer_free(p);
1509         return NULL;
1510 }
1511
1512 void isl_pw_qpolynomial_fold_print(__isl_keep isl_pw_qpolynomial_fold *pwf,
1513         FILE *out, unsigned output_format)
1514 {
1515         isl_printer *p;
1516
1517         if (!pwf)
1518                 return;
1519
1520         p = isl_printer_to_file(pwf->dim->ctx, out);
1521         p = isl_printer_set_output_format(p, output_format);
1522         p = isl_printer_print_pw_qpolynomial_fold(p, pwf);
1523
1524         isl_printer_free(p);
1525 }