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