isl_output.c

   1 /*
   2  * Copyright 2008-2009 Katholieke Universiteit Leuven
   3  * Copyright 2010      INRIA Saclay
   4  *
   5  * Use of this software is governed by the GNU LGPLv2.1 license
   6  *
   7  * Written by Sven Verdoolaege, K.U.Leuven, Departement
   8  * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
   9  * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,
  10  * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France
  11  */
  12
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <isl_ctx_private.h>
  16 #include <isl_map_private.h>
  17 #include <isl/set.h>
  18 #include <isl/seq.h>
  19 #include <isl_polynomial_private.h>
  20 #include <isl_printer_private.h>
  21 #include <isl_dim_private.h>
  22 #include <isl_mat_private.h>
  23 #include <isl/union_map.h>
  24 #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_dim *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_dim_size(dim, t);
 162                 for (p = 0; p < s; ++p) {
 163                         const char *n = isl_dim_get_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_dim *dim,
 172         __isl_take isl_printer *p, enum isl_dim_type type, unsigned pos,
 173         int set, int latex)
 174 {
 175         const char *name;
 176         char buffer[20];
 177         int primes;
 178
 179         name = type == isl_dim_div ? NULL : isl_dim_get_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 (set || 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_dim *dim, unsigned *pos)
 203 {
 204         enum isl_dim_type type;
 205         unsigned n_in = isl_dim_size(dim, isl_dim_in);
 206         unsigned n_out = isl_dim_size(dim, isl_dim_out);
 207         unsigned nparam = isl_dim_size(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_dim *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_dim *dim,
 230         __isl_keep isl_mat *div,
 231         isl_int c, unsigned pos, __isl_take isl_printer *p, int set, 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, set, latex);
 256         return p;
 257 }
 258
 259 static __isl_give isl_printer *print_affine_of_len(__isl_keep isl_dim *dim,
 260         __isl_keep isl_mat *div,
 261         __isl_take isl_printer *p, isl_int *c, int len, int set)
 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, set, 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_dim *dim, __isl_take isl_printer *p, isl_int *c, int set)
 290 {
 291         unsigned len = 1 + isl_basic_map_total_dim(bmap);
 292         return print_affine_of_len(dim, NULL, p, c, len, set);
 293 }
 294
 295 static int defining_equality(__isl_keep isl_basic_map *eq,
 296         __isl_keep isl_dim *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_dim_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_dim *global_dim, enum isl_dim_type global_type,
 322         __isl_keep isl_dim *local_dim, enum isl_dim_type local_type,
 323         int set, 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_dim_size(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_dim_offset(global_dim, global_type)
 336                                     + offset + i;
 337                         p = print_affine_of_len(eq->dim, NULL,
 338                                                 p, eq->eq[j], pos, set);
 339                 } else {
 340                         p = print_name(global_dim, p, global_type, offset + i,
 341                                         set, latex);
 342                 }
 343         }
 344         return p;
 345 }
 346
 347 static __isl_give isl_printer *print_var_list(__isl_keep isl_dim *dim,
 348         __isl_take isl_printer *p, enum isl_dim_type type,
 349         int set, int latex, __isl_keep isl_basic_map *eq)
 350 {
 351         return print_nested_var_list(p, dim, type, dim, type, set, latex, eq, 0);
 352 }
 353
 354 static __isl_give isl_printer *print_nested_map_dim(__isl_take isl_printer *p,
 355         __isl_keep isl_dim *global_dim, enum isl_dim_type global_type,
 356         __isl_keep isl_dim *local_dim,
 357          int set, 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_dim *global_dim, enum isl_dim_type global_type,
 361         __isl_keep isl_dim *local_dim, enum isl_dim_type local_type,
 362         int set, int latex, __isl_keep isl_basic_map *eq, int offset)
 363 {
 364         const char *name = NULL;
 365         unsigned n = isl_dim_size(local_dim, local_type);
 366         if ((local_type == isl_dim_in || local_type == isl_dim_out)) {
 367                 name = isl_dim_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                                 set, latex, eq, offset);
 385         } else
 386                 p = print_nested_var_list(p, global_dim, global_type,
 387                                  local_dim, local_type, set, 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_dim *dim,
 394         __isl_take isl_printer *p, enum isl_dim_type type,
 395         int set, int latex, __isl_keep isl_basic_map *eq)
 396 {
 397         return print_nested_tuple(p, dim, type, dim, type, set, latex, eq, 0);
 398 }
 399
 400 static __isl_give isl_printer *print_nested_map_dim(__isl_take isl_printer *p,
 401         __isl_keep isl_dim *global_dim, enum isl_dim_type global_type,
 402         __isl_keep isl_dim *local_dim,
 403          int set, 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, set, 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, set, latex, eq, offset);
 410
 411         return p;
 412 }
 413
 414 static __isl_give isl_printer *print_dim(__isl_keep isl_dim *dim,
 415         __isl_take isl_printer *p, int set, 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 (set)
 421                 p = print_tuple(dim, p, isl_dim_set, 1, latex, eq);
 422         else {
 423                 p = print_tuple(dim, p, isl_dim_in, 0, latex, eq);
 424                 p = isl_printer_print_str(p, s_to[latex]);
 425                 p = print_tuple(dim, p, isl_dim_out, 0, latex, eq);
 426         }
 427
 428         return p;
 429 }
 430
 431 static __isl_give isl_printer *print_omega_parameters(__isl_keep isl_dim *dim,
 432         __isl_take isl_printer *p)
 433 {
 434         if (isl_dim_size(dim, isl_dim_param) == 0)
 435                 return p;
 436
 437         p = isl_printer_start_line(p);
 438         p = isl_printer_print_str(p, "symbolic ");
 439         p = print_var_list(dim, p, isl_dim_param, 0, 0, NULL);
 440         p = isl_printer_print_str(p, ";");
 441         p = isl_printer_end_line(p);
 442         return p;
 443 }
 444
 445 static __isl_give isl_printer *print_constraint(struct isl_basic_map *bmap,
 446         __isl_keep isl_dim *dim, __isl_take isl_printer *p,
 447         isl_int *c, int last, const char *op, int first_constraint, int set,
 448         int latex)
 449 {
 450         if (!first_constraint)
 451                 p = isl_printer_print_str(p, s_and[latex]);
 452
 453         isl_int_abs(c[last], c[last]);
 454
 455         p = print_term(dim, NULL, c[last], last, p, set, latex);
 456
 457         p = isl_printer_print_str(p, " ");
 458         p = isl_printer_print_str(p, op);
 459         p = isl_printer_print_str(p, " ");
 460
 461         isl_int_set_si(c[last], 0);
 462         p = print_affine(bmap, dim, p, c, set);
 463
 464         return p;
 465 }
 466
 467 static __isl_give isl_printer *print_constraints(__isl_keep isl_basic_map *bmap,
 468         __isl_keep isl_dim *dim, __isl_take isl_printer *p, int set, int latex)
 469 {
 470         int i;
 471         struct isl_vec *c;
 472         unsigned total = isl_basic_map_total_dim(bmap);
 473
 474         c = isl_vec_alloc(bmap->ctx, 1 + total);
 475         if (!c)
 476                 goto error;
 477
 478         for (i = bmap->n_eq - 1; i >= 0; --i) {
 479                 int l = isl_seq_last_non_zero(bmap->eq[i], 1 + total);
 480                 if (l < 0) {
 481                         if (i != bmap->n_eq - 1)
 482                                 p = isl_printer_print_str(p, s_and[latex]);
 483                         p = isl_printer_print_str(p, "0 = 0");
 484                         continue;
 485                 }
 486                 if (isl_int_is_neg(bmap->eq[i][l]))
 487                         isl_seq_cpy(c->el, bmap->eq[i], 1 + total);
 488                 else
 489                         isl_seq_neg(c->el, bmap->eq[i], 1 + total);
 490                 p = print_constraint(bmap, dim, p, c->el, l,
 491                                     "=", i == bmap->n_eq - 1, set, latex);
 492         }
 493         for (i = 0; i < bmap->n_ineq; ++i) {
 494                 int l = isl_seq_last_non_zero(bmap->ineq[i], 1 + total);
 495                 int s;
 496                 const char *op;
 497                 if (l < 0)
 498                         continue;
 499                 s = isl_int_sgn(bmap->ineq[i][l]);
 500                 if (s < 0)
 501                         isl_seq_cpy(c->el, bmap->ineq[i], 1 + total);
 502                 else
 503                         isl_seq_neg(c->el, bmap->ineq[i], 1 + total);
 504                 op = s < 0 ? s_le[latex] : s_ge[latex];
 505                 p = print_constraint(bmap, dim, p, c->el, l,
 506                                         op, !bmap->n_eq && !i, set, latex);
 507         }
 508
 509         isl_vec_free(c);
 510
 511         return p;
 512 error:
 513         isl_vec_free(c);
 514         isl_printer_free(p);
 515         return NULL;
 516 }
 517
 518 static __isl_give isl_printer *print_omega_constraints(
 519         __isl_keep isl_basic_map *bmap, __isl_take isl_printer *p, int set)
 520 {
 521         if (bmap->n_eq + bmap->n_ineq == 0)
 522                 return p;
 523
 524         p = isl_printer_print_str(p, ": ");
 525         if (bmap->n_div > 0) {
 526                 int i;
 527                 p = isl_printer_print_str(p, "exists (");
 528                 for (i = 0; i < bmap->n_div; ++i) {
 529                         if (i)
 530                                 p = isl_printer_print_str(p, ", ");
 531                         p = print_name(bmap->dim, p, isl_dim_div, i, 0, 0);
 532                 }
 533                 p = isl_printer_print_str(p, ": ");
 534         }
 535         p = print_constraints(bmap, bmap->dim, p, set, 0);
 536         if (bmap->n_div > 0)
 537                 p = isl_printer_print_str(p, ")");
 538         return p;
 539 }
 540
 541 static __isl_give isl_printer *basic_map_print_omega(
 542         __isl_keep isl_basic_map *bmap, __isl_take isl_printer *p)
 543 {
 544         p = isl_printer_print_str(p, "{ [");
 545         p = print_var_list(bmap->dim, p, isl_dim_in, 0, 0, NULL);
 546         p = isl_printer_print_str(p, "] -> [");
 547         p = print_var_list(bmap->dim, p, isl_dim_out, 0, 0, NULL);
 548         p = isl_printer_print_str(p, "] ");
 549         p = print_omega_constraints(bmap, p, 0);
 550         p = isl_printer_print_str(p, " }");
 551         return p;
 552 }
 553
 554 static __isl_give isl_printer *isl_basic_map_print_omega(
 555         __isl_keep isl_basic_map *bmap, __isl_take isl_printer *p)
 556 {
 557         p = print_omega_parameters(bmap->dim, p);
 558
 559         p = isl_printer_start_line(p);
 560         p = basic_map_print_omega(bmap, p);
 561         p = isl_printer_end_line(p);
 562         return p;
 563 }
 564
 565 static __isl_give isl_printer *basic_set_print_omega(
 566         __isl_keep isl_basic_set *bset, __isl_take isl_printer *p)
 567 {
 568         p = isl_printer_print_str(p, "{ [");
 569         p = print_var_list(bset->dim, p, isl_dim_set, 1, 0, NULL);
 570         p = isl_printer_print_str(p, "] ");
 571         p = print_omega_constraints((isl_basic_map *)bset, p, 1);
 572         p = isl_printer_print_str(p, " }");
 573         return p;
 574 }
 575
 576 static __isl_give isl_printer *isl_basic_set_print_omega(
 577         __isl_keep isl_basic_set *bset, __isl_take isl_printer *p)
 578 {
 579         p = print_omega_parameters(bset->dim, p);
 580
 581         p = isl_printer_start_line(p);
 582         p = basic_set_print_omega(bset, p);
 583         p = isl_printer_end_line(p);
 584         return p;
 585 }
 586
 587 static __isl_give isl_printer *isl_map_print_omega(__isl_keep isl_map *map,
 588         __isl_take isl_printer *p)
 589 {
 590         int i;
 591
 592         p = print_omega_parameters(map->dim, p);
 593
 594         p = isl_printer_start_line(p);
 595         for (i = 0; i < map->n; ++i) {
 596                 if (i)
 597                         p = isl_printer_print_str(p, " union ");
 598                 p = basic_map_print_omega(map->p[i], p);
 599         }
 600         p = isl_printer_end_line(p);
 601         return p;
 602 }
 603
 604 static __isl_give isl_printer *isl_set_print_omega(__isl_keep isl_set *set,
 605         __isl_take isl_printer *p)
 606 {
 607         int i;
 608
 609         p = print_omega_parameters(set->dim, p);
 610
 611         p = isl_printer_start_line(p);
 612         for (i = 0; i < set->n; ++i) {
 613                 if (i)
 614                         p = isl_printer_print_str(p, " union ");
 615                 p = basic_set_print_omega(set->p[i], p);
 616         }
 617         p = isl_printer_end_line(p);
 618         return p;
 619 }
 620
 621 static __isl_give isl_printer *print_disjunct(__isl_keep isl_basic_map *bmap,
 622         __isl_keep isl_dim *dim, __isl_take isl_printer *p, int set, int latex)
 623 {
 624         if (bmap->n_div > 0) {
 625                 int i;
 626                 p = isl_printer_print_str(p, s_open_exists[latex]);
 627                 for (i = 0; i < bmap->n_div; ++i) {
 628                         if (i)
 629                                 p = isl_printer_print_str(p, ", ");
 630                         p = print_name(dim, p, isl_dim_div, i, 0, latex);
 631                         if (latex || isl_int_is_zero(bmap->div[i][0]))
 632                                 continue;
 633                         p = isl_printer_print_str(p, " = [(");
 634                         p = print_affine(bmap, dim, p, bmap->div[i] + 1, set);
 635                         p = isl_printer_print_str(p, ")/");
 636                         p = isl_printer_print_isl_int(p, bmap->div[i][0]);
 637                         p = isl_printer_print_str(p, "]");
 638                 }
 639                 p = isl_printer_print_str(p, ": ");
 640         }
 641
 642         p = print_constraints(bmap, dim, p, set, latex);
 643
 644         if (bmap->n_div > 0)
 645                 p = isl_printer_print_str(p, s_close_exists[latex]);
 646         return p;
 647 }
 648
 649 static __isl_give isl_printer *isl_basic_map_print_isl(
 650         __isl_keep isl_basic_map *bmap, __isl_take isl_printer *p,
 651         int set, int latex)
 652 {
 653         int rational = ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL);
 654         if (isl_basic_map_dim(bmap, isl_dim_param) > 0) {
 655                 p = print_tuple(bmap->dim, p, isl_dim_param, 0, latex, NULL);
 656                 p = isl_printer_print_str(p, " -> ");
 657         }
 658         p = isl_printer_print_str(p, "{ ");
 659         p = print_dim(bmap->dim, p, set, latex, rational, NULL);
 660         p = isl_printer_print_str(p, " : ");
 661         p = print_disjunct(bmap, bmap->dim, p, set, latex);
 662         p = isl_printer_print_str(p, " }");
 663         return p;
 664 }
 665
 666 static __isl_give isl_printer *print_disjuncts(__isl_keep isl_map *map,
 667         __isl_take isl_printer *p, int set, int latex)
 668 {
 669         int i;
 670
 671         if (isl_map_plain_is_universe(map))
 672                 return p;
 673
 674         p = isl_printer_print_str(p, s_such_that[latex]);
 675         if (map->n == 0)
 676                 p = isl_printer_print_str(p, "1 = 0");
 677         for (i = 0; i < map->n; ++i) {
 678                 if (i)
 679                         p = isl_printer_print_str(p, s_or[latex]);
 680                 if (map->n > 1 && map->p[i]->n_eq + map->p[i]->n_ineq > 1)
 681                         p = isl_printer_print_str(p, "(");
 682                 p = print_disjunct(map->p[i], map->dim, p, set, latex);
 683                 if (map->n > 1 && map->p[i]->n_eq + map->p[i]->n_ineq > 1)
 684                         p = isl_printer_print_str(p, ")");
 685         }
 686         return p;
 687 }
 688
 689 struct isl_aff_split {
 690         isl_basic_map *aff;
 691         isl_map *map;
 692 };
 693
 694 static void free_split(__isl_take struct isl_aff_split *split, int n)
 695 {
 696         int i;
 697
 698         if (!split)
 699                 return;
 700
 701         for (i = 0; i < n; ++i) {
 702                 isl_basic_map_free(split[i].aff);
 703                 isl_map_free(split[i].map);
 704         }
 705
 706         free(split);
 707 }
 708
 709 static __isl_give isl_basic_map *get_aff(__isl_take isl_basic_map *bmap)
 710 {
 711         int i, j;
 712         unsigned nparam, n_in, n_out, total;
 713
 714         bmap = isl_basic_map_cow(bmap);
 715         if (!bmap)
 716                 return NULL;
 717         if (isl_basic_map_free_inequality(bmap, bmap->n_ineq) < 0)
 718                 goto error;
 719
 720         nparam = isl_basic_map_dim(bmap, isl_dim_param);
 721         n_in = isl_basic_map_dim(bmap, isl_dim_in);
 722         n_out = isl_basic_map_dim(bmap, isl_dim_out);
 723         total = isl_basic_map_dim(bmap, isl_dim_all);
 724         for (i = bmap->n_eq - 1; i >= 0; --i) {
 725                 j = isl_seq_last_non_zero(bmap->eq[i] + 1, total);
 726                 if (j >= nparam && j < nparam + n_in + n_out &&
 727                     (isl_int_is_one(bmap->eq[i][1 + j]) ||
 728                      isl_int_is_negone(bmap->eq[i][1 + j])))
 729                         continue;
 730                 if (isl_basic_map_drop_equality(bmap, i) < 0)
 731                         goto error;
 732         }
 733
 734         bmap = isl_basic_map_finalize(bmap);
 735
 736         return bmap;
 737 error:
 738         isl_basic_map_free(bmap);
 739         return NULL;
 740 }
 741
 742 static int aff_split_cmp(const void *p1, const void *p2)
 743 {
 744         const struct isl_aff_split *s1, *s2;
 745         s1 = (const struct isl_aff_split *) p1;
 746         s2 = (const struct isl_aff_split *) p2;
 747
 748         return isl_basic_map_plain_cmp(s1->aff, s2->aff);
 749 }
 750
 751 static __isl_give isl_basic_map *drop_aff(__isl_take isl_basic_map *bmap,
 752         __isl_keep isl_basic_map *aff)
 753 {
 754         int i, j;
 755         unsigned total;
 756
 757         if (!bmap || !aff)
 758                 goto error;
 759
 760         total = isl_dim_total(bmap->dim);
 761
 762         for (i = bmap->n_eq - 1; i >= 0; --i) {
 763                 if (isl_seq_first_non_zero(bmap->eq[i] + 1 + total,
 764                                             bmap->n_div) != -1)
 765                         continue;
 766                 for (j = 0; j < aff->n_eq; ++j) {
 767                         if (!isl_seq_eq(bmap->eq[i], aff->eq[j], 1 + total) &&
 768                             !isl_seq_is_neg(bmap->eq[i], aff->eq[j], 1 + total))
 769                                 continue;
 770                         if (isl_basic_map_drop_equality(bmap, i) < 0)
 771                                 goto error;
 772                         break;
 773                 }
 774         }
 775
 776         return bmap;
 777 error:
 778         isl_basic_map_free(bmap);
 779         return NULL;
 780 }
 781
 782 static __isl_give struct isl_aff_split *split_aff(__isl_keep isl_map *map)
 783 {
 784         int i, n;
 785         struct isl_aff_split *split;
 786         isl_ctx *ctx;
 787
 788         ctx = isl_map_get_ctx(map);
 789         split = isl_calloc_array(ctx, struct isl_aff_split, map->n);
 790         if (!split)
 791                 return NULL;
 792
 793         for (i = 0; i < map->n; ++i) {
 794                 isl_basic_map *bmap;
 795                 split[i].aff = get_aff(isl_basic_map_copy(map->p[i]));
 796                 bmap = isl_basic_map_copy(map->p[i]);
 797                 bmap = isl_basic_map_cow(bmap);
 798                 bmap = drop_aff(bmap, split[i].aff);
 799                 split[i].map = isl_map_from_basic_map(bmap);
 800                 if (!split[i].aff || !split[i].map)
 801                         goto error;
 802         }
 803
 804         qsort(split, map->n, sizeof(struct isl_aff_split), &aff_split_cmp);
 805
 806         n = map->n;
 807         for (i = n - 1; i >= 1; --i) {
 808                 if (!isl_basic_map_plain_is_equal(split[i - 1].aff,
 809                                                  split[i].aff))
 810                         continue;
 811                 isl_basic_map_free(split[i].aff);
 812                 split[i - 1].map = isl_map_union(split[i - 1].map,
 813                                                  split[i].map);
 814                 if (i != n - 1)
 815                         split[i] = split[n - 1];
 816                 split[n - 1].aff = NULL;
 817                 split[n - 1].map = NULL;
 818                 --n;
 819         }
 820
 821         return split;
 822 error:
 823         free_split(split, map->n);
 824         return NULL;
 825 }
 826
 827 static __isl_give isl_printer *print_split_map(__isl_take isl_printer *p,
 828         struct isl_aff_split *split, int n, int set)
 829 {
 830         int i;
 831         int rational;
 832
 833         for (i = 0; i < n; ++i) {
 834                 isl_dim *dim;
 835
 836                 if (!split[i].map)
 837                         break;
 838                 dim = split[i].map->dim;
 839                 rational = split[i].map->n > 0 &&
 840                     ISL_F_ISSET(split[i].map->p[0], ISL_BASIC_MAP_RATIONAL);
 841                 if (i)
 842                         p = isl_printer_print_str(p, "; ");
 843                 p = print_dim(dim, p, set, 0, rational, split[i].aff);
 844                 p = print_disjuncts(split[i].map, p, set, 0);
 845         }
 846
 847         return p;
 848 }
 849
 850 static __isl_give isl_printer *isl_map_print_isl_body(__isl_keep isl_map *map,
 851         __isl_take isl_printer *p, int set)
 852 {
 853         struct isl_aff_split *split = NULL;
 854         int rational;
 855
 856         if (map->n > 0)
 857                 split = split_aff(map);
 858         if (split) {
 859                 p = print_split_map(p, split, map->n, set);
 860         } else {
 861                 rational = map->n > 0 &&
 862                     ISL_F_ISSET(map->p[0], ISL_BASIC_MAP_RATIONAL);
 863                 p = print_dim(map->dim, p, set, 0, rational, NULL);
 864                 p = print_disjuncts(map, p, set, 0);
 865         }
 866         free_split(split, map->n);
 867         return p;
 868 }
 869
 870 static __isl_give isl_printer *isl_map_print_isl(__isl_keep isl_map *map,
 871         __isl_take isl_printer *p, int set)
 872 {
 873         if (isl_map_dim(map, isl_dim_param) > 0) {
 874                 p = print_tuple(map->dim, p, isl_dim_param, set, 0, NULL);
 875                 p = isl_printer_print_str(p, s_to[0]);
 876         }
 877         p = isl_printer_print_str(p, s_open_set[0]);
 878         p = isl_map_print_isl_body(map, p, set);
 879         p = isl_printer_print_str(p, s_close_set[0]);
 880         return p;
 881 }
 882
 883 static __isl_give isl_printer *print_latex_map(__isl_keep isl_map *map,
 884         __isl_take isl_printer *p, __isl_keep isl_basic_map *aff, int set)
 885 {
 886         if (isl_map_dim(map, isl_dim_param) > 0) {
 887                 p = print_tuple(map->dim, p, isl_dim_param, set, 1, NULL);
 888                 p = isl_printer_print_str(p, s_to[1]);
 889         }
 890         p = isl_printer_print_str(p, s_open_set[1]);
 891         p = print_dim(map->dim, p, set, 1, 0, aff);
 892         p = print_disjuncts(map, p, set, 1);
 893         p = isl_printer_print_str(p, s_close_set[1]);
 894
 895         return p;
 896 }
 897
 898 static __isl_give isl_printer *isl_map_print_latex(__isl_keep isl_map *map,
 899         __isl_take isl_printer *p, int set)
 900 {
 901         int i;
 902         struct isl_aff_split *split = NULL;
 903
 904         if (map->n > 0)
 905                 split = split_aff(map);
 906
 907         if (!split)
 908                 return print_latex_map(map, p, NULL, set);
 909
 910         for (i = 0; i < map->n; ++i) {
 911                 if (!split[i].map)
 912                         break;
 913                 if (i)
 914                         p = isl_printer_print_str(p, " \\cup ");
 915                 p = print_latex_map(split[i].map, p, split[i].aff, set);
 916         }
 917
 918         free_split(split, map->n);
 919         return p;
 920 }
 921
 922 __isl_give isl_printer *isl_printer_print_basic_map(__isl_take isl_printer *p,
 923         __isl_keep isl_basic_map *bmap)
 924 {
 925         if (!p || !bmap)
 926                 goto error;
 927         if (p->output_format == ISL_FORMAT_ISL)
 928                 return isl_basic_map_print_isl(bmap, p, 0, 0);
 929         else if (p->output_format == ISL_FORMAT_OMEGA)
 930                 return isl_basic_map_print_omega(bmap, p);
 931         isl_assert(bmap->ctx, 0, goto error);
 932 error:
 933         isl_printer_free(p);
 934         return NULL;
 935 }
 936
 937 void isl_basic_map_print(__isl_keep isl_basic_map *bmap, FILE *out, int indent,
 938         const char *prefix, const char *suffix, unsigned output_format)
 939 {
 940         isl_printer *printer;
 941
 942         if (!bmap)
 943                 return;
 944
 945         printer = isl_printer_to_file(bmap->ctx, out);
 946         printer = isl_printer_set_indent(printer, indent);
 947         printer = isl_printer_set_prefix(printer, prefix);
 948         printer = isl_printer_set_suffix(printer, suffix);
 949         printer = isl_printer_set_output_format(printer, output_format);
 950         isl_printer_print_basic_map(printer, bmap);
 951
 952         isl_printer_free(printer);
 953 }
 954
 955 __isl_give isl_printer *isl_printer_print_basic_set(__isl_take isl_printer *p,
 956         __isl_keep isl_basic_set *bset)
 957 {
 958         if (!p || !bset)
 959                 goto error;
 960
 961         if (p->output_format == ISL_FORMAT_ISL)
 962                 return isl_basic_map_print_isl(bset, p, 1, 0);
 963         else if (p->output_format == ISL_FORMAT_POLYLIB)
 964                 return isl_basic_set_print_polylib(bset, p, 0);
 965         else if (p->output_format == ISL_FORMAT_EXT_POLYLIB)
 966                 return isl_basic_set_print_polylib(bset, p, 1);
 967         else if (p->output_format == ISL_FORMAT_POLYLIB_CONSTRAINTS)
 968                 return bset_print_constraints_polylib(bset, p);
 969         else if (p->output_format == ISL_FORMAT_OMEGA)
 970                 return isl_basic_set_print_omega(bset, p);
 971         isl_assert(p->ctx, 0, goto error);
 972 error:
 973         isl_printer_free(p);
 974         return NULL;
 975 }
 976
 977 void isl_basic_set_print(struct isl_basic_set *bset, FILE *out, int indent,
 978         const char *prefix, const char *suffix, unsigned output_format)
 979 {
 980         isl_printer *printer;
 981
 982         if (!bset)
 983                 return;
 984
 985         printer = isl_printer_to_file(bset->ctx, out);
 986         printer = isl_printer_set_indent(printer, indent);
 987         printer = isl_printer_set_prefix(printer, prefix);
 988         printer = isl_printer_set_suffix(printer, suffix);
 989         printer = isl_printer_set_output_format(printer, output_format);
 990         isl_printer_print_basic_set(printer, bset);
 991
 992         isl_printer_free(printer);
 993 }
 994
 995 __isl_give isl_printer *isl_printer_print_set(__isl_take isl_printer *p,
 996         __isl_keep isl_set *set)
 997 {
 998         if (!p || !set)
 999                 goto error;
1000         if (p->output_format == ISL_FORMAT_ISL)
1001                 return isl_map_print_isl((isl_map *)set, p, 1);
1002         else if (p->output_format == ISL_FORMAT_POLYLIB)
1003                 return isl_set_print_polylib(set, p, 0);
1004         else if (p->output_format == ISL_FORMAT_EXT_POLYLIB)
1005                 return isl_set_print_polylib(set, p, 1);
1006         else if (p->output_format == ISL_FORMAT_OMEGA)
1007                 return isl_set_print_omega(set, p);
1008         else if (p->output_format == ISL_FORMAT_LATEX)
1009                 return isl_map_print_latex((isl_map *)set, p, 1);
1010         isl_assert(set->ctx, 0, goto error);
1011 error:
1012         isl_printer_free(p);
1013         return NULL;
1014 }
1015
1016 void isl_set_print(struct isl_set *set, FILE *out, int indent,
1017         unsigned output_format)
1018 {
1019         isl_printer *printer;
1020
1021         if (!set)
1022                 return;
1023
1024         printer = isl_printer_to_file(set->ctx, out);
1025         printer = isl_printer_set_indent(printer, indent);
1026         printer = isl_printer_set_output_format(printer, output_format);
1027         printer = isl_printer_print_set(printer, set);
1028
1029         isl_printer_free(printer);
1030 }
1031
1032 __isl_give isl_printer *isl_printer_print_map(__isl_take isl_printer *p,
1033         __isl_keep isl_map *map)
1034 {
1035         if (!p || !map)
1036                 goto error;
1037
1038         if (p->output_format == ISL_FORMAT_ISL)
1039                 return isl_map_print_isl(map, p, 0);
1040         else if (p->output_format == ISL_FORMAT_POLYLIB)
1041                 return isl_map_print_polylib(map, p, 0);
1042         else if (p->output_format == ISL_FORMAT_EXT_POLYLIB)
1043                 return isl_map_print_polylib(map, p, 1);
1044         else if (p->output_format == ISL_FORMAT_OMEGA)
1045                 return isl_map_print_omega(map, p);
1046         else if (p->output_format == ISL_FORMAT_LATEX)
1047                 return isl_map_print_latex(map, p, 0);
1048         isl_assert(map->ctx, 0, goto error);
1049 error:
1050         isl_printer_free(p);
1051         return NULL;
1052 }
1053
1054 struct isl_union_print_data {
1055         isl_printer *p;
1056         int set;
1057         int first;
1058 };
1059
1060 static int print_map_body(__isl_take isl_map *map, void *user)
1061 {
1062         struct isl_union_print_data *data;
1063         data = (struct isl_union_print_data *)user;
1064
1065         if (!data->first)
1066                 data->p = isl_printer_print_str(data->p, "; ");
1067         data->first = 0;
1068
1069         data->p = isl_map_print_isl_body(map, data->p, data->set);
1070         isl_map_free(map);
1071
1072         return 0;
1073 }
1074
1075 static __isl_give isl_printer *isl_union_map_print_isl(
1076         __isl_keep isl_union_map *umap, __isl_take isl_printer *p, int set)
1077 {
1078         struct isl_union_print_data data = { p, set, 1 };
1079         isl_dim *dim;
1080         dim = isl_union_map_get_dim(umap);
1081         if (isl_dim_size(dim, isl_dim_param) > 0) {
1082                 p = print_tuple(dim, p, isl_dim_param, set, 0, NULL);
1083                 p = isl_printer_print_str(p, s_to[0]);
1084         }
1085         isl_dim_free(dim);
1086         p = isl_printer_print_str(p, s_open_set[0]);
1087         isl_union_map_foreach_map(umap, &print_map_body, &data);
1088         p = data.p;
1089         p = isl_printer_print_str(p, s_close_set[0]);
1090         return p;
1091 }
1092
1093 static int print_latex_map_body(__isl_take isl_map *map, void *user)
1094 {
1095         struct isl_union_print_data *data;
1096         data = (struct isl_union_print_data *)user;
1097
1098         if (!data->first)
1099                 data->p = isl_printer_print_str(data->p, " \\cup ");
1100         data->first = 0;
1101
1102         data->p = isl_map_print_latex(map, data->p, data->set);
1103         isl_map_free(map);
1104
1105         return 0;
1106 }
1107
1108 static __isl_give isl_printer *isl_union_map_print_latex(
1109         __isl_keep isl_union_map *umap, __isl_take isl_printer *p, int set)
1110 {
1111         struct isl_union_print_data data = { p, set, 1 };
1112         isl_union_map_foreach_map(umap, &print_latex_map_body, &data);
1113         p = data.p;
1114         return p;
1115 }
1116
1117 __isl_give isl_printer *isl_printer_print_union_map(__isl_take isl_printer *p,
1118         __isl_keep isl_union_map *umap)
1119 {
1120         if (!p || !umap)
1121                 goto error;
1122
1123         if (p->output_format == ISL_FORMAT_ISL)
1124                 return isl_union_map_print_isl(umap, p, 0);
1125         if (p->output_format == ISL_FORMAT_LATEX)
1126                 return isl_union_map_print_latex(umap, p, 0);
1127
1128         isl_die(p->ctx, isl_error_invalid,
1129                 "invalid output format for isl_union_map", goto error);
1130 error:
1131         isl_printer_free(p);
1132         return NULL;
1133 }
1134
1135 __isl_give isl_printer *isl_printer_print_union_set(__isl_take isl_printer *p,
1136         __isl_keep isl_union_set *uset)
1137 {
1138         if (!p || !uset)
1139                 goto error;
1140
1141         if (p->output_format == ISL_FORMAT_ISL)
1142                 return isl_union_map_print_isl((isl_union_map *)uset, p, 1);
1143         if (p->output_format == ISL_FORMAT_LATEX)
1144                 return isl_union_map_print_latex((isl_union_map *)uset, p, 1);
1145
1146         isl_die(p->ctx, isl_error_invalid,
1147                 "invalid output format for isl_union_set", goto error);
1148 error:
1149         isl_printer_free(p);
1150         return NULL;
1151 }
1152
1153 void isl_map_print(__isl_keep isl_map *map, FILE *out, int indent,
1154         unsigned output_format)
1155 {
1156         isl_printer *printer;
1157
1158         if (!map)
1159                 return;
1160
1161         printer = isl_printer_to_file(map->ctx, out);
1162         printer = isl_printer_set_indent(printer, indent);
1163         printer = isl_printer_set_output_format(printer, output_format);
1164         printer = isl_printer_print_map(printer, map);
1165
1166         isl_printer_free(printer);
1167 }
1168
1169 void isl_basic_map_dump(__isl_keep isl_basic_map *bmap)
1170 {
1171         isl_printer *printer;
1172
1173         if (!bmap)
1174                 return;
1175
1176         printer = isl_printer_to_file(isl_basic_map_get_ctx(bmap), stderr);
1177         printer = isl_printer_print_basic_map(printer, bmap);
1178         printer = isl_printer_end_line(printer);
1179
1180         isl_printer_free(printer);
1181 }
1182
1183 void isl_basic_set_dump(__isl_keep isl_basic_set *bset)
1184 {
1185         isl_printer *printer;
1186
1187         if (!bset)
1188                 return;
1189
1190         printer = isl_printer_to_file(isl_basic_set_get_ctx(bset), stderr);
1191         printer = isl_printer_print_basic_set(printer, bset);
1192         printer = isl_printer_end_line(printer);
1193
1194         isl_printer_free(printer);
1195 }
1196
1197 void isl_map_dump(__isl_keep isl_map *map)
1198 {
1199         isl_printer *printer;
1200
1201         if (!map)
1202                 return;
1203
1204         printer = isl_printer_to_file(isl_map_get_ctx(map), stderr);
1205         printer = isl_printer_print_map(printer, map);
1206         printer = isl_printer_end_line(printer);
1207
1208         isl_printer_free(printer);
1209 }
1210
1211 void isl_set_dump(__isl_keep isl_set *set)
1212 {
1213         isl_printer *printer;
1214
1215         if (!set)
1216                 return;
1217
1218         printer = isl_printer_to_file(isl_set_get_ctx(set), stderr);
1219         printer = isl_printer_print_set(printer, set);
1220         printer = isl_printer_end_line(printer);
1221
1222         isl_printer_free(printer);
1223 }
1224
1225 void isl_union_map_dump(__isl_keep isl_union_map *umap)
1226 {
1227         isl_printer *printer;
1228
1229         if (!umap)
1230                 return;
1231
1232         printer = isl_printer_to_file(isl_union_map_get_ctx(umap), stderr);
1233         printer = isl_printer_print_union_map(printer, umap);
1234         printer = isl_printer_end_line(printer);
1235
1236         isl_printer_free(printer);
1237 }
1238
1239 void isl_union_set_dump(__isl_keep isl_union_set *uset)
1240 {
1241         isl_printer *printer;
1242
1243         if (!uset)
1244                 return;
1245
1246         printer = isl_printer_to_file(isl_union_set_get_ctx(uset), stderr);
1247         printer = isl_printer_print_union_set(printer, uset);
1248         printer = isl_printer_end_line(printer);
1249
1250         isl_printer_free(printer);
1251 }
1252
1253 void isl_union_pw_qpolynomial_dump(__isl_keep isl_union_pw_qpolynomial *upwqp)
1254 {
1255         isl_printer *printer;
1256
1257         if (!upwqp)
1258                 return;
1259
1260         printer = isl_printer_to_file(isl_union_pw_qpolynomial_get_ctx(upwqp),
1261                                         stderr);
1262         printer = isl_printer_print_union_pw_qpolynomial(printer, upwqp);
1263         printer = isl_printer_end_line(printer);
1264
1265         isl_printer_free(printer);
1266 }
1267
1268 void isl_qpolynomial_dump(__isl_keep isl_qpolynomial *qp)
1269 {
1270         isl_printer *printer;
1271
1272         if (!qp)
1273                 return;
1274
1275         printer = isl_printer_to_file(isl_qpolynomial_get_ctx(qp), stderr);
1276         printer = isl_printer_print_qpolynomial(printer, qp);
1277         printer = isl_printer_end_line(printer);
1278
1279         isl_printer_free(printer);
1280 }
1281
1282 void isl_qpolynomial_fold_dump(__isl_keep isl_qpolynomial_fold *fold)
1283 {
1284         isl_printer *printer;
1285
1286         if (!fold)
1287                 return;
1288
1289         printer = isl_printer_to_file(isl_qpolynomial_fold_get_ctx(fold),
1290                                         stderr);
1291         printer = isl_printer_print_qpolynomial_fold(printer, fold);
1292         printer = isl_printer_end_line(printer);
1293
1294         isl_printer_free(printer);
1295 }
1296
1297 void isl_pw_qpolynomial_dump(__isl_keep isl_pw_qpolynomial *pwqp)
1298 {
1299         isl_printer *printer;
1300
1301         if (!pwqp)
1302                 return;
1303
1304         printer = isl_printer_to_file(isl_pw_qpolynomial_get_ctx(pwqp), stderr);
1305         printer = isl_printer_print_pw_qpolynomial(printer, pwqp);
1306         printer = isl_printer_end_line(printer);
1307
1308         isl_printer_free(printer);
1309 }
1310
1311 void isl_pw_qpolynomial_fold_dump(__isl_keep isl_pw_qpolynomial_fold *pwf)
1312 {
1313         isl_printer *printer;
1314
1315         if (!pwf)
1316                 return;
1317
1318         printer = isl_printer_to_file(
1319                         isl_pw_qpolynomial_fold_get_ctx(pwf), stderr);
1320         printer = isl_printer_print_pw_qpolynomial_fold(printer, pwf);
1321         printer = isl_printer_end_line(printer);
1322
1323         isl_printer_free(printer);
1324 }
1325
1326 void isl_union_pw_qpolynomial_fold_dump(
1327         __isl_keep isl_union_pw_qpolynomial_fold *upwf)
1328 {
1329         isl_printer *printer;
1330
1331         if (!upwf)
1332                 return;
1333
1334         printer = isl_printer_to_file(
1335                         isl_union_pw_qpolynomial_fold_get_ctx(upwf), stderr);
1336         printer = isl_printer_print_union_pw_qpolynomial_fold(printer, upwf);
1337         printer = isl_printer_end_line(printer);
1338
1339         isl_printer_free(printer);
1340 }
1341
1342 static int upoly_rec_n_non_zero(__isl_keep struct isl_upoly_rec *rec)
1343 {
1344         int i;
1345         int n;
1346
1347         for (i = 0, n = 0; i < rec->n; ++i)
1348                 if (!isl_upoly_is_zero(rec->p[i]))
1349                         ++n;
1350
1351         return n;
1352 }
1353
1354 static __isl_give isl_printer *print_div(__isl_keep isl_dim *dim,
1355         __isl_keep isl_mat *div, int pos, __isl_take isl_printer *p)
1356 {
1357         int c = p->output_format == ISL_FORMAT_C;
1358         p = isl_printer_print_str(p, c ? "floord(" : "[(");
1359         p = print_affine_of_len(dim, div, p,
1360                                 div->row[pos] + 1, div->n_col - 1, 1);
1361         p = isl_printer_print_str(p, c ? ", " : ")/");
1362         p = isl_printer_print_isl_int(p, div->row[pos][0]);
1363         p = isl_printer_print_str(p, c ? ")" : "]");
1364         return p;
1365 }
1366
1367 static __isl_give isl_printer *upoly_print_cst(__isl_keep struct isl_upoly *up,
1368         __isl_take isl_printer *p, int first)
1369 {
1370         struct isl_upoly_cst *cst;
1371         int neg;
1372
1373         cst = isl_upoly_as_cst(up);
1374         if (!cst)
1375                 goto error;
1376         neg = !first && isl_int_is_neg(cst->n);
1377         if (!first)
1378                 p = isl_printer_print_str(p, neg ? " - " :  " + ");
1379         if (neg)
1380                 isl_int_neg(cst->n, cst->n);
1381         if (isl_int_is_zero(cst->d)) {
1382                 int sgn = isl_int_sgn(cst->n);
1383                 p = isl_printer_print_str(p, sgn < 0 ? "-infty" :
1384                                             sgn == 0 ? "NaN" : "infty");
1385         } else
1386                 p = isl_printer_print_isl_int(p, cst->n);
1387         if (neg)
1388                 isl_int_neg(cst->n, cst->n);
1389         if (!isl_int_is_zero(cst->d) && !isl_int_is_one(cst->d)) {
1390                 p = isl_printer_print_str(p, "/");
1391                 p = isl_printer_print_isl_int(p, cst->d);
1392         }
1393         return p;
1394 error:
1395         isl_printer_free(p);
1396         return NULL;
1397 }
1398
1399 static __isl_give isl_printer *print_base(__isl_take isl_printer *p,
1400         __isl_keep isl_dim *dim, __isl_keep isl_mat *div, int var)
1401 {
1402         unsigned total;
1403
1404         total = isl_dim_total(dim);
1405         if (var < total)
1406                 p = print_term(dim, NULL, dim->ctx->one, 1 + var, p, 1, 0);
1407         else
1408                 p = print_div(dim, div, var - total, p);
1409         return p;
1410 }
1411
1412 static __isl_give isl_printer *print_pow(__isl_take isl_printer *p,
1413         __isl_keep isl_dim *dim, __isl_keep isl_mat *div, int var, int exp)
1414 {
1415         p = print_base(p, dim, div, var);
1416         if (exp == 1)
1417                 return p;
1418         if (p->output_format == ISL_FORMAT_C) {
1419                 int i;
1420                 for (i = 1; i < exp; ++i) {
1421                         p = isl_printer_print_str(p, "*");
1422                         p = print_base(p, dim, div, var);
1423                 }
1424         } else {
1425                 p = isl_printer_print_str(p, "^");
1426                 p = isl_printer_print_int(p, exp);
1427         }
1428         return p;
1429 }
1430
1431 static __isl_give isl_printer *upoly_print(__isl_keep struct isl_upoly *up,
1432         __isl_keep isl_dim *dim, __isl_keep isl_mat *div,
1433         __isl_take isl_printer *p, int outer)
1434 {
1435         int i, n, first, print_parens;
1436         struct isl_upoly_rec *rec;
1437
1438         if (!p || !up || !dim || !div)
1439                 goto error;
1440
1441         if (isl_upoly_is_cst(up))
1442                 return upoly_print_cst(up, p, 1);
1443
1444         rec = isl_upoly_as_rec(up);
1445         if (!rec)
1446                 goto error;
1447         n = upoly_rec_n_non_zero(rec);
1448         print_parens = n > 1 || (outer && rec->up.var >= isl_dim_total(dim));
1449         if (print_parens)
1450                 p = isl_printer_print_str(p, "(");
1451         for (i = 0, first = 1; i < rec->n; ++i) {
1452                 if (isl_upoly_is_zero(rec->p[i]))
1453                         continue;
1454                 if (isl_upoly_is_negone(rec->p[i])) {
1455                         if (!i)
1456                                 p = isl_printer_print_str(p, "-1");
1457                         else if (first)
1458                                 p = isl_printer_print_str(p, "-");
1459                         else
1460                                 p = isl_printer_print_str(p, " - ");
1461                 } else if (isl_upoly_is_cst(rec->p[i]) &&
1462                                 !isl_upoly_is_one(rec->p[i]))
1463                         p = upoly_print_cst(rec->p[i], p, first);
1464                 else {
1465                         if (!first)
1466                                 p = isl_printer_print_str(p, " + ");
1467                         if (i == 0 || !isl_upoly_is_one(rec->p[i]))
1468                                 p = upoly_print(rec->p[i], dim, div, p, 0);
1469                 }
1470                 first = 0;
1471                 if (i == 0)
1472                         continue;
1473                 if (!isl_upoly_is_one(rec->p[i]) &&
1474                     !isl_upoly_is_negone(rec->p[i]))
1475                         p = isl_printer_print_str(p, " * ");
1476                 p = print_pow(p, dim, div, rec->up.var, i);
1477         }
1478         if (print_parens)
1479                 p = isl_printer_print_str(p, ")");
1480         return p;
1481 error:
1482         isl_printer_free(p);
1483         return NULL;
1484 }
1485
1486 static __isl_give isl_printer *print_qpolynomial(__isl_take isl_printer *p,
1487         __isl_keep isl_qpolynomial *qp)
1488 {
1489         if (!p || !qp)
1490                 goto error;
1491         p = upoly_print(qp->upoly, qp->dim, qp->div, p, 1);
1492         return p;
1493 error:
1494         isl_printer_free(p);
1495         return NULL;
1496 }
1497
1498 static __isl_give isl_printer *print_qpolynomial_isl(__isl_take isl_printer *p,
1499         __isl_keep isl_qpolynomial *qp)
1500 {
1501         if (!p || !qp)
1502                 goto error;
1503
1504         if (isl_dim_size(qp->dim, isl_dim_param) > 0) {
1505                 p = print_tuple(qp->dim, p, isl_dim_param, 0, 0, NULL);
1506                 p = isl_printer_print_str(p, " -> ");
1507         }
1508         p = isl_printer_print_str(p, "{ ");
1509         if (isl_dim_size(qp->dim, isl_dim_set) > 0 ||
1510             isl_dim_is_named_or_nested(qp->dim, isl_dim_set)) {
1511                 p = print_dim(qp->dim, p, 1, 0, 0, NULL);
1512                 p = isl_printer_print_str(p, " -> ");
1513         }
1514         p = print_qpolynomial(p, qp);
1515         p = isl_printer_print_str(p, " }");
1516         return p;
1517 error:
1518         isl_printer_free(p);
1519         return NULL;
1520 }
1521
1522 static __isl_give isl_printer *print_qpolynomial_c(__isl_take isl_printer *p,
1523         __isl_keep isl_dim *dim, __isl_keep isl_qpolynomial *qp)
1524 {
1525         isl_int den;
1526
1527         isl_int_init(den);
1528         isl_qpolynomial_get_den(qp, &den);
1529         if (!isl_int_is_one(den)) {
1530                 isl_qpolynomial *f;
1531                 p = isl_printer_print_str(p, "(");
1532                 qp = isl_qpolynomial_copy(qp);
1533                 f = isl_qpolynomial_rat_cst(isl_dim_copy(qp->dim),
1534                                                 den, qp->dim->ctx->one);
1535                 qp = isl_qpolynomial_mul(qp, f);
1536         }
1537         if (qp)
1538                 p = upoly_print(qp->upoly, dim, qp->div, p, 0);
1539         if (!isl_int_is_one(den)) {
1540                 p = isl_printer_print_str(p, ")/");
1541                 p = isl_printer_print_isl_int(p, den);
1542                 isl_qpolynomial_free(qp);
1543         }
1544         isl_int_clear(den);
1545         return p;
1546 }
1547
1548 __isl_give isl_printer *isl_printer_print_qpolynomial(
1549         __isl_take isl_printer *p, __isl_keep isl_qpolynomial *qp)
1550 {
1551         if (!p || !qp)
1552                 goto error;
1553
1554         if (p->output_format == ISL_FORMAT_ISL)
1555                 return print_qpolynomial_isl(p, qp);
1556         else if (p->output_format == ISL_FORMAT_C)
1557                 return print_qpolynomial_c(p, qp->dim, qp);
1558         else
1559                 isl_die(qp->dim->ctx, isl_error_unsupported,
1560                         "output format not supported for isl_qpolynomials",
1561                         goto error);
1562 error:
1563         isl_printer_free(p);
1564         return NULL;
1565 }
1566
1567 void isl_qpolynomial_print(__isl_keep isl_qpolynomial *qp, FILE *out,
1568         unsigned output_format)
1569 {
1570         isl_printer *p;
1571
1572         if  (!qp)
1573                 return;
1574
1575         isl_assert(qp->dim->ctx, output_format == ISL_FORMAT_ISL, return);
1576         p = isl_printer_to_file(qp->dim->ctx, out);
1577         p = isl_printer_print_qpolynomial(p, qp);
1578         isl_printer_free(p);
1579 }
1580
1581 static __isl_give isl_printer *qpolynomial_fold_print(
1582         __isl_keep isl_qpolynomial_fold *fold, __isl_take isl_printer *p)
1583 {
1584         int i;
1585
1586         if (fold->type == isl_fold_min)
1587                 p = isl_printer_print_str(p, "min");
1588         else if (fold->type == isl_fold_max)
1589                 p = isl_printer_print_str(p, "max");
1590         p = isl_printer_print_str(p, "(");
1591         for (i = 0; i < fold->n; ++i) {
1592                 if (i)
1593                         p = isl_printer_print_str(p, ", ");
1594                 p = print_qpolynomial(p, fold->qp[i]);
1595         }
1596         p = isl_printer_print_str(p, ")");
1597         return p;
1598 }
1599
1600 void isl_qpolynomial_fold_print(__isl_keep isl_qpolynomial_fold *fold,
1601         FILE *out, unsigned output_format)
1602 {
1603         isl_printer *p;
1604
1605         if (!fold)
1606                 return;
1607
1608         isl_assert(fold->dim->ctx, output_format == ISL_FORMAT_ISL, return);
1609
1610         p = isl_printer_to_file(fold->dim->ctx, out);
1611         p = isl_printer_print_qpolynomial_fold(p, fold);
1612
1613         isl_printer_free(p);
1614 }
1615
1616 static __isl_give isl_printer *isl_pwqp_print_isl_body(
1617         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial *pwqp)
1618 {
1619         int i = 0;
1620
1621         for (i = 0; i < pwqp->n; ++i) {
1622                 if (i)
1623                         p = isl_printer_print_str(p, "; ");
1624                 if (isl_dim_size(pwqp->dim, isl_dim_set) > 0 ||
1625                     isl_dim_is_named_or_nested(pwqp->dim, isl_dim_set)) {
1626                         p = print_dim(pwqp->p[i].set->dim, p, 1, 0, 0, NULL);
1627                         p = isl_printer_print_str(p, " -> ");
1628                 }
1629                 p = print_qpolynomial(p, pwqp->p[i].qp);
1630                 p = print_disjuncts((isl_map *)pwqp->p[i].set, p, 1, 0);
1631         }
1632
1633         return p;
1634 }
1635
1636 static __isl_give isl_printer *print_pw_qpolynomial_isl(
1637         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial *pwqp)
1638 {
1639         if (!p || !pwqp)
1640                 goto error;
1641
1642         if (isl_dim_size(pwqp->dim, isl_dim_param) > 0) {
1643                 p = print_tuple(pwqp->dim, p, isl_dim_param, 0, 0, NULL);
1644                 p = isl_printer_print_str(p, " -> ");
1645         }
1646         p = isl_printer_print_str(p, "{ ");
1647         if (pwqp->n == 0) {
1648                 if (isl_dim_size(pwqp->dim, isl_dim_set) > 0 ||
1649                     isl_dim_is_named_or_nested(pwqp->dim, isl_dim_set)) {
1650                         p = print_dim(pwqp->dim, p, 1, 0, 0, NULL);
1651                         p = isl_printer_print_str(p, " -> ");
1652                 }
1653                 p = isl_printer_print_str(p, "0");
1654         }
1655         p = isl_pwqp_print_isl_body(p, pwqp);
1656         p = isl_printer_print_str(p, " }");
1657         return p;
1658 error:
1659         isl_printer_free(p);
1660         return NULL;
1661 }
1662
1663 void isl_pw_qpolynomial_print(__isl_keep isl_pw_qpolynomial *pwqp, FILE *out,
1664         unsigned output_format)
1665 {
1666         isl_printer *p;
1667
1668         if (!pwqp)
1669                 return;
1670
1671         p = isl_printer_to_file(pwqp->dim->ctx, out);
1672         p = isl_printer_set_output_format(p, output_format);
1673         p = isl_printer_print_pw_qpolynomial(p, pwqp);
1674
1675         isl_printer_free(p);
1676 }
1677
1678 static __isl_give isl_printer *isl_pwf_print_isl_body(
1679         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial_fold *pwf)
1680 {
1681         int i = 0;
1682
1683         for (i = 0; i < pwf->n; ++i) {
1684                 if (i)
1685                         p = isl_printer_print_str(p, "; ");
1686                 if (isl_dim_size(pwf->dim, isl_dim_set) > 0 ||
1687                     isl_dim_is_named_or_nested(pwf->dim, isl_dim_set)) {
1688                         p = print_dim(pwf->p[i].set->dim, p, 1, 0, 0, NULL);
1689                         p = isl_printer_print_str(p, " -> ");
1690                 }
1691                 p = qpolynomial_fold_print(pwf->p[i].fold, p);
1692                 p = print_disjuncts((isl_map *)pwf->p[i].set, p, 1, 0);
1693         }
1694
1695         return p;
1696 }
1697
1698 static __isl_give isl_printer *print_pw_qpolynomial_fold_isl(
1699         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial_fold *pwf)
1700 {
1701         if (isl_dim_size(pwf->dim, isl_dim_param) > 0) {
1702                 p = print_tuple(pwf->dim, p, isl_dim_param, 0, 0, NULL);
1703                 p = isl_printer_print_str(p, " -> ");
1704         }
1705         p = isl_printer_print_str(p, "{ ");
1706         if (pwf->n == 0) {
1707                 if (isl_dim_size(pwf->dim, isl_dim_set) > 0 ||
1708                     isl_dim_is_named_or_nested(pwf->dim, isl_dim_set)) {
1709                         p = print_dim(pwf->dim, p, 1, 0, 0, NULL);
1710                         p = isl_printer_print_str(p, " -> ");
1711                 }
1712                 p = isl_printer_print_str(p, "0");
1713         }
1714         p = isl_pwf_print_isl_body(p, pwf);
1715         p = isl_printer_print_str(p, " }");
1716         return p;
1717 }
1718
1719 static __isl_give isl_printer *print_affine_c(__isl_take isl_printer *p,
1720         __isl_keep isl_dim *dim, __isl_keep isl_basic_set *bset, isl_int *c);
1721
1722 static __isl_give isl_printer *print_name_c(__isl_take isl_printer *p,
1723         __isl_keep isl_dim *dim,
1724         __isl_keep isl_basic_set *bset, enum isl_dim_type type, unsigned pos)
1725 {
1726         if (type == isl_dim_div) {
1727                 p = isl_printer_print_str(p, "floord(");
1728                 p = print_affine_c(p, dim, bset, bset->div[pos] + 1);
1729                 p = isl_printer_print_str(p, ", ");
1730                 p = isl_printer_print_isl_int(p, bset->div[pos][0]);
1731                 p = isl_printer_print_str(p, ")");
1732         } else {
1733                 const char *name;
1734
1735                 name = isl_dim_get_name(dim, type, pos);
1736                 if (!name)
1737                         name = "UNNAMED";
1738                 p = isl_printer_print_str(p, name);
1739         }
1740         return p;
1741 }
1742
1743 static __isl_give isl_printer *print_term_c(__isl_take isl_printer *p,
1744         __isl_keep isl_dim *dim,
1745         __isl_keep isl_basic_set *bset, isl_int c, unsigned pos)
1746 {
1747         enum isl_dim_type type;
1748
1749         if (pos == 0)
1750                 return isl_printer_print_isl_int(p, c);
1751
1752         if (isl_int_is_one(c))
1753                 ;
1754         else if (isl_int_is_negone(c))
1755                 p = isl_printer_print_str(p, "-");
1756         else {
1757                 p = isl_printer_print_isl_int(p, c);
1758                 p = isl_printer_print_str(p, "*");
1759         }
1760         type = pos2type(dim, &pos);
1761         p = print_name_c(p, dim, bset, type, pos);
1762         return p;
1763 }
1764
1765 static __isl_give isl_printer *print_partial_affine_c(__isl_take isl_printer *p,
1766         __isl_keep isl_dim *dim,
1767         __isl_keep isl_basic_set *bset, isl_int *c, unsigned len)
1768 {
1769         int i;
1770         int first;
1771
1772         for (i = 0, first = 1; i < len; ++i) {
1773                 int flip = 0;
1774                 if (isl_int_is_zero(c[i]))
1775                         continue;
1776                 if (!first) {
1777                         if (isl_int_is_neg(c[i])) {
1778                                 flip = 1;
1779                                 isl_int_neg(c[i], c[i]);
1780                                 p = isl_printer_print_str(p, " - ");
1781                         } else
1782                                 p = isl_printer_print_str(p, " + ");
1783                 }
1784                 first = 0;
1785                 p = print_term_c(p, dim, bset, c[i], i);
1786                 if (flip)
1787                         isl_int_neg(c[i], c[i]);
1788         }
1789         if (first)
1790                 p = isl_printer_print_str(p, "0");
1791         return p;
1792 }
1793
1794 static __isl_give isl_printer *print_affine_c(__isl_take isl_printer *p,
1795         __isl_keep isl_dim *dim, __isl_keep isl_basic_set *bset, isl_int *c)
1796 {
1797         unsigned len = 1 + isl_basic_set_total_dim(bset);
1798         return print_partial_affine_c(p, dim, bset, c, len);
1799 }
1800
1801 static __isl_give isl_printer *print_constraint_c(__isl_take isl_printer *p,
1802         __isl_keep isl_dim *dim,
1803         __isl_keep isl_basic_set *bset, isl_int *c, const char *op, int first)
1804 {
1805         if (!first)
1806                 p = isl_printer_print_str(p, " && ");
1807
1808         p = print_affine_c(p, dim, bset, c);
1809         p = isl_printer_print_str(p, " ");
1810         p = isl_printer_print_str(p, op);
1811         p = isl_printer_print_str(p, " 0");
1812         return p;
1813 }
1814
1815 static __isl_give isl_printer *print_basic_set_c(__isl_take isl_printer *p,
1816         __isl_keep isl_dim *dim, __isl_keep isl_basic_set *bset)
1817 {
1818         int i, j;
1819         unsigned n_div = isl_basic_set_dim(bset, isl_dim_div);
1820         unsigned total = isl_basic_set_total_dim(bset) - n_div;
1821
1822         for (i = 0; i < bset->n_eq; ++i) {
1823                 j = isl_seq_last_non_zero(bset->eq[i] + 1 + total, n_div);
1824                 if (j < 0)
1825                         p = print_constraint_c(p, dim, bset,
1826                                                 bset->eq[i], "==", !i);
1827                 else {
1828                         if (i)
1829                                 p = isl_printer_print_str(p, " && ");
1830                         p = isl_printer_print_str(p, "(");
1831                         p = print_partial_affine_c(p, dim, bset, bset->eq[i],
1832                                                    1 + total + j);
1833                         p = isl_printer_print_str(p, ") % ");
1834                         p = isl_printer_print_isl_int(p,
1835                                                 bset->eq[i][1 + total + j]);
1836                         p = isl_printer_print_str(p, " == 0");
1837                 }
1838         }
1839         for (i = 0; i < bset->n_ineq; ++i)
1840                 p = print_constraint_c(p, dim, bset, bset->ineq[i], ">=",
1841                                         !bset->n_eq && !i);
1842         return p;
1843 }
1844
1845 static __isl_give isl_printer *print_set_c(__isl_take isl_printer *p,
1846         __isl_keep isl_dim *dim, __isl_keep isl_set *set)
1847 {
1848         int i;
1849
1850         if (set->n == 0)
1851                 p = isl_printer_print_str(p, "0");
1852
1853         for (i = 0; i < set->n; ++i) {
1854                 if (i)
1855                         p = isl_printer_print_str(p, " || ");
1856                 if (set->n > 1)
1857                         p = isl_printer_print_str(p, "(");
1858                 p = print_basic_set_c(p, dim, set->p[i]);
1859                 if (set->n > 1)
1860                         p = isl_printer_print_str(p, ")");
1861         }
1862         return p;
1863 }
1864
1865 static __isl_give isl_printer *print_pw_qpolynomial_c(
1866         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial *pwqp)
1867 {
1868         int i;
1869
1870         if (pwqp->n == 1 && isl_set_plain_is_universe(pwqp->p[0].set))
1871                 return print_qpolynomial_c(p, pwqp->dim, pwqp->p[0].qp);
1872
1873         for (i = 0; i < pwqp->n; ++i) {
1874                 p = isl_printer_print_str(p, "(");
1875                 p = print_set_c(p, pwqp->dim, pwqp->p[i].set);
1876                 p = isl_printer_print_str(p, ") ? (");
1877                 p = print_qpolynomial_c(p, pwqp->dim, pwqp->p[i].qp);
1878                 p = isl_printer_print_str(p, ") : ");
1879         }
1880
1881         p = isl_printer_print_str(p, "0");
1882         return p;
1883 }
1884
1885 __isl_give isl_printer *isl_printer_print_pw_qpolynomial(
1886         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial *pwqp)
1887 {
1888         if (!p || !pwqp)
1889                 goto error;
1890
1891         if (p->output_format == ISL_FORMAT_ISL)
1892                 return print_pw_qpolynomial_isl(p, pwqp);
1893         else if (p->output_format == ISL_FORMAT_C)
1894                 return print_pw_qpolynomial_c(p, pwqp);
1895         isl_assert(p->ctx, 0, goto error);
1896 error:
1897         isl_printer_free(p);
1898         return NULL;
1899 }
1900
1901 static int print_pwqp_body(__isl_take isl_pw_qpolynomial *pwqp, void *user)
1902 {
1903         struct isl_union_print_data *data;
1904         data = (struct isl_union_print_data *)user;
1905
1906         if (!data->first)
1907                 data->p = isl_printer_print_str(data->p, "; ");
1908         data->first = 0;
1909
1910         data->p = isl_pwqp_print_isl_body(data->p, pwqp);
1911         isl_pw_qpolynomial_free(pwqp);
1912
1913         return 0;
1914 }
1915
1916 static __isl_give isl_printer *print_union_pw_qpolynomial_isl(
1917         __isl_take isl_printer *p, __isl_keep isl_union_pw_qpolynomial *upwqp)
1918 {
1919         struct isl_union_print_data data = { p, 1, 1 };
1920         isl_dim *dim;
1921         dim = isl_union_pw_qpolynomial_get_dim(upwqp);
1922         if (isl_dim_size(dim, isl_dim_param) > 0) {
1923                 p = print_tuple(dim, p, isl_dim_param, 1, 0, NULL);
1924                 p = isl_printer_print_str(p, " -> ");
1925         }
1926         isl_dim_free(dim);
1927         p = isl_printer_print_str(p, "{ ");
1928         isl_union_pw_qpolynomial_foreach_pw_qpolynomial(upwqp, &print_pwqp_body,
1929                                                         &data);
1930         p = data.p;
1931         p = isl_printer_print_str(p, " }");
1932         return p;
1933 }
1934
1935 __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial(
1936         __isl_take isl_printer *p, __isl_keep isl_union_pw_qpolynomial *upwqp)
1937 {
1938         if (!p || !upwqp)
1939                 goto error;
1940
1941         if (p->output_format == ISL_FORMAT_ISL)
1942                 return print_union_pw_qpolynomial_isl(p, upwqp);
1943         isl_die(p->ctx, isl_error_invalid,
1944                 "invalid output format for isl_union_pw_qpolynomial",
1945                 goto error);
1946 error:
1947         isl_printer_free(p);
1948         return NULL;
1949 }
1950
1951 static __isl_give isl_printer *print_qpolynomial_fold_c(
1952         __isl_take isl_printer *p, __isl_keep isl_dim *dim,
1953         __isl_keep isl_qpolynomial_fold *fold)
1954 {
1955         int i;
1956
1957         for (i = 0; i < fold->n - 1; ++i)
1958                 if (fold->type == isl_fold_min)
1959                         p = isl_printer_print_str(p, "min(");
1960                 else if (fold->type == isl_fold_max)
1961                         p = isl_printer_print_str(p, "max(");
1962
1963         for (i = 0; i < fold->n; ++i) {
1964                 if (i)
1965                         p = isl_printer_print_str(p, ", ");
1966                 p = print_qpolynomial_c(p, dim, fold->qp[i]);
1967                 if (i)
1968                         p = isl_printer_print_str(p, ")");
1969         }
1970         return p;
1971 }
1972
1973 __isl_give isl_printer *isl_printer_print_qpolynomial_fold(
1974         __isl_take isl_printer *p, __isl_keep isl_qpolynomial_fold *fold)
1975 {
1976         if  (!p || !fold)
1977                 goto error;
1978         if (p->output_format == ISL_FORMAT_ISL)
1979                 return qpolynomial_fold_print(fold, p);
1980         else if (p->output_format == ISL_FORMAT_C)
1981                 return print_qpolynomial_fold_c(p, fold->dim, fold);
1982         isl_die(p->ctx, isl_error_unsupported, "unsupported output format",
1983                 goto error);
1984 error:
1985         isl_printer_free(p);
1986         return NULL;
1987 }
1988
1989 static __isl_give isl_printer *print_pw_qpolynomial_fold_c(
1990         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial_fold *pwf)
1991 {
1992         int i;
1993
1994         if (pwf->n == 1 && isl_set_plain_is_universe(pwf->p[0].set))
1995                 return print_qpolynomial_fold_c(p, pwf->dim, pwf->p[0].fold);
1996
1997         for (i = 0; i < pwf->n; ++i) {
1998                 p = isl_printer_print_str(p, "(");
1999                 p = print_set_c(p, pwf->dim, pwf->p[i].set);
2000                 p = isl_printer_print_str(p, ") ? (");
2001                 p = print_qpolynomial_fold_c(p, pwf->dim, pwf->p[i].fold);
2002                 p = isl_printer_print_str(p, ") : ");
2003         }
2004
2005         p = isl_printer_print_str(p, "0");
2006         return p;
2007 }
2008
2009 __isl_give isl_printer *isl_printer_print_pw_qpolynomial_fold(
2010         __isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial_fold *pwf)
2011 {
2012         if (!p || !pwf)
2013                 goto error;
2014
2015         if (p->output_format == ISL_FORMAT_ISL)
2016                 return print_pw_qpolynomial_fold_isl(p, pwf);
2017         else if (p->output_format == ISL_FORMAT_C)
2018                 return print_pw_qpolynomial_fold_c(p, pwf);
2019         isl_assert(p->ctx, 0, goto error);
2020 error:
2021         isl_printer_free(p);
2022         return NULL;
2023 }
2024
2025 void isl_pw_qpolynomial_fold_print(__isl_keep isl_pw_qpolynomial_fold *pwf,
2026         FILE *out, unsigned output_format)
2027 {
2028         isl_printer *p;
2029
2030         if (!pwf)
2031                 return;
2032
2033         p = isl_printer_to_file(pwf->dim->ctx, out);
2034         p = isl_printer_set_output_format(p, output_format);
2035         p = isl_printer_print_pw_qpolynomial_fold(p, pwf);
2036
2037         isl_printer_free(p);
2038 }
2039
2040 static int print_pwf_body(__isl_take isl_pw_qpolynomial_fold *pwf, void *user)
2041 {
2042         struct isl_union_print_data *data;
2043         data = (struct isl_union_print_data *)user;
2044
2045         if (!data->first)
2046                 data->p = isl_printer_print_str(data->p, "; ");
2047         data->first = 0;
2048
2049         data->p = isl_pwf_print_isl_body(data->p, pwf);
2050         isl_pw_qpolynomial_fold_free(pwf);
2051
2052         return 0;
2053 }
2054
2055 static __isl_give isl_printer *print_union_pw_qpolynomial_fold_isl(
2056         __isl_take isl_printer *p,
2057         __isl_keep isl_union_pw_qpolynomial_fold *upwf)
2058 {
2059         struct isl_union_print_data data = { p, 1, 1 };
2060         isl_dim *dim;
2061         dim = isl_union_pw_qpolynomial_fold_get_dim(upwf);
2062         if (isl_dim_size(dim, isl_dim_param) > 0) {
2063                 p = print_tuple(dim, p, isl_dim_param, 1, 0, NULL);
2064                 p = isl_printer_print_str(p, " -> ");
2065         }
2066         isl_dim_free(dim);
2067         p = isl_printer_print_str(p, "{ ");
2068         isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(upwf,
2069                                                         &print_pwf_body, &data);
2070         p = data.p;
2071         p = isl_printer_print_str(p, " }");
2072         return p;
2073 }
2074
2075 __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial_fold(
2076         __isl_take isl_printer *p,
2077         __isl_keep isl_union_pw_qpolynomial_fold *upwf)
2078 {
2079         if (!p || !upwf)
2080                 goto error;
2081
2082         if (p->output_format == ISL_FORMAT_ISL)
2083                 return print_union_pw_qpolynomial_fold_isl(p, upwf);
2084         isl_die(p->ctx, isl_error_invalid,
2085                 "invalid output format for isl_union_pw_qpolynomial_fold",
2086                 goto error);
2087 error:
2088         isl_printer_free(p);
2089         return NULL;
2090 }
2091
2092 __isl_give isl_printer *isl_printer_print_constraint(__isl_take isl_printer *p,
2093         __isl_keep isl_constraint *c)
2094 {
2095         isl_basic_map *bmap;
2096
2097         if (!p || !c)
2098                 goto error;
2099
2100         bmap = isl_basic_map_from_constraint(isl_constraint_copy(c));
2101         p = isl_printer_print_basic_map(p, bmap);
2102         isl_basic_map_free(bmap);
2103         return p;
2104 error:
2105         isl_printer_free(p);
2106         return NULL;
2107 }
2108
2109 void isl_constraint_dump(__isl_keep isl_constraint *c)
2110 {
2111         isl_printer *printer;
2112
2113         if (!c)
2114                 return;
2115
2116         printer = isl_printer_to_file(isl_constraint_get_ctx(c), stderr);
2117         printer = isl_printer_print_constraint(printer, c);
2118         printer = isl_printer_end_line(printer);
2119
2120         isl_printer_free(printer);
2121 }
2122
2123 __isl_give isl_printer *isl_printer_print_dim(__isl_take isl_printer *p,
2124         __isl_keep isl_dim *dim)
2125 {
2126         if (!dim)
2127                 goto error;
2128
2129         if (isl_dim_size(dim, isl_dim_param) > 0) {
2130                 p = print_tuple(dim, p, isl_dim_param, 0, 0, NULL);
2131                 p = isl_printer_print_str(p, " -> ");
2132         }
2133
2134         p = isl_printer_print_str(p, "{ ");
2135         p = print_tuple(dim, p, isl_dim_in, 0, 0, NULL);
2136         p = isl_printer_print_str(p, " -> ");
2137         p = print_tuple(dim, p, isl_dim_out, 0, 0, NULL);
2138         p = isl_printer_print_str(p, " }");
2139
2140         return p;
2141 error:
2142         isl_printer_free(p);
2143         return NULL;
2144 }
2145
2146 void isl_dim_dump(__isl_keep isl_dim *dim)
2147 {
2148         isl_printer *printer;
2149
2150         if (!dim)
2151                 return;
2152
2153         printer = isl_printer_to_file(isl_dim_get_ctx(dim), stderr);
2154         printer = isl_printer_print_dim(printer, dim);
2155         printer = isl_printer_end_line(printer);
2156
2157         isl_printer_free(printer);
2158 }
2159
2160 __isl_give isl_printer *isl_printer_print_local_space(__isl_take isl_printer *p,
2161         __isl_keep isl_local_space *ls)
2162 {
2163         unsigned total;
2164         unsigned n_div;
2165
2166         if (!ls)
2167                 goto error;
2168
2169         total = isl_local_space_dim(ls, isl_dim_all);
2170         if (isl_local_space_dim(ls, isl_dim_param) > 0) {
2171                 p = print_tuple(ls->dim, p, isl_dim_param, 0, 0, NULL);
2172                 p = isl_printer_print_str(p, " -> ");
2173         }
2174         p = isl_printer_print_str(p, "{ ");
2175         p = print_tuple(ls->dim, p, isl_dim_in, 0, 0, NULL);
2176         p = isl_printer_print_str(p, " -> ");
2177         p = print_tuple(ls->dim, p, isl_dim_out, 0, 0, NULL);
2178         n_div = isl_local_space_dim(ls, isl_dim_div);
2179         if (n_div > 0) {
2180                 int i;
2181                 p = isl_printer_print_str(p, " : ");
2182                 p = isl_printer_print_str(p, s_open_exists[0]);
2183                 for (i = 0; i < n_div; ++i) {
2184                         if (i)
2185                                 p = isl_printer_print_str(p, ", ");
2186                         p = print_name(ls->dim, p, isl_dim_div, i, 0, 0);
2187                         if (isl_int_is_zero(ls->div->row[i][0]))
2188                                 continue;
2189                         p = isl_printer_print_str(p, " = [(");
2190                         p = print_affine_of_len(ls->dim, ls->div, p,
2191                                             ls->div->row[i] + 1, 1 + total, 0);
2192                         p = isl_printer_print_str(p, ")/");
2193                         p = isl_printer_print_isl_int(p, ls->div->row[i][0]);
2194                         p = isl_printer_print_str(p, "]");
2195                 }
2196         }
2197         p = isl_printer_print_str(p, " }");
2198         return p;
2199 error:
2200         isl_printer_free(p);
2201         return NULL;
2202 }
2203
2204 void isl_local_space_dump(__isl_keep isl_local_space *ls)
2205 {
2206         isl_printer *printer;
2207
2208         if (!ls)
2209                 return;
2210
2211         printer = isl_printer_to_file(isl_local_space_get_ctx(ls), stderr);
2212         printer = isl_printer_print_local_space(printer, ls);
2213         printer = isl_printer_end_line(printer);
2214
2215         isl_printer_free(printer);
2216 }
2217
2218 static __isl_give isl_printer *print_aff(__isl_take isl_printer *p,
2219         __isl_keep isl_aff *aff)
2220 {
2221         unsigned total;
2222
2223         total = isl_local_space_dim(aff->ls, isl_dim_all);
2224         p = print_tuple(aff->ls->dim, p, isl_dim_set, 1, 0, NULL);
2225         p = isl_printer_print_str(p, " -> [");
2226         p = isl_printer_print_str(p, "(");
2227         p = print_affine_of_len(aff->ls->dim, aff->ls->div, p,
2228                                 aff->v->el + 1, 1 + total, 1);
2229         if (isl_int_is_one(aff->v->el[0]))
2230                 p = isl_printer_print_str(p, ")");
2231         else {
2232                 p = isl_printer_print_str(p, ")/");
2233                 p = isl_printer_print_isl_int(p, aff->v->el[0]);
2234         }
2235         p = isl_printer_print_str(p, "]");
2236
2237         return p;
2238 }
2239
2240 __isl_give isl_printer *isl_printer_print_aff(__isl_take isl_printer *p,
2241         __isl_keep isl_aff *aff)
2242 {
2243         if (!aff)
2244                 goto error;
2245
2246         if (isl_local_space_dim(aff->ls, isl_dim_param) > 0) {
2247                 p = print_tuple(aff->ls->dim, p, isl_dim_param, 0, 0, NULL);
2248                 p = isl_printer_print_str(p, " -> ");
2249         }
2250         p = isl_printer_print_str(p, "{ ");
2251         p = print_aff(p, aff);
2252         p = isl_printer_print_str(p, " }");
2253         return p;
2254 error:
2255         isl_printer_free(p);
2256         return NULL;
2257 }
2258
2259 void isl_aff_dump(__isl_keep isl_aff *aff)
2260 {
2261         isl_printer *printer;
2262
2263         if (!aff)
2264                 return;
2265
2266         printer = isl_printer_to_file(isl_aff_get_ctx(aff), stderr);
2267         printer = isl_printer_print_aff(printer, aff);
2268         printer = isl_printer_end_line(printer);
2269
2270         isl_printer_free(printer);
2271 }
2272
2273 static __isl_give isl_printer *print_pw_aff_isl(__isl_take isl_printer *p,
2274         __isl_keep isl_pw_aff *pwaff)
2275 {
2276         int i;
2277
2278         if (!pwaff)
2279                 goto error;
2280
2281         if (isl_dim_size(pwaff->dim, isl_dim_param) > 0) {
2282                 p = print_tuple(pwaff->dim, p, isl_dim_param, 0, 0, NULL);
2283                 p = isl_printer_print_str(p, " -> ");
2284         }
2285         p = isl_printer_print_str(p, "{ ");
2286         for (i = 0; i < pwaff->n; ++i) {
2287                 if (i)
2288                         p = isl_printer_print_str(p, "; ");
2289                 p = print_aff(p, pwaff->p[i].aff);
2290                 p = print_disjuncts((isl_map *)pwaff->p[i].set, p, 1, 0);
2291         }
2292         p = isl_printer_print_str(p, " }");
2293         return p;
2294 error:
2295         isl_printer_free(p);
2296         return NULL;
2297 }
2298
2299 static __isl_give isl_printer *print_ls_affine_c(__isl_take isl_printer *p,
2300         __isl_keep isl_local_space *ls, isl_int *c);
2301
2302 static __isl_give isl_printer *print_ls_name_c(__isl_take isl_printer *p,
2303         __isl_keep isl_local_space *ls, enum isl_dim_type type, unsigned pos)
2304 {
2305         if (type == isl_dim_div) {
2306                 p = isl_printer_print_str(p, "floord(");
2307                 p = print_ls_affine_c(p, ls, ls->div->row[pos] + 1);
2308                 p = isl_printer_print_str(p, ", ");
2309                 p = isl_printer_print_isl_int(p, ls->div->row[pos][0]);
2310                 p = isl_printer_print_str(p, ")");
2311         } else {
2312                 const char *name;
2313
2314                 name = isl_dim_get_name(ls->dim, type, pos);
2315                 if (!name)
2316                         name = "UNNAMED";
2317                 p = isl_printer_print_str(p, name);
2318         }
2319         return p;
2320 }
2321
2322 static __isl_give isl_printer *print_ls_term_c(__isl_take isl_printer *p,
2323         __isl_keep isl_local_space *ls, isl_int c, unsigned pos)
2324 {
2325         enum isl_dim_type type;
2326
2327         if (pos == 0)
2328                 return isl_printer_print_isl_int(p, c);
2329
2330         if (isl_int_is_one(c))
2331                 ;
2332         else if (isl_int_is_negone(c))
2333                 p = isl_printer_print_str(p, "-");
2334         else {
2335                 p = isl_printer_print_isl_int(p, c);
2336                 p = isl_printer_print_str(p, "*");
2337         }
2338         type = pos2type(ls->dim, &pos);
2339         p = print_ls_name_c(p, ls, type, pos);
2340         return p;
2341 }
2342
2343 static __isl_give isl_printer *print_ls_partial_affine_c(
2344         __isl_take isl_printer *p, __isl_keep isl_local_space *ls,
2345         isl_int *c, unsigned len)
2346 {
2347         int i;
2348         int first;
2349
2350         for (i = 0, first = 1; i < len; ++i) {
2351                 int flip = 0;
2352                 if (isl_int_is_zero(c[i]))
2353                         continue;
2354                 if (!first) {
2355                         if (isl_int_is_neg(c[i])) {
2356                                 flip = 1;
2357                                 isl_int_neg(c[i], c[i]);
2358                                 p = isl_printer_print_str(p, " - ");
2359                         } else
2360                                 p = isl_printer_print_str(p, " + ");
2361                 }
2362                 first = 0;
2363                 p = print_ls_term_c(p, ls, c[i], i);
2364                 if (flip)
2365                         isl_int_neg(c[i], c[i]);
2366         }
2367         if (first)
2368                 p = isl_printer_print_str(p, "0");
2369         return p;
2370 }
2371
2372 static __isl_give isl_printer *print_ls_affine_c(__isl_take isl_printer *p,
2373         __isl_keep isl_local_space *ls, isl_int *c)
2374 {
2375         unsigned len = 1 + isl_local_space_dim(ls, isl_dim_all);
2376         return print_ls_partial_affine_c(p, ls, c, len);
2377 }
2378
2379 static __isl_give isl_printer *print_aff_c(__isl_take isl_printer *p,
2380         __isl_keep isl_aff *aff)
2381 {
2382         unsigned total;
2383
2384         total = isl_local_space_dim(aff->ls, isl_dim_all);
2385         p = isl_printer_print_str(p, "(");
2386         p = print_ls_partial_affine_c(p, aff->ls, aff->v->el + 1, 1 + total);
2387         if (isl_int_is_one(aff->v->el[0]))
2388                 p = isl_printer_print_str(p, ")");
2389         else {
2390                 p = isl_printer_print_str(p, ")/");
2391                 p = isl_printer_print_isl_int(p, aff->v->el[0]);
2392         }
2393         return p;
2394 }
2395
2396 static __isl_give isl_printer *print_pw_aff_c(__isl_take isl_printer *p,
2397         __isl_keep isl_pw_aff *pwaff)
2398 {
2399         int i;
2400
2401         if (pwaff->n < 1)
2402                 isl_die(p->ctx, isl_error_unsupported,
2403                         "cannot print empty isl_pw_aff in C format", goto error);
2404
2405         for (i = 0; i < pwaff->n - 1; ++i) {
2406                 p = isl_printer_print_str(p, "(");
2407                 p = print_set_c(p, pwaff->dim, pwaff->p[i].set);
2408                 p = isl_printer_print_str(p, ") ? (");
2409                 p = print_aff_c(p, pwaff->p[i].aff);
2410                 p = isl_printer_print_str(p, ") : ");
2411         }
2412
2413         return print_aff_c(p, pwaff->p[pwaff->n - 1].aff);
2414 error:
2415         isl_printer_free(p);
2416         return NULL;
2417 }
2418
2419 __isl_give isl_printer *isl_printer_print_pw_aff(__isl_take isl_printer *p,
2420         __isl_keep isl_pw_aff *pwaff)
2421 {
2422         if (!p || !pwaff)
2423                 goto error;
2424
2425         if (p->output_format == ISL_FORMAT_ISL)
2426                 return print_pw_aff_isl(p, pwaff);
2427         else if (p->output_format == ISL_FORMAT_C)
2428                 return print_pw_aff_c(p, pwaff);
2429         isl_die(p->ctx, isl_error_unsupported, "unsupported output format",
2430                 goto error);
2431 error:
2432         isl_printer_free(p);
2433         return NULL;
2434 }
2435
2436 void isl_pw_aff_dump(__isl_keep isl_pw_aff *pwaff)
2437 {
2438         isl_printer *printer;
2439
2440         if (!pwaff)
2441                 return;
2442
2443         printer = isl_printer_to_file(isl_pw_aff_get_ctx(pwaff), stderr);
2444         printer = isl_printer_print_pw_aff(printer, pwaff);
2445         printer = isl_printer_end_line(printer);
2446
2447         isl_printer_free(printer);
2448 }