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