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