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