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