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