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 #include <isl_mat_private.h>
  22 #include <isl_union_map.h>
  23
  24 static const char *s_to[2] = { " -> ", " \\to " };
  25 static const char *s_and[2] = { " and ", " \\wedge " };
  26 static const char *s_or[2] = { " or ", " \\vee " };
  27 static const char *s_le[2] = { "<=", "\\le" };
  28 static const char *s_ge[2] = { ">=", "\\ge" };
  29 static const char *s_open_set[2] = { "{ ", "\\{\\, " };
  30 static const char *s_close_set[2] = { " }", " \\,\\}" };
  31 static const char *s_open_list[2] = { "[", "(" };
  32 static const char *s_close_list[2] = { "]", ")" };
  33 static const char *s_such_that[2] = { " : ", " \\mid " };
  34 static const char *s_open_exists[2] = { "exists (", "\\exists \\, " };
  35 static const char *s_close_exists[2] = { ")", "" };
  36 static const char *s_div_prefix[2] = { "e", "\\alpha_" };
  37 static const char *s_param_prefix[2] = { "p", "p_" };
  38 static const char *s_input_prefix[2] = { "i", "i_" };
  39 static const char *s_output_prefix[2] = { "o", "o_" };
  40
  41 static __isl_give isl_printer *print_constraint_polylib(
  42         struct isl_basic_map *bmap, int ineq, int n, __isl_take isl_printer *p)
  43 {
  44         int i;
  45         unsigned n_in = isl_basic_map_dim(bmap, isl_dim_in);
  46         unsigned n_out = isl_basic_map_dim(bmap, isl_dim_out);
  47         unsigned nparam = isl_basic_map_dim(bmap, isl_dim_param);
  48         isl_int *c = ineq ? bmap->ineq[n] : bmap->eq[n];
  49
  50         p = isl_printer_start_line(p);
  51         p = isl_printer_print_int(p, ineq);
  52         for (i = 0; i < n_out; ++i) {
  53                 p = isl_printer_print_str(p, " ");
  54                 p = isl_printer_print_isl_int(p, c[1+nparam+n_in+i]);
  55         }
  56         for (i = 0; i < n_in; ++i) {
  57                 p = isl_printer_print_str(p, " ");
  58                 p = isl_printer_print_isl_int(p, c[1+nparam+i]);
  59         }
  60         for (i = 0; i < bmap->n_div; ++i) {
  61                 p = isl_printer_print_str(p, " ");
  62                 p = isl_printer_print_isl_int(p, c[1+nparam+n_in+n_out+i]);
  63         }
  64         for (i = 0; i < nparam; ++i) {
  65                 p = isl_printer_print_str(p, " ");
  66                 p = isl_printer_print_isl_int(p, c[1+i]);
  67         }
  68         p = isl_printer_print_str(p, " ");
  69         p = isl_printer_print_isl_int(p, c[0]);
  70         p = isl_printer_end_line(p);
  71         return p;
  72 }
  73
  74 static __isl_give isl_printer *print_constraints_polylib(
  75         struct isl_basic_map *bmap, __isl_take isl_printer *p)
  76 {
  77         int i;
  78
  79         p = isl_printer_set_isl_int_width(p, 5);
  80
  81         for (i = 0; i < bmap->n_eq; ++i)
  82                 p = print_constraint_polylib(bmap, 0, i, p);
  83         for (i = 0; i < bmap->n_ineq; ++i)
  84                 p = print_constraint_polylib(bmap, 1, i, p);
  85
  86         return p;
  87 }
  88
  89 static __isl_give isl_printer *bset_print_constraints_polylib(
  90         struct isl_basic_set *bset, __isl_take isl_printer *p)
  91 {
  92         return print_constraints_polylib((struct isl_basic_map *)bset, p);
  93 }
  94
  95 static __isl_give isl_printer *isl_basic_map_print_polylib(
  96         __isl_keep isl_basic_map *bmap, __isl_take isl_printer *p)
  97 {
  98         unsigned total = isl_basic_map_total_dim(bmap);
  99         p = isl_printer_start_line(p);
 100         p = isl_printer_print_int(p, bmap->n_eq + bmap->n_ineq);
 101         p = isl_printer_print_str(p, " ");
 102         p = isl_printer_print_int(p, 1 + total + 1);
 103         p = isl_printer_end_line(p);
 104         return print_constraints_polylib(bmap, p);
 105 }
 106
 107 static __isl_give isl_printer *isl_basic_set_print_polylib(
 108         __isl_keep isl_basic_set *bset, __isl_take isl_printer *p)
 109 {
 110         return isl_basic_map_print_polylib((struct isl_basic_map *)bset, p);
 111 }
 112
 113 static __isl_give isl_printer *isl_map_print_polylib(__isl_keep isl_map *map,
 114         __isl_take isl_printer *p)
 115 {
 116         int i;
 117
 118         p = isl_printer_start_line(p);
 119         p = isl_printer_print_int(p, map->n);
 120         p = isl_printer_end_line(p);
 121         for (i = 0; i < map->n; ++i) {
 122                 p = isl_printer_start_line(p);
 123                 p = isl_printer_end_line(p);
 124                 p = isl_basic_map_print_polylib(map->p[i], p);
 125         }
 126         return p;
 127 }
 128
 129 static __isl_give isl_printer *isl_set_print_polylib(__isl_keep isl_set *set,
 130         __isl_take isl_printer *p)
 131 {
 132         return isl_map_print_polylib((struct isl_map *)set, p);
 133 }
 134
 135 static int count_same_name(__isl_keep isl_dim *dim,
 136         enum isl_dim_type type, unsigned pos, const char *name)
 137 {
 138         enum isl_dim_type t;
 139         unsigned p, s;
 140         int count = 0;
 141
 142         for (t = isl_dim_param; t <= type && t <= isl_dim_out; ++t) {
 143                 s = t == type ? pos : isl_dim_size(dim, t);
 144                 for (p = 0; p < s; ++p) {
 145                         const char *n = isl_dim_get_name(dim, t, p);
 146                         if (n && !strcmp(n, name))
 147                                 count++;
 148                 }
 149         }
 150         return count;
 151 }
 152
 153 static __isl_give isl_printer *print_name(__isl_keep isl_dim *dim,
 154         __isl_take isl_printer *p, enum isl_dim_type type, unsigned pos,
 155         int set, int latex)
 156 {
 157         const char *name;
 158         char buffer[20];
 159         int primes;
 160
 161         name = type == isl_dim_div ? NULL : isl_dim_get_name(dim, type, pos);
 162
 163         if (!name) {
 164                 const char *prefix;
 165                 if (type == isl_dim_param)
 166                         prefix = s_param_prefix[latex];
 167                 else if (type == isl_dim_div)
 168                         prefix = s_div_prefix[latex];
 169                 else if (set || type == isl_dim_in)
 170                         prefix = s_input_prefix[latex];
 171                 else
 172                         prefix = s_output_prefix[latex];
 173                 snprintf(buffer, sizeof(buffer), "%s%d", prefix, pos);
 174                 name = buffer;
 175         }
 176         primes = count_same_name(dim, name == buffer ? isl_dim_div : type,
 177                                  pos, name);
 178         p = isl_printer_print_str(p, name);
 179         while (primes-- > 0)
 180                 p = isl_printer_print_str(p, "'");
 181         return p;
 182 }
 183
 184 static enum isl_dim_type pos2type(__isl_keep isl_dim *dim, unsigned *pos)
 185 {
 186         enum isl_dim_type type;
 187         unsigned n_in = isl_dim_size(dim, isl_dim_in);
 188         unsigned n_out = isl_dim_size(dim, isl_dim_out);
 189         unsigned nparam = isl_dim_size(dim, isl_dim_param);
 190
 191         if (*pos < 1 + nparam) {
 192                 type = isl_dim_param;
 193                 *pos -= 1;
 194         } else if (*pos < 1 + nparam + n_in) {
 195                 type = isl_dim_in;
 196                 *pos -= 1 + nparam;
 197         } else if (*pos < 1 + nparam + n_in + n_out) {
 198                 type = isl_dim_out;
 199                 *pos -= 1 + nparam + n_in;
 200         } else {
 201                 type = isl_dim_div;
 202                 *pos -= 1 + nparam + n_in + n_out;
 203         }
 204
 205         return type;
 206 }
 207
 208 static __isl_give isl_printer *print_term(__isl_keep isl_dim *dim,
 209         isl_int c, unsigned pos, __isl_take isl_printer *p, int set, int latex)
 210 {
 211         enum isl_dim_type type;
 212
 213         if (pos == 0)
 214                 return isl_printer_print_isl_int(p, c);
 215
 216         if (isl_int_is_one(c))
 217                 ;
 218         else if (isl_int_is_negone(c))
 219                 p = isl_printer_print_str(p, "-");
 220         else
 221                 p = isl_printer_print_isl_int(p, c);
 222         type = pos2type(dim, &pos);
 223         p = print_name(dim, p, type, pos, set, latex);
 224         return p;
 225 }
 226
 227 static __isl_give isl_printer *print_affine_of_len(__isl_keep isl_dim *dim,
 228         __isl_take isl_printer *p, isl_int *c, int len, int set)
 229 {
 230         int i;
 231         int first;
 232
 233         for (i = 0, first = 1; i < len; ++i) {
 234                 int flip = 0;
 235                 if (isl_int_is_zero(c[i]))
 236                         continue;
 237                 if (!first) {
 238                         if (isl_int_is_neg(c[i])) {
 239                                 flip = 1;
 240                                 isl_int_neg(c[i], c[i]);
 241                                 p = isl_printer_print_str(p, " - ");
 242                         } else
 243                                 p = isl_printer_print_str(p, " + ");
 244                 }
 245                 first = 0;
 246                 p = print_term(dim, c[i], i, p, set, 0);
 247                 if (flip)
 248                         isl_int_neg(c[i], c[i]);
 249         }
 250         if (first)
 251                 p = isl_printer_print_str(p, "0");
 252         return p;
 253 }
 254
 255 static __isl_give isl_printer *print_affine(__isl_keep isl_basic_map *bmap,
 256         __isl_keep isl_dim *dim, __isl_take isl_printer *p, isl_int *c, int set)
 257 {
 258         unsigned len = 1 + isl_basic_map_total_dim(bmap);
 259         return print_affine_of_len(dim, p, c, len, set);
 260 }
 261
 262 static int defining_equality(__isl_keep isl_basic_map *eq,
 263         __isl_keep isl_dim *dim, enum isl_dim_type type, int pos)
 264 {
 265         int i;
 266         unsigned total;
 267
 268         if (!eq)
 269                 return -1;
 270
 271         pos += isl_dim_offset(dim, type);
 272         total = isl_basic_map_total_dim(eq);
 273
 274         for (i = 0; i < eq->n_eq; ++i) {
 275                 if (isl_seq_last_non_zero(eq->eq[i] + 1, total) != pos)
 276                         continue;
 277                 if (isl_int_is_one(eq->eq[i][1 + pos]))
 278                         isl_seq_neg(eq->eq[i], eq->eq[i], 1 + total);
 279                 return i;
 280         }
 281
 282         return -1;
 283 }
 284
 285 /* offset is the offset of local_dim inside global_type of global_dim.
 286  */
 287 static __isl_give isl_printer *print_nested_var_list(__isl_take isl_printer *p,
 288         __isl_keep isl_dim *global_dim, enum isl_dim_type global_type,
 289         __isl_keep isl_dim *local_dim, enum isl_dim_type local_type,
 290         int set, int latex, __isl_keep isl_basic_map *eq, int offset)
 291 {
 292         int i, j;
 293
 294         if (global_dim != local_dim && local_type == isl_dim_out)
 295                 offset += local_dim->n_in;
 296
 297         for (i = 0; i < isl_dim_size(local_dim, local_type); ++i) {
 298                 if (i)
 299                         p = isl_printer_print_str(p, ", ");
 300                 j = defining_equality(eq, global_dim, global_type, offset + i);
 301                 if (j >= 0) {
 302                         int pos = 1 + isl_dim_offset(global_dim, global_type)
 303                                     + offset + i;
 304                         p = print_affine_of_len(eq->dim, p, eq->eq[j], pos, set);
 305                 } else {
 306                         p = print_name(global_dim, p, global_type, offset + i,
 307                                         set, latex);
 308                 }
 309         }
 310         return p;
 311 }
 312
 313 static __isl_give isl_printer *print_var_list(__isl_keep isl_dim *dim,
 314         __isl_take isl_printer *p, enum isl_dim_type type,
 315         int set, int latex, __isl_keep isl_basic_map *eq)
 316 {
 317         return print_nested_var_list(p, dim, type, dim, type, set, latex, eq, 0);
 318 }
 319
 320 static __isl_give isl_printer *print_nested_map_dim(__isl_take isl_printer *p,
 321         __isl_keep isl_dim *global_dim, enum isl_dim_type global_type,
 322         __isl_keep isl_dim *local_dim,
 323          int set, int latex, __isl_keep isl_basic_map *eq, int offset);
 324
 325 static __isl_give isl_printer *print_nested_tuple(__isl_take isl_printer *p,
 326         __isl_keep isl_dim *global_dim, enum isl_dim_type global_type,
 327         __isl_keep isl_dim *local_dim, enum isl_dim_type local_type,
 328         int set, int latex, __isl_keep isl_basic_map *eq, int offset)
 329 {
 330         const char *name = NULL;
 331         unsigned n = isl_dim_size(local_dim, local_type);
 332         if ((local_type == isl_dim_in || local_type == isl_dim_out)) {
 333                 name = isl_dim_get_tuple_name(local_dim, local_type);
 334                 if (name) {
 335                         if (latex)
 336                                 p = isl_printer_print_str(p, "\\mathrm{");
 337                         p = isl_printer_print_str(p, name);
 338                         if (latex)
 339                                 p = isl_printer_print_str(p, "}");
 340                 }
 341         }
 342         if (!latex || n != 1 || name)
 343                 p = isl_printer_print_str(p, s_open_list[latex]);
 344         if ((local_type == isl_dim_in || local_type == isl_dim_out) &&
 345             local_dim->nested[local_type - isl_dim_in]) {
 346                 if (global_dim != local_dim && local_type == isl_dim_out)
 347                         offset += local_dim->n_in;
 348                 p = print_nested_map_dim(p, global_dim, global_type,
 349                                 local_dim->nested[local_type - isl_dim_in],
 350                                 set, latex, eq, offset);
 351         } else
 352                 p = print_nested_var_list(p, global_dim, global_type,
 353                                  local_dim, local_type, set, latex, eq, offset);
 354         if (!latex || n != 1 || name)
 355                 p = isl_printer_print_str(p, s_close_list[latex]);
 356         return p;
 357 }
 358
 359 static __isl_give isl_printer *print_tuple(__isl_keep isl_dim *dim,
 360         __isl_take isl_printer *p, enum isl_dim_type type,
 361         int set, int latex, __isl_keep isl_basic_map *eq)
 362 {
 363         return print_nested_tuple(p, dim, type, dim, type, set, latex, eq, 0);
 364 }
 365
 366 static __isl_give isl_printer *print_nested_map_dim(__isl_take isl_printer *p,
 367         __isl_keep isl_dim *global_dim, enum isl_dim_type global_type,
 368         __isl_keep isl_dim *local_dim,
 369          int set, int latex, __isl_keep isl_basic_map *eq, int offset)
 370 {
 371         p = print_nested_tuple(p, global_dim, global_type,
 372                         local_dim, isl_dim_in, set, latex, eq, offset);
 373         p = isl_printer_print_str(p, s_to[latex]);
 374         p = print_nested_tuple(p, global_dim, global_type,
 375                         local_dim, isl_dim_out, set, latex, eq, offset);
 376
 377         return p;
 378 }
 379
 380 static __isl_give isl_printer *print_dim(__isl_keep isl_dim *dim,
 381         __isl_take isl_printer *p, int set, int latex,
 382         __isl_keep isl_basic_map *eq)
 383 {
 384         if (set)
 385                 p = print_tuple(dim, p, isl_dim_set, 1, latex, eq);
 386         else {
 387                 p = print_tuple(dim, p, isl_dim_in, 0, latex, eq);
 388                 p = isl_printer_print_str(p, s_to[latex]);
 389                 p = print_tuple(dim, p, isl_dim_out, 0, latex, eq);
 390         }
 391
 392         return p;
 393 }
 394
 395 static __isl_give isl_printer *print_omega_parameters(__isl_keep isl_dim *dim,
 396         __isl_take isl_printer *p)
 397 {
 398         if (isl_dim_size(dim, isl_dim_param) == 0)
 399                 return p;
 400
 401         p = isl_printer_start_line(p);
 402         p = isl_printer_print_str(p, "symbolic ");
 403         p = print_var_list(dim, p, isl_dim_param, 0, 0, NULL);
 404         p = isl_printer_print_str(p, ";");
 405         p = isl_printer_end_line(p);
 406         return p;
 407 }
 408
 409 static __isl_give isl_printer *print_constraint(struct isl_basic_map *bmap,
 410         __isl_keep isl_dim *dim, __isl_take isl_printer *p,
 411         isl_int *c, int last, const char *op, int first_constraint, int set,
 412         int latex)
 413 {
 414         if (!first_constraint)
 415                 p = isl_printer_print_str(p, s_and[latex]);
 416
 417         isl_int_abs(c[last], c[last]);
 418
 419         p = print_term(dim, c[last], last, p, set, latex);
 420
 421         p = isl_printer_print_str(p, " ");
 422         p = isl_printer_print_str(p, op);
 423         p = isl_printer_print_str(p, " ");
 424
 425         isl_int_set_si(c[last], 0);
 426         p = print_affine(bmap, dim, p, c, set);
 427
 428         return p;
 429 }
 430
 431 static __isl_give isl_printer *print_constraints(__isl_keep isl_basic_map *bmap,
 432         __isl_keep isl_dim *dim, __isl_take isl_printer *p, int set, int latex)
 433 {
 434         int i;
 435         struct isl_vec *c;
 436         unsigned total = isl_basic_map_total_dim(bmap);
 437
 438         c = isl_vec_alloc(bmap->ctx, 1 + total);
 439         if (!c)
 440                 goto error;
 441
 442         for (i = bmap->n_eq - 1; i >= 0; --i) {
 443                 int l = isl_seq_last_non_zero(bmap->eq[i], 1 + total);
 444                 isl_assert(bmap->ctx, l >= 0, goto error);
 445                 if (isl_int_is_neg(bmap->eq[i][l]))
 446                         isl_seq_cpy(c->el, bmap->eq[i], 1 + total);
 447                 else
 448                         isl_seq_neg(c->el, bmap->eq[i], 1 + total);
 449                 p = print_constraint(bmap, dim, p, c->el, l,
 450                                     "=", i == bmap->n_eq - 1, set, latex);
 451         }
 452         for (i = 0; i < bmap->n_ineq; ++i) {
 453                 int l = isl_seq_last_non_zero(bmap->ineq[i], 1 + total);
 454                 int s;
 455                 const char *op;
 456                 if (l < 0)
 457                         continue;
 458                 s = isl_int_sgn(bmap->ineq[i][l]);
 459                 if (s < 0)
 460                         isl_seq_cpy(c->el, bmap->ineq[i], 1 + total);
 461                 else
 462                         isl_seq_neg(c->el, bmap->ineq[i], 1 + total);
 463                 op = s < 0 ? s_le[latex] : s_ge[latex];
 464                 p = print_constraint(bmap, dim, p, c->el, l,
 465                                         op, !bmap->n_eq && !i, set, latex);
 466         }
 467
 468         isl_vec_free(c);
 469
 470         return p;
 471 error:
 472         isl_printer_free(p);
 473         return NULL;
 474 }
 475
 476 static __isl_give isl_printer *print_omega_constraints(
 477         __isl_keep isl_basic_map *bmap, __isl_take isl_printer *p, int set)
 478 {
 479         if (bmap->n_eq + bmap->n_ineq == 0)
 480                 return p;
 481
 482         p = isl_printer_print_str(p, ": ");
 483         if (bmap->n_div > 0) {
 484                 int i;
 485                 p = isl_printer_print_str(p, "exists (");
 486                 for (i = 0; i < bmap->n_div; ++i) {
 487                         if (i)
 488                                 p = isl_printer_print_str(p, ", ");
 489                         p = print_name(bmap->dim, p, isl_dim_div, i, 0, 0);
 490                 }
 491                 p = isl_printer_print_str(p, ": ");
 492         }
 493         p = print_constraints(bmap, bmap->dim, p, set, 0);
 494         if (bmap->n_div > 0)
 495                 p = isl_printer_print_str(p, ")");
 496         return p;
 497 }
 498
 499 static __isl_give isl_printer *basic_map_print_omega(
 500         __isl_keep isl_basic_map *bmap, __isl_take isl_printer *p)
 501 {
 502         p = isl_printer_print_str(p, "{ [");
 503         p = print_var_list(bmap->dim, p, isl_dim_in, 0, 0, NULL);
 504         p = isl_printer_print_str(p, "] -> [");
 505         p = print_var_list(bmap->dim, p, isl_dim_out, 0, 0, NULL);
 506         p = isl_printer_print_str(p, "] ");
 507         p = print_omega_constraints(bmap, p, 0);
 508         p = isl_printer_print_str(p, " }");
 509         return p;
 510 }
 511
 512 static __isl_give isl_printer *isl_basic_map_print_omega(
 513         __isl_keep isl_basic_map *bmap, __isl_take isl_printer *p)
 514 {
 515         p = print_omega_parameters(bmap->dim, p);
 516
 517         p = isl_printer_start_line(p);
 518         p = basic_map_print_omega(bmap, p);
 519         p = isl_printer_end_line(p);
 520         return p;
 521 }
 522
 523 static __isl_give isl_printer *basic_set_print_omega(
 524         __isl_keep isl_basic_set *bset, __isl_take isl_printer *p)
 525 {
 526         p = isl_printer_print_str(p, "{ [");
 527         p = print_var_list(bset->dim, p, isl_dim_set, 1, 0, NULL);
 528         p = isl_printer_print_str(p, "] ");
 529         p = print_omega_constraints((isl_basic_map *)bset, p, 1);
 530         p = isl_printer_print_str(p, " }");
 531         return p;
 532 }
 533
 534 static __isl_give isl_printer *isl_basic_set_print_omega(
 535         __isl_keep isl_basic_set *bset, __isl_take isl_printer *p)
 536 {
 537         p = print_omega_parameters(bset->dim, p);
 538
 539         p = isl_printer_start_line(p);
 540         p = basic_set_print_omega(bset, p);
 541         p = isl_printer_end_line(p);
 542         return p;
 543 }
 544
 545 static __isl_give isl_printer *isl_map_print_omega(__isl_keep isl_map *map,
 546         __isl_take isl_printer *p)
 547 {
 548         int i;
 549
 550         p = print_omega_parameters(map->dim, p);
 551
 552         p = isl_printer_start_line(p);
 553         for (i = 0; i < map->n; ++i) {
 554                 if (i)
 555                         p = isl_printer_print_str(p, " union ");
 556                 p = basic_map_print_omega(map->p[i], p);
 557         }
 558         p = isl_printer_end_line(p);
 559         return p;
 560 }
 561
 562 static __isl_give isl_printer *isl_set_print_omega(__isl_keep isl_set *set,
 563         __isl_take isl_printer *p)
 564 {
 565         int i;
 566
 567         p = print_omega_parameters(set->dim, p);
 568
 569         p = isl_printer_start_line(p);
 570         for (i = 0; i < set->n; ++i) {
 571                 if (i)
 572                         p = isl_printer_print_str(p, " union ");
 573                 p = basic_set_print_omega(set->p[i], p);
 574         }
 575         p = isl_printer_end_line(p);
 576         return p;
 577 }
 578
 579 static __isl_give isl_printer *print_disjunct(__isl_keep isl_basic_map *bmap,
 580         __isl_keep isl_dim *dim, __isl_take isl_printer *p, int set, int latex)
 581 {
 582         if (bmap->n_div > 0) {
 583                 int i;
 584                 p = isl_printer_print_str(p, s_open_exists[latex]);
 585                 for (i = 0; i < bmap->n_div; ++i) {
 586                         if (i)
 587                                 p = isl_printer_print_str(p, ", ");
 588                         p = print_name(dim, p, isl_dim_div, i, 0, latex);
 589                         if (latex || isl_int_is_zero(bmap->div[i][0]))
 590                                 continue;
 591                         p = isl_printer_print_str(p, " = [(");
 592                         p = print_affine(bmap, dim, p, bmap->div[i] + 1, set);
 593                         p = isl_printer_print_str(p, ")/");
 594                         p = isl_printer_print_isl_int(p, bmap->div[i][0]);
 595                         p = isl_printer_print_str(p, "]");
 596                 }
 597                 p = isl_printer_print_str(p, ": ");
 598         }
 599
 600         p = print_constraints(bmap, dim, p, set, latex);
 601
 602         if (bmap->n_div > 0)
 603                 p = isl_printer_print_str(p, s_close_exists[latex]);
 604         return p;
 605 }
 606
 607 static __isl_give isl_printer *isl_basic_map_print_isl(
 608         __isl_keep isl_basic_map *bmap, __isl_take isl_printer *p, int latex)
 609 {
 610         int i;
 611
 612         p = isl_printer_start_line(p);
 613         if (isl_basic_map_dim(bmap, isl_dim_param) > 0) {
 614                 p = print_tuple(bmap->dim, p, isl_dim_param, 0, latex, NULL);
 615                 p = isl_printer_print_str(p, " -> ");
 616         }
 617         p = isl_printer_print_str(p, "{ ");
 618         p = print_dim(bmap->dim, p, 0, latex, NULL);
 619         p = isl_printer_print_str(p, " : ");
 620         p = print_disjunct(bmap, bmap->dim, p, 0, latex);
 621         p = isl_printer_print_str(p, " }");
 622         p = isl_printer_end_line(p);
 623         return p;
 624 }
 625
 626 static __isl_give isl_printer *isl_basic_set_print_isl(
 627         __isl_keep isl_basic_set *bset, __isl_take isl_printer *p, int latex)
 628 {
 629         int i;
 630
 631         p = isl_printer_start_line(p);
 632         if (isl_basic_set_dim(bset, isl_dim_param) > 0) {
 633                 p = print_tuple(bset->dim, p, isl_dim_param, 0, latex, NULL);
 634                 p = isl_printer_print_str(p, " -> ");
 635         }
 636         p = isl_printer_print_str(p, "{ ");
 637         p = print_dim(bset->dim, p, 1, latex, NULL);
 638         p = isl_printer_print_str(p, " : ");
 639         p = print_disjunct((isl_basic_map *)bset, bset->dim, p, 1, latex);
 640         p = isl_printer_print_str(p, " }");
 641         p = isl_printer_end_line(p);
 642         return p;
 643 }
 644
 645 static __isl_give isl_printer *print_disjuncts(__isl_keep isl_map *map,
 646         __isl_take isl_printer *p, int set, int latex)
 647 {
 648         int i;
 649
 650         if (isl_map_fast_is_universe(map))
 651                 return p;
 652
 653         p = isl_printer_print_str(p, s_such_that[latex]);
 654         if (map->n == 0)
 655                 p = isl_printer_print_str(p, "1 = 0");
 656         for (i = 0; i < map->n; ++i) {
 657                 if (i)
 658                         p = isl_printer_print_str(p, s_or[latex]);
 659                 if (map->n > 1 && map->p[i]->n_eq + map->p[i]->n_ineq > 1)
 660                         p = isl_printer_print_str(p, "(");
 661                 p = print_disjunct(map->p[i], map->dim, p, set, latex);
 662                 if (map->n > 1 && map->p[i]->n_eq + map->p[i]->n_ineq > 1)
 663                         p = isl_printer_print_str(p, ")");
 664         }
 665         return p;
 666 }
 667
 668 struct isl_aff_split {
 669         isl_basic_map *aff;
 670         isl_map *map;
 671 };
 672
 673 static void free_split(__isl_take struct isl_aff_split *split, int n)
 674 {
 675         int i;
 676
 677         if (!split)
 678                 return;
 679
 680         for (i = 0; i < n; ++i) {
 681                 isl_basic_map_free(split[i].aff);
 682                 isl_map_free(split[i].map);
 683         }
 684
 685         free(split);
 686 }
 687
 688 static __isl_give isl_basic_map *get_aff(__isl_take isl_basic_map *bmap)
 689 {
 690         int i, j;
 691         unsigned nparam, n_in, n_out, total;
 692
 693         bmap = isl_basic_map_cow(bmap);
 694         if (!bmap)
 695                 return NULL;
 696         if (isl_basic_map_free_inequality(bmap, bmap->n_ineq) < 0)
 697                 goto error;
 698
 699         nparam = isl_basic_map_dim(bmap, isl_dim_param);
 700         n_in = isl_basic_map_dim(bmap, isl_dim_in);
 701         n_out = isl_basic_map_dim(bmap, isl_dim_out);
 702         total = isl_basic_map_dim(bmap, isl_dim_all);
 703         for (i = bmap->n_eq - 1; i >= 0; --i) {
 704                 j = isl_seq_last_non_zero(bmap->eq[i] + 1, total);
 705                 if (j >= nparam && j < nparam + n_in + n_out &&
 706                     (isl_int_is_one(bmap->eq[i][1 + j]) ||
 707                      isl_int_is_negone(bmap->eq[i][1 + j])))
 708                         continue;
 709                 if (isl_basic_map_drop_equality(bmap, i) < 0)
 710                         goto error;
 711         }
 712
 713         bmap = isl_basic_map_finalize(bmap);
 714
 715         return bmap;
 716 error:
 717         isl_basic_map_free(bmap);
 718         return NULL;
 719 }
 720
 721 static int aff_split_cmp(const void *p1, const void *p2)
 722 {
 723         const struct isl_aff_split *s1, *s2;
 724         s1 = (const struct isl_aff_split *) p1;
 725         s2 = (const struct isl_aff_split *) p2;
 726
 727         return isl_basic_map_fast_cmp(s1->aff, s2->aff);
 728 }
 729
 730 static __isl_give isl_basic_map *drop_aff(__isl_take isl_basic_map *bmap,
 731         __isl_keep isl_basic_map *aff)
 732 {
 733         int i, j;
 734         unsigned total;
 735
 736         if (!bmap || !aff)
 737                 goto error;
 738
 739         total = isl_dim_total(bmap->dim);
 740
 741         for (i = bmap->n_eq - 1; i >= 0; --i) {
 742                 if (isl_seq_first_non_zero(bmap->eq[i] + 1 + total,
 743                                             bmap->n_div) != -1)
 744                         continue;
 745                 for (j = 0; j < aff->n_eq; ++j) {
 746                         if (!isl_seq_eq(bmap->eq[i], aff->eq[j], 1 + total) &&
 747                             !isl_seq_is_neg(bmap->eq[i], aff->eq[j], 1 + total))
 748                                 continue;
 749                         if (isl_basic_map_drop_equality(bmap, i) < 0)
 750                                 goto error;
 751                         break;
 752                 }
 753         }
 754
 755         return bmap;
 756 error:
 757         isl_basic_map_free(bmap);
 758         return NULL;
 759 }
 760
 761 static __isl_give struct isl_aff_split *split_aff(__isl_keep isl_map *map)
 762 {
 763         int i, n;
 764         struct isl_aff_split *split;
 765
 766         split = isl_calloc_array(map->isl, struct isl_aff_split, map->n);
 767         if (!split)
 768                 return NULL;
 769
 770         for (i = 0; i < map->n; ++i) {
 771                 isl_basic_map *bmap;
 772                 split[i].aff = get_aff(isl_basic_map_copy(map->p[i]));
 773                 bmap = isl_basic_map_copy(map->p[i]);
 774                 bmap = isl_basic_map_cow(bmap);
 775                 bmap = drop_aff(bmap, split[i].aff);
 776                 split[i].map = isl_map_from_basic_map(bmap);
 777                 if (!split[i].aff || !split[i].map)
 778                         goto error;
 779         }
 780
 781         qsort(split, map->n, sizeof(struct isl_aff_split), &aff_split_cmp);
 782
 783         n = map->n;
 784         for (i = n - 1; i >= 1; --i) {
 785                 if (!isl_basic_map_fast_is_equal(split[i - 1].aff,
 786                                                  split[i].aff))
 787                         continue;
 788                 isl_basic_map_free(split[i].aff);
 789                 split[i - 1].map = isl_map_union(split[i - 1].map,
 790                                                  split[i].map);
 791                 if (i != n - 1)
 792                         split[i] = split[n - 1];
 793                 split[n - 1].aff = NULL;
 794                 split[n - 1].map = NULL;
 795                 --n;
 796         }
 797
 798         return split;
 799 error:
 800         free_split(split, map->n);
 801         return NULL;
 802 }
 803
 804 static __isl_give isl_printer *print_split_map(__isl_take isl_printer *p,
 805         struct isl_aff_split *split, int n, int set)
 806 {
 807         int i;
 808
 809         for (i = 0; i < n; ++i) {
 810                 isl_dim *dim;
 811
 812                 if (!split[i].map)
 813                         break;
 814                 dim = split[i].map->dim;
 815                 if (i)
 816                         p = isl_printer_print_str(p, "; ");
 817                 p = print_dim(dim, p, set, 0, split[i].aff);
 818                 p = print_disjuncts(split[i].map, p, set, 0);
 819         }
 820
 821         return p;
 822 }
 823
 824 static __isl_give isl_printer *isl_map_print_isl_body(__isl_keep isl_map *map,
 825         __isl_take isl_printer *p, int set)
 826 {
 827         struct isl_aff_split *split = NULL;
 828
 829         if (map->n > 0)
 830                 split = split_aff(map);
 831         if (split) {
 832                 p = print_split_map(p, split, map->n, set);
 833         } else {
 834                 p = print_dim(map->dim, p, set, 0, NULL);
 835                 p = print_disjuncts(map, p, set, 0);
 836         }
 837         free_split(split, map->n);
 838         return p;
 839 }
 840
 841 static __isl_give isl_printer *isl_map_print_isl(__isl_keep isl_map *map,
 842         __isl_take isl_printer *p, int set)
 843 {
 844         if (isl_map_dim(map, isl_dim_param) > 0) {
 845                 p = print_tuple(map->dim, p, isl_dim_param, set, 0, NULL);
 846                 p = isl_printer_print_str(p, s_to[0]);
 847         }
 848         p = isl_printer_print_str(p, s_open_set[0]);
 849         p = isl_map_print_isl_body(map, p, set);
 850         p = isl_printer_print_str(p, s_close_set[0]);
 851         return p;
 852 }
 853
 854 static __isl_give isl_printer *print_latex_map(__isl_keep isl_map *map,
 855         __isl_take isl_printer *p, __isl_keep isl_basic_map *aff, int set)
 856 {
 857         if (isl_map_dim(map, isl_dim_param) > 0) {
 858                 p = print_tuple(map->dim, p, isl_dim_param, set, 1, NULL);
 859                 p = isl_printer_print_str(p, s_to[1]);
 860         }
 861         p = isl_printer_print_str(p, s_open_set[1]);
 862         p = print_dim(map->dim, p, set, 1, aff);
 863         p = print_disjuncts(map, p, set, 1);
 864         p = isl_printer_print_str(p, s_close_set[1]);
 865
 866         return p;
 867 }
 868
 869 static __isl_give isl_printer *isl_map_print_latex(__isl_keep isl_map *map,
 870         __isl_take isl_printer *p, int set)
 871 {
 872         int i;
 873         struct isl_aff_split *split = NULL;
 874
 875         if (map->n > 0)
 876                 split = split_aff(map);
 877
 878         if (!split)
 879                 return print_latex_map(map, p, NULL, set);
 880
 881         for (i = 0; i < map->n; ++i) {
 882                 if (!split[i].map)
 883                         break;
 884                 if (i)
 885                         p = isl_printer_print_str(p, " \\cup ");
 886                 p = print_latex_map(split[i].map, p, split[i].aff, set);
 887         }
 888
 889         free_split(split, map->n);
 890         return p;
 891 }
 892
 893 __isl_give isl_printer *isl_printer_print_basic_map(__isl_take isl_printer *p,
 894         __isl_keep isl_basic_map *bmap)
 895 {
 896         if (!p || !bmap)
 897                 goto error;
 898         if (p->output_format == ISL_FORMAT_ISL)
 899                 return isl_basic_map_print_isl(bmap, p, 0);
 900         else if (p->output_format == ISL_FORMAT_OMEGA)
 901                 return isl_basic_map_print_omega(bmap, p);
 902         isl_assert(bmap->ctx, 0, goto error);
 903 error:
 904         isl_printer_free(p);
 905         return NULL;
 906 }
 907
 908 void isl_basic_map_print(__isl_keep isl_basic_map *bmap, FILE *out, int indent,
 909         const char *prefix, const char *suffix, unsigned output_format)
 910 {
 911         isl_printer *printer;
 912
 913         if (!bmap)
 914                 return;
 915
 916         printer = isl_printer_to_file(bmap->ctx, out);
 917         printer = isl_printer_set_indent(printer, indent);
 918         printer = isl_printer_set_prefix(printer, prefix);
 919         printer = isl_printer_set_suffix(printer, suffix);
 920         printer = isl_printer_set_output_format(printer, output_format);
 921         isl_printer_print_basic_map(printer, bmap);
 922
 923         isl_printer_free(printer);
 924 }
 925
 926 __isl_give isl_printer *isl_printer_print_basic_set(__isl_take isl_printer *p,
 927         __isl_keep isl_basic_set *bset)
 928 {
 929         if (!p || !bset)
 930                 goto error;
 931
 932         if (p->output_format == ISL_FORMAT_ISL)
 933                 return isl_basic_set_print_isl(bset, p, 0);
 934         else if (p->output_format == ISL_FORMAT_POLYLIB)
 935                 return isl_basic_set_print_polylib(bset, p);
 936         else if (p->output_format == ISL_FORMAT_POLYLIB_CONSTRAINTS)
 937                 return bset_print_constraints_polylib(bset, p);
 938         else if (p->output_format == ISL_FORMAT_OMEGA)
 939                 return isl_basic_set_print_omega(bset, p);
 940         isl_assert(p->ctx, 0, goto error);
 941 error:
 942         isl_printer_free(p);
 943         return NULL;
 944 }
 945
 946 void isl_basic_set_print(struct isl_basic_set *bset, FILE *out, int indent,
 947         const char *prefix, const char *suffix, unsigned output_format)
 948 {
 949         isl_printer *printer;
 950
 951         if (!bset)
 952                 return;
 953
 954         printer = isl_printer_to_file(bset->ctx, out);
 955         printer = isl_printer_set_indent(printer, indent);
 956         printer = isl_printer_set_prefix(printer, prefix);
 957         printer = isl_printer_set_suffix(printer, suffix);
 958         printer = isl_printer_set_output_format(printer, output_format);
 959         isl_printer_print_basic_set(printer, bset);
 960
 961         isl_printer_free(printer);
 962 }
 963
 964 __isl_give isl_printer *isl_printer_print_set(__isl_take isl_printer *p,
 965         __isl_keep isl_set *set)
 966 {
 967         if (!p || !set)
 968                 goto error;
 969         if (p->output_format == ISL_FORMAT_ISL)
 970                 return isl_map_print_isl((isl_map *)set, p, 1);
 971         else if (p->output_format == ISL_FORMAT_POLYLIB)
 972                 return isl_set_print_polylib(set, p);
 973         else if (p->output_format == ISL_FORMAT_OMEGA)
 974                 return isl_set_print_omega(set, p);
 975         else if (p->output_format == ISL_FORMAT_LATEX)
 976                 return isl_map_print_latex((isl_map *)set, p, 1);
 977         isl_assert(set->ctx, 0, goto error);
 978 error:
 979         isl_printer_free(p);
 980         return NULL;
 981 }
 982
 983 void isl_set_print(struct isl_set *set, FILE *out, int indent,
 984         unsigned output_format)
 985 {
 986         isl_printer *printer;
 987
 988         if (!set)
 989                 return;
 990
 991         printer = isl_printer_to_file(set->ctx, out);
 992         printer = isl_printer_set_indent(printer, indent);
 993         printer = isl_printer_set_output_format(printer, output_format);
 994         printer = isl_printer_print_set(printer, set);
 995
 996         isl_printer_free(printer);
 997 }
 998
 999 __isl_give isl_printer *isl_printer_print_map(__isl_take isl_printer *p,
1000         __isl_keep isl_map *map)
1001 {
1002         if (!p || !map)
1003                 goto error;
1004
1005         if (p->output_format == ISL_FORMAT_ISL)
1006                 return isl_map_print_isl(map, p, 0);
1007         else if (p->output_format == ISL_FORMAT_POLYLIB)
1008                 return isl_map_print_polylib(map, p);
1009         else if (p->output_format == ISL_FORMAT_OMEGA)
1010                 return isl_map_print_omega(map, p);
1011         else if (p->output_format == ISL_FORMAT_LATEX)
1012                 return isl_map_print_latex(map, p, 0);
1013         isl_assert(map->ctx, 0, goto error);
1014 error:
1015         isl_printer_free(p);
1016         return NULL;
1017 }
1018
1019 struct isl_union_print_data {
1020         isl_printer *p;
1021         int set;
1022         int first;
1023 };
1024
1025 static int print_map_body(__isl_take isl_map *map, void *user)
1026 {
1027         struct isl_union_print_data *data;
1028         data = (struct isl_union_print_data *)user;
1029
1030         if (!data->first)
1031                 data->p = isl_printer_print_str(data->p, "; ");
1032         data->first = 0;
1033
1034         data->p = isl_map_print_isl_body(map, data->p, data->set);
1035         isl_map_free(map);
1036
1037         return 0;
1038 }
1039
1040 static __isl_give isl_printer *isl_union_map_print_isl(
1041         __isl_keep isl_union_map *umap, __isl_take isl_printer *p, int set)
1042 {
1043         struct isl_union_print_data data = { p, set, 1 };
1044         isl_dim *dim;
1045         dim = isl_union_map_get_dim(umap);
1046         if (isl_dim_size(dim, isl_dim_param) > 0) {
1047                 p = print_tuple(dim, p, isl_dim_param, set, 0, NULL);
1048                 p = isl_printer_print_str(p, s_to[0]);
1049         }
1050         isl_dim_free(dim);
1051         p = isl_printer_print_str(p, s_open_set[0]);
1052         isl_union_map_foreach_map(umap, &print_map_body, &data);
1053         p = data.p;
1054         p = isl_printer_print_str(p, s_close_set[0]);
1055         return p;
1056 }
1057
1058 static int print_latex_map_body(__isl_take isl_map *map, void *user)
1059 {
1060         struct isl_union_print_data *data;
1061         data = (struct isl_union_print_data *)user;
1062
1063         if (!data->first)
1064                 data->p = isl_printer_print_str(data->p, " \\cup ");
1065         data->first = 0;
1066
1067         data->p = isl_map_print_latex(map, data->p, data->set);
1068         isl_map_free(map);
1069
1070         return 0;
1071 }
1072
1073 static __isl_give isl_printer *isl_union_map_print_latex(
1074         __isl_keep isl_union_map *umap, __isl_take isl_printer *p, int set)
1075 {
1076         struct isl_union_print_data data = { p, set, 1 };
1077         isl_union_map_foreach_map(umap, &print_latex_map_body, &data);
1078         p = data.p;
1079         return p;
1080 }
1081
1082 __isl_give isl_printer *isl_printer_print_union_map(__isl_take isl_printer *p,
1083         __isl_keep isl_union_map *umap)
1084 {
1085         if (!p || !umap)
1086                 goto error;
1087
1088         if (p->output_format == ISL_FORMAT_ISL)
1089                 return isl_union_map_print_isl(umap, p, 0);
1090         if (p->output_format == ISL_FORMAT_LATEX)
1091                 return isl_union_map_print_latex(umap, p, 0);
1092
1093         isl_die(p->ctx, isl_error_invalid,
1094                 "invalid output format for isl_union_map", goto error);
1095 error:
1096         isl_printer_free(p);
1097         return NULL;
1098 }
1099
1100 __isl_give isl_printer *isl_printer_print_union_set(__isl_take isl_printer *p,
1101         __isl_keep isl_union_set *uset)
1102 {
1103         if (!p || !uset)
1104                 goto error;
1105
1106         if (p->output_format == ISL_FORMAT_ISL)
1107                 return isl_union_map_print_isl((isl_union_map *)uset, p, 1);
1108         if (p->output_format == ISL_FORMAT_LATEX)
1109                 return isl_union_map_print_latex((isl_union_map *)uset, p, 1);
1110
1111         isl_die(p->ctx, isl_error_invalid,
1112                 "invalid output format for isl_union_set", goto error);
1113 error:
1114         isl_printer_free(p);
1115         return NULL;
1116 }
1117
1118 void isl_map_print(__isl_keep isl_map *map, FILE *out, int indent,
1119         unsigned output_format)
1120 {
1121         isl_printer *printer;
1122
1123         if (!map)
1124                 return;
1125
1126         printer = isl_printer_to_file(map->ctx, out);
1127         printer = isl_printer_set_indent(printer, indent);
1128         printer = isl_printer_set_output_format(printer, output_format);
1129         printer = isl_printer_print_map(printer, map);
1130
1131         isl_printer_free(printer);
1132 }
1133
1134 void isl_union_map_dump(__isl_keep isl_union_map *umap)
1135 {
1136         isl_printer *printer;
1137
1138         if (!umap)
1139                 return;
1140
1141         printer = isl_printer_to_file(isl_union_map_get_ctx(umap), stderr);
1142         printer = isl_printer_print_union_map(printer, umap);
1143         printer = isl_printer_end_line(printer);
1144
1145         isl_printer_free(printer);
1146 }
1147
1148 void isl_union_set_dump(__isl_keep isl_union_set *uset)
1149 {
1150         isl_printer *printer;
1151
1152         if (!uset)
1153                 return;
1154
1155         printer = isl_printer_to_file(isl_union_set_get_ctx(uset), stderr);
1156         printer = isl_printer_print_union_set(printer, uset);
1157         printer = isl_printer_end_line(printer);
1158
1159         isl_printer_free(printer);
1160 }
1161
1162 void isl_union_pw_qpolynomial_dump(__isl_keep isl_union_pw_qpolynomial *upwqp)
1163 {
1164         isl_printer *printer;
1165
1166         if (!upwqp)
1167                 return;
1168
1169         printer = isl_printer_to_file(isl_union_pw_qpolynomial_get_ctx(upwqp),
1170                                         stderr);
1171         printer = isl_printer_print_union_pw_qpolynomial(printer, upwqp);
1172         printer = isl_printer_end_line(printer);
1173
1174         isl_printer_free(printer);
1175 }
1176
1177 void isl_union_pw_qpolynomial_fold_dump(
1178         __isl_keep isl_union_pw_qpolynomial_fold *upwf)
1179 {
1180         isl_printer *printer;
1181
1182         if (!upwf)
1183                 return;
1184
1185         printer = isl_printer_to_file(
1186                         isl_union_pw_qpolynomial_fold_get_ctx(upwf), stderr);
1187         printer = isl_printer_print_union_pw_qpolynomial_fold(printer, upwf);
1188         printer = isl_printer_end_line(printer);
1189
1190         isl_printer_free(printer);
1191 }
1192
1193 static int upoly_rec_n_non_zero(__isl_keep struct isl_upoly_rec *rec)
1194 {
1195         int i;
1196         int n;
1197
1198         for (i = 0, n = 0; i < rec->n; ++i)
1199                 if (!isl_upoly_is_zero(rec->p[i]))
1200                         ++n;
1201
1202         return n;
1203 }
1204
1205 static __isl_give isl_printer *print_div(__isl_keep isl_dim *dim,
1206         __isl_keep isl_mat *div, int pos, __isl_take isl_printer *p)
1207 {
1208         int c = p->output_format == ISL_FORMAT_C;
1209         p = isl_printer_print_str(p, c ? "floord(" : "[(");
1210         p = print_affine_of_len(dim, p, div->row[pos] + 1, div->n_col - 1, 1);
1211         p = isl_printer_print_str(p, c ? ", " : ")/");
1212         p = isl_printer_print_isl_int(p, div->row[pos][0]);
1213         p = isl_printer_print_str(p, c ? ")" : "]");
1214         return p;
1215 }
1216
1217 static __isl_give isl_printer *upoly_print_cst(__isl_keep struct isl_upoly *up,
1218         __isl_take isl_printer *p, int first)
1219 {
1220         struct isl_upoly_cst *cst;
1221         int neg;
1222
1223         cst = isl_upoly_as_cst(up);
1224         if (!cst)
1225                 goto error;
1226         neg = !first && isl_int_is_neg(cst->n);
1227         if (!first)
1228                 p = isl_printer_print_str(p, neg ? " - " :  " + ");
1229         if (neg)
1230                 isl_int_neg(cst->n, cst->n);
1231         if (isl_int_is_zero(cst->d)) {
1232                 int sgn = isl_int_sgn(cst->n);
1233                 p = isl_printer_print_str(p, sgn < 0 ? "-infty" :
1234                                             sgn == 0 ? "NaN" : "infty");
1235         } else
1236                 p = isl_printer_print_isl_int(p, cst->n);
1237         if (neg)
1238                 isl_int_neg(cst->n, cst->n);
1239         if (!isl_int_is_zero(cst->d) && !isl_int_is_one(cst->d)) {
1240                 p = isl_printer_print_str(p, "/");
1241                 p = isl_printer_print_isl_int(p, cst->d);
1242         }
1243         return p;
1244 error:
1245         isl_printer_free(p);
1246         return NULL;
1247 }
1248
1249 static __isl_give isl_printer *print_base(__isl_take isl_printer *p,
1250         __isl_keep isl_dim *dim, __isl_keep isl_mat *div, int var)
1251 {
1252         unsigned total;
1253
1254         total = isl_dim_total(dim);
1255         if (var < total)
1256                 p = print_term(dim, dim->ctx->one, 1 + var, p, 1, 0);
1257         else
1258                 p = print_div(dim, div, var - total, p);
1259         return p;
1260 }
1261
1262 static __isl_give isl_printer *print_pow(__isl_take isl_printer *p,
1263         __isl_keep isl_dim *dim, __isl_keep isl_mat *div, int var, int exp)
1264 {
1265         p = print_base(p, dim, div, var);
1266         if (exp == 1)
1267                 return p;
1268         if (p->output_format == ISL_FORMAT_C) {
1269                 int i;
1270                 for (i = 1; i < exp; ++i) {
1271                         p = isl_printer_print_str(p, "*");
1272                         p = print_base(p, dim, div, var);
1273                 }
1274         } else {
1275                 p = isl_printer_print_str(p, "^");
1276                 p = isl_printer_print_int(p, exp);
1277         }
1278         return p;
1279 }
1280
1281 static __isl_give isl_printer *upoly_print(__isl_keep struct isl_upoly *up,
1282         __isl_keep isl_dim *dim, __isl_keep isl_mat *div,
1283         __isl_take isl_printer *p, int outer)
1284 {
1285         int i, n, first, print_parens;
1286         struct isl_upoly_rec *rec;
1287
1288         if (!p || !up || !dim || !div)
1289                 goto error;
1290
1291         if (isl_upoly_is_cst(up))
1292                 return upoly_print_cst(up, p, 1);
1293
1294         rec = isl_upoly_as_rec(up);
1295         if (!rec)
1296                 goto error;
1297         n = upoly_rec_n_non_zero(rec);
1298         print_parens = n > 1 || (outer && rec->up.var >= isl_dim_total(dim));
1299         if (print_parens)
1300                 p = isl_printer_print_str(p, "(");
1301         for (i = 0, first = 1; i < rec->n; ++i) {
1302                 if (isl_upoly_is_zero(rec->p[i]))
1303                         continue;
1304                 if (isl_upoly_is_negone(rec->p[i])) {
1305                         if (!i)
1306                                 p = isl_printer_print_str(p, "-1");
1307                         else if (first)
1308                                 p = isl_printer_print_str(p, "-");
1309                         else
1310                                 p = isl_printer_print_str(p, " - ");
1311                 } else if (isl_upoly_is_cst(rec->p[i]) &&
1312                                 !isl_upoly_is_one(rec->p[i]))
1313                         p = upoly_print_cst(rec->p[i], p, first);
1314                 else {
1315                         if (!first)
1316                                 p = isl_printer_print_str(p, " + ");
1317                         if (i == 0 || !isl_upoly_is_one(rec->p[i]))
1318                                 p = upoly_print(rec->p[i], dim, div, p, 0);
1319                 }
1320                 first = 0;
1321                 if (i == 0)
1322                         continue;
1323                 if (!isl_upoly_is_one(rec->p[i]) &&
1324                     !isl_upoly_is_negone(rec->p[i]))
1325                         p = isl_printer_print_str(p, " * ");
1326                 p = print_pow(p, dim, div, rec->up.var, i);
1327         }
1328         if (print_parens)
1329                 p = isl_printer_print_str(p, ")");
1330         return p;
1331 error:
1332         isl_printer_free(p);
1333         return NULL;
1334 }
1335
1336 __isl_give isl_printer *isl_printer_print_qpolynomial(__isl_take isl_printer *p,
1337         __isl_keep isl_qpolynomial *qp)
1338 {
1339         if (!p || !qp)
1340                 goto error;
1341         p = upoly_print(qp->upoly, qp->dim, qp->div, p, 1);
1342         return p;
1343 error:
1344         isl_printer_free(p);
1345         return NULL;
1346 }
1347
1348 void isl_qpolynomial_print(__isl_keep isl_qpolynomial *qp, FILE *out,
1349         unsigned output_format)
1350 {
1351         isl_printer *p;
1352
1353         if  (!qp)
1354                 return;
1355
1356         isl_assert(qp->dim->ctx, output_format == ISL_FORMAT_ISL, return);
1357         p = isl_printer_to_file(qp->dim->ctx, out);
1358         p = isl_printer_print_qpolynomial(p, qp);
1359         isl_printer_free(p);
1360 }
1361
1362 static __isl_give isl_printer *qpolynomial_fold_print(
1363         __isl_keep isl_qpolynomial_fold *fold, __isl_take isl_printer *p)
1364 {
1365         int i;
1366
1367         if (fold->type == isl_fold_min)
1368                 p = isl_printer_print_str(p, "min");
1369         else if (fold->type == isl_fold_max)
1370                 p = isl_printer_print_str(p, "max");
1371         p = isl_printer_print_str(p, "(");
1372         for (i = 0; i < fold->n; ++i) {
1373                 if (i)
1374                         p = isl_printer_print_str(p, ", ");
1375                 p = isl_printer_print_qpolynomial(p, fold->qp[i]);
1376         }
1377         p = isl_printer_print_str(p, ")");
1378         return p;
1379 }
1380
1381 __isl_give isl_printer *isl_printer_print_qpolynomial_fold(
1382         __isl_take isl_printer *p, __isl_keep isl_qpolynomial_fold *fold)
1383 {
1384         if  (!p || !fold)
1385                 goto error;
1386         p = qpolynomial_fold_print(fold, p);
1387         return p;
1388 error:
1389         isl_printer_free(p);
1390         return NULL;
1391 }
1392
1393 void isl_qpolynomial_fold_print(__isl_keep isl_qpolynomial_fold *fold,
1394         FILE *out, unsigned output_format)
1395 {
1396         isl_printer *p;
1397
1398         if (!fold)
1399                 return;
1400
1401         isl_assert(fold->dim->ctx, output_format == ISL_FORMAT_ISL, return);
1402
1403         p = isl_printer_to_file(fold->dim->ctx, out);
1404         p = isl_printer_print_qpolynomial_fold(p, fold);
1405
1406         isl_printer_free(p);
1407 }
1408
1409 static __isl_give isl_printer *isl_pwqp_print_isl_body(
1410         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial *pwqp)
1411 {
1412         int i = 0;
1413
1414         for (i = 0; i < pwqp->n; ++i) {
1415                 if (i)
1416                         p = isl_printer_print_str(p, "; ");
1417                 if (isl_dim_size(pwqp->p[i].set->dim, isl_dim_set) > 0 ||
1418                     isl_dim_get_tuple_name(pwqp->p[i].set->dim, isl_dim_set)) {
1419                         p = print_dim(pwqp->p[i].set->dim, p, 1, 0, NULL);
1420                         p = isl_printer_print_str(p, " -> ");
1421                 }
1422                 p = isl_printer_print_qpolynomial(p, pwqp->p[i].qp);
1423                 p = print_disjuncts((isl_map *)pwqp->p[i].set, p, 1, 0);
1424         }
1425
1426         return p;
1427 }
1428
1429 static __isl_give isl_printer *print_pw_qpolynomial_isl(
1430         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial *pwqp)
1431 {
1432         if (!p || !pwqp)
1433                 goto error;
1434
1435         if (isl_dim_size(pwqp->dim, isl_dim_param) > 0) {
1436                 p = print_tuple(pwqp->dim, p, isl_dim_param, 0, 0, NULL);
1437                 p = isl_printer_print_str(p, " -> ");
1438         }
1439         p = isl_printer_print_str(p, "{ ");
1440         if (pwqp->n == 0) {
1441                 if (isl_dim_size(pwqp->dim, isl_dim_set) > 0) {
1442                         p = print_dim(pwqp->dim, p, 1, 0, NULL);
1443                         p = isl_printer_print_str(p, " -> ");
1444                 }
1445                 p = isl_printer_print_str(p, "0");
1446         }
1447         p = isl_pwqp_print_isl_body(p, pwqp);
1448         p = isl_printer_print_str(p, " }");
1449         return p;
1450 error:
1451         isl_printer_free(p);
1452         return NULL;
1453 }
1454
1455 void isl_pw_qpolynomial_print(__isl_keep isl_pw_qpolynomial *pwqp, FILE *out,
1456         unsigned output_format)
1457 {
1458         isl_printer *p;
1459
1460         if (!pwqp)
1461                 return;
1462
1463         p = isl_printer_to_file(pwqp->dim->ctx, out);
1464         p = isl_printer_set_output_format(p, output_format);
1465         p = isl_printer_print_pw_qpolynomial(p, pwqp);
1466
1467         isl_printer_free(p);
1468 }
1469
1470 static __isl_give isl_printer *isl_pwf_print_isl_body(
1471         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial_fold *pwf)
1472 {
1473         int i = 0;
1474
1475         for (i = 0; i < pwf->n; ++i) {
1476                 if (i)
1477                         p = isl_printer_print_str(p, "; ");
1478                 if (isl_dim_size(pwf->p[i].set->dim, isl_dim_set) > 0) {
1479                         p = print_dim(pwf->p[i].set->dim, p, 1, 0, NULL);
1480                         p = isl_printer_print_str(p, " -> ");
1481                 }
1482                 p = qpolynomial_fold_print(pwf->p[i].fold, p);
1483                 p = print_disjuncts((isl_map *)pwf->p[i].set, p, 1, 0);
1484         }
1485
1486         return p;
1487 }
1488
1489 static __isl_give isl_printer *print_pw_qpolynomial_fold_isl(
1490         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial_fold *pwf)
1491 {
1492         if (isl_dim_size(pwf->dim, isl_dim_param) > 0) {
1493                 p = print_tuple(pwf->dim, p, isl_dim_param, 0, 0, NULL);
1494                 p = isl_printer_print_str(p, " -> ");
1495         }
1496         p = isl_printer_print_str(p, "{ ");
1497         if (pwf->n == 0) {
1498                 if (isl_dim_size(pwf->dim, isl_dim_set) > 0) {
1499                         p = print_dim(pwf->dim, p, 1, 0, NULL);
1500                         p = isl_printer_print_str(p, " -> ");
1501                 }
1502                 p = isl_printer_print_str(p, "0");
1503         }
1504         p = isl_pwf_print_isl_body(p, pwf);
1505         p = isl_printer_print_str(p, " }");
1506         return p;
1507 }
1508
1509 static __isl_give isl_printer *print_affine_c(__isl_take isl_printer *p,
1510         __isl_keep isl_basic_set *bset, isl_int *c);
1511
1512 static __isl_give isl_printer *print_name_c(__isl_take isl_printer *p,
1513         __isl_keep isl_basic_set *bset, enum isl_dim_type type, unsigned pos)
1514 {
1515         if (type == isl_dim_div) {
1516                 p = isl_printer_print_str(p, "floord(");
1517                 p = print_affine_c(p, bset, bset->div[pos] + 1);
1518                 p = isl_printer_print_str(p, ", ");
1519                 p = isl_printer_print_isl_int(p, bset->div[pos][0]);
1520                 p = isl_printer_print_str(p, ")");
1521         } else {
1522                 const char *name;
1523
1524                 name = isl_dim_get_name(bset->dim, type, pos);
1525                 if (!name)
1526                         name = "UNNAMED";
1527                 p = isl_printer_print_str(p, name);
1528         }
1529         return p;
1530 }
1531
1532 static __isl_give isl_printer *print_term_c(__isl_take isl_printer *p,
1533         __isl_keep isl_basic_set *bset, isl_int c, unsigned pos)
1534 {
1535         enum isl_dim_type type;
1536         unsigned nparam = isl_basic_set_dim(bset, isl_dim_param);
1537
1538         if (pos == 0)
1539                 return isl_printer_print_isl_int(p, c);
1540
1541         if (isl_int_is_one(c))
1542                 ;
1543         else if (isl_int_is_negone(c))
1544                 p = isl_printer_print_str(p, "-");
1545         else {
1546                 p = isl_printer_print_isl_int(p, c);
1547                 p = isl_printer_print_str(p, "*");
1548         }
1549         type = pos2type(bset->dim, &pos);
1550         p = print_name_c(p, bset, type, pos);
1551         return p;
1552 }
1553
1554 static __isl_give isl_printer *print_affine_c(__isl_take isl_printer *p,
1555         __isl_keep isl_basic_set *bset, isl_int *c)
1556 {
1557         int i;
1558         int first;
1559         unsigned len = 1 + isl_basic_set_total_dim(bset);
1560
1561         for (i = 0, first = 1; i < len; ++i) {
1562                 int flip = 0;
1563                 if (isl_int_is_zero(c[i]))
1564                         continue;
1565                 if (!first) {
1566                         if (isl_int_is_neg(c[i])) {
1567                                 flip = 1;
1568                                 isl_int_neg(c[i], c[i]);
1569                                 p = isl_printer_print_str(p, " - ");
1570                         } else
1571                                 p = isl_printer_print_str(p, " + ");
1572                 }
1573                 first = 0;
1574                 p = print_term_c(p, bset, c[i], i);
1575                 if (flip)
1576                         isl_int_neg(c[i], c[i]);
1577         }
1578         if (first)
1579                 p = isl_printer_print_str(p, "0");
1580         return p;
1581 }
1582
1583 static __isl_give isl_printer *print_constraint_c(__isl_take isl_printer *p,
1584         __isl_keep isl_basic_set *bset, isl_int *c, const char *op, int first)
1585 {
1586         if (!first)
1587                 p = isl_printer_print_str(p, " && ");
1588
1589         p = print_affine_c(p, bset, c);
1590         p = isl_printer_print_str(p, " ");
1591         p = isl_printer_print_str(p, op);
1592         p = isl_printer_print_str(p, " 0");
1593         return p;
1594 }
1595
1596 static __isl_give isl_printer *print_basic_set_c(__isl_take isl_printer *p,
1597         __isl_keep isl_basic_set *bset)
1598 {
1599         int i;
1600
1601         for (i = 0; i < bset->n_eq; ++i)
1602                 p = print_constraint_c(p, bset, bset->eq[i], "==", !i);
1603         for (i = 0; i < bset->n_ineq; ++i)
1604                 p = print_constraint_c(p, bset, bset->ineq[i], ">=",
1605                                         !bset->n_eq && !i);
1606         return p;
1607 }
1608
1609 static __isl_give isl_printer *print_set_c(__isl_take isl_printer *p,
1610         __isl_keep isl_set *set)
1611 {
1612         int i;
1613
1614         if (set->n == 0)
1615                 p = isl_printer_print_str(p, "0");
1616
1617         for (i = 0; i < set->n; ++i) {
1618                 if (i)
1619                         p = isl_printer_print_str(p, " || ");
1620                 if (set->n > 1)
1621                         p = isl_printer_print_str(p, "(");
1622                 p = print_basic_set_c(p, set->p[i]);
1623                 if (set->n > 1)
1624                         p = isl_printer_print_str(p, ")");
1625         }
1626         return p;
1627 }
1628
1629 static __isl_give isl_printer *print_qpolynomial_c(__isl_take isl_printer *p,
1630         __isl_keep isl_qpolynomial *qp)
1631 {
1632         isl_int den;
1633
1634         isl_int_init(den);
1635         isl_qpolynomial_get_den(qp, &den);
1636         if (!isl_int_is_one(den)) {
1637                 isl_qpolynomial *f;
1638                 p = isl_printer_print_str(p, "(");
1639                 qp = isl_qpolynomial_copy(qp);
1640                 f = isl_qpolynomial_rat_cst(isl_dim_copy(qp->dim),
1641                                                 den, qp->dim->ctx->one);
1642                 qp = isl_qpolynomial_mul(qp, f);
1643         }
1644         if (qp)
1645                 p = upoly_print(qp->upoly, qp->dim, qp->div, p, 0);
1646         if (!isl_int_is_one(den)) {
1647                 p = isl_printer_print_str(p, ")/");
1648                 p = isl_printer_print_isl_int(p, den);
1649                 isl_qpolynomial_free(qp);
1650         }
1651         isl_int_clear(den);
1652         return p;
1653 }
1654
1655 static __isl_give isl_printer *print_pw_qpolynomial_c(
1656         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial *pwpq)
1657 {
1658         int i;
1659
1660         if (pwpq->n == 1 && isl_set_fast_is_universe(pwpq->p[0].set))
1661                 return print_qpolynomial_c(p, pwpq->p[0].qp);
1662
1663         for (i = 0; i < pwpq->n; ++i) {
1664                 p = isl_printer_print_str(p, "(");
1665                 p = print_set_c(p, pwpq->p[i].set);
1666                 p = isl_printer_print_str(p, ") ? (");
1667                 p = print_qpolynomial_c(p, pwpq->p[i].qp);
1668                 p = isl_printer_print_str(p, ") : ");
1669         }
1670
1671         p = isl_printer_print_str(p, "0");
1672         return p;
1673 }
1674
1675 __isl_give isl_printer *isl_printer_print_pw_qpolynomial(
1676         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial *pwqp)
1677 {
1678         if (!p || !pwqp)
1679                 goto error;
1680
1681         if (p->output_format == ISL_FORMAT_ISL)
1682                 return print_pw_qpolynomial_isl(p, pwqp);
1683         else if (p->output_format == ISL_FORMAT_C)
1684                 return print_pw_qpolynomial_c(p, pwqp);
1685         isl_assert(p->ctx, 0, goto error);
1686 error:
1687         isl_printer_free(p);
1688         return NULL;
1689 }
1690
1691 static int print_pwqp_body(__isl_take isl_pw_qpolynomial *pwqp, void *user)
1692 {
1693         struct isl_union_print_data *data;
1694         data = (struct isl_union_print_data *)user;
1695
1696         if (!data->first)
1697                 data->p = isl_printer_print_str(data->p, "; ");
1698         data->first = 0;
1699
1700         data->p = isl_pwqp_print_isl_body(data->p, pwqp);
1701         isl_pw_qpolynomial_free(pwqp);
1702
1703         return 0;
1704 }
1705
1706 static __isl_give isl_printer *print_union_pw_qpolynomial_isl(
1707         __isl_take isl_printer *p, __isl_keep isl_union_pw_qpolynomial *upwqp)
1708 {
1709         struct isl_union_print_data data = { p, 1, 1 };
1710         isl_dim *dim;
1711         dim = isl_union_pw_qpolynomial_get_dim(upwqp);
1712         if (isl_dim_size(dim, isl_dim_param) > 0) {
1713                 p = print_tuple(dim, p, isl_dim_param, 1, 0, NULL);
1714                 p = isl_printer_print_str(p, " -> ");
1715         }
1716         isl_dim_free(dim);
1717         p = isl_printer_print_str(p, "{ ");
1718         isl_union_pw_qpolynomial_foreach_pw_qpolynomial(upwqp, &print_pwqp_body,
1719                                                         &data);
1720         p = data.p;
1721         p = isl_printer_print_str(p, " }");
1722         return p;
1723 }
1724
1725 __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial(
1726         __isl_take isl_printer *p, __isl_keep isl_union_pw_qpolynomial *upwqp)
1727 {
1728         if (!p || !upwqp)
1729                 goto error;
1730
1731         if (p->output_format == ISL_FORMAT_ISL)
1732                 return print_union_pw_qpolynomial_isl(p, upwqp);
1733         isl_die(p->ctx, isl_error_invalid,
1734                 "invalid output format for isl_union_pw_qpolynomial",
1735                 goto error);
1736 error:
1737         isl_printer_free(p);
1738         return NULL;
1739 }
1740
1741 static __isl_give isl_printer *print_qpolynomial_fold_c(
1742         __isl_take isl_printer *p, __isl_keep isl_qpolynomial_fold *fold)
1743 {
1744         int i;
1745
1746         for (i = 0; i < fold->n - 1; ++i)
1747                 if (fold->type == isl_fold_min)
1748                         p = isl_printer_print_str(p, "min(");
1749                 else if (fold->type == isl_fold_max)
1750                         p = isl_printer_print_str(p, "max(");
1751
1752         for (i = 0; i < fold->n; ++i) {
1753                 if (i)
1754                         p = isl_printer_print_str(p, ", ");
1755                 p = print_qpolynomial_c(p, fold->qp[i]);
1756                 if (i)
1757                         p = isl_printer_print_str(p, ")");
1758         }
1759         return p;
1760 }
1761
1762 static __isl_give isl_printer *print_pw_qpolynomial_fold_c(
1763         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial_fold *pwf)
1764 {
1765         int i;
1766
1767         if (pwf->n == 1 && isl_set_fast_is_universe(pwf->p[0].set))
1768                 return print_qpolynomial_fold_c(p, pwf->p[0].fold);
1769
1770         for (i = 0; i < pwf->n; ++i) {
1771                 p = isl_printer_print_str(p, "(");
1772                 p = print_set_c(p, pwf->p[i].set);
1773                 p = isl_printer_print_str(p, ") ? (");
1774                 p = print_qpolynomial_fold_c(p, pwf->p[i].fold);
1775                 p = isl_printer_print_str(p, ") : ");
1776         }
1777
1778         p = isl_printer_print_str(p, "0");
1779         return p;
1780 }
1781
1782 __isl_give isl_printer *isl_printer_print_pw_qpolynomial_fold(
1783         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial_fold *pwf)
1784 {
1785         if (!p || !pwf)
1786                 goto error;
1787
1788         if (p->output_format == ISL_FORMAT_ISL)
1789                 return print_pw_qpolynomial_fold_isl(p, pwf);
1790         else if (p->output_format == ISL_FORMAT_C)
1791                 return print_pw_qpolynomial_fold_c(p, pwf);
1792         isl_assert(p->ctx, 0, goto error);
1793 error:
1794         isl_printer_free(p);
1795         return NULL;
1796 }
1797
1798 void isl_pw_qpolynomial_fold_print(__isl_keep isl_pw_qpolynomial_fold *pwf,
1799         FILE *out, unsigned output_format)
1800 {
1801         isl_printer *p;
1802
1803         if (!pwf)
1804                 return;
1805
1806         p = isl_printer_to_file(pwf->dim->ctx, out);
1807         p = isl_printer_set_output_format(p, output_format);
1808         p = isl_printer_print_pw_qpolynomial_fold(p, pwf);
1809
1810         isl_printer_free(p);
1811 }
1812
1813 static int print_pwf_body(__isl_take isl_pw_qpolynomial_fold *pwf, void *user)
1814 {
1815         struct isl_union_print_data *data;
1816         data = (struct isl_union_print_data *)user;
1817
1818         if (!data->first)
1819                 data->p = isl_printer_print_str(data->p, "; ");
1820         data->first = 0;
1821
1822         data->p = isl_pwf_print_isl_body(data->p, pwf);
1823         isl_pw_qpolynomial_fold_free(pwf);
1824
1825         return 0;
1826 }
1827
1828 static __isl_give isl_printer *print_union_pw_qpolynomial_fold_isl(
1829         __isl_take isl_printer *p,
1830         __isl_keep isl_union_pw_qpolynomial_fold *upwf)
1831 {
1832         struct isl_union_print_data data = { p, 1, 1 };
1833         isl_dim *dim;
1834         dim = isl_union_pw_qpolynomial_fold_get_dim(upwf);
1835         if (isl_dim_size(dim, isl_dim_param) > 0) {
1836                 p = print_tuple(dim, p, isl_dim_param, 1, 0, NULL);
1837                 p = isl_printer_print_str(p, " -> ");
1838         }
1839         isl_dim_free(dim);
1840         p = isl_printer_print_str(p, "{ ");
1841         isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(upwf,
1842                                                         &print_pwf_body, &data);
1843         p = data.p;
1844         p = isl_printer_print_str(p, " }");
1845         return p;
1846 }
1847
1848 __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial_fold(
1849         __isl_take isl_printer *p,
1850         __isl_keep isl_union_pw_qpolynomial_fold *upwf)
1851 {
1852         if (!p || !upwf)
1853                 goto error;
1854
1855         if (p->output_format == ISL_FORMAT_ISL)
1856                 return print_union_pw_qpolynomial_fold_isl(p, upwf);
1857         isl_die(p->ctx, isl_error_invalid,
1858                 "invalid output format for isl_union_pw_qpolynomial_fold",
1859                 goto error);
1860 error:
1861         isl_printer_free(p);
1862         return NULL;
1863 }