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 <isl_set.h>
  14
  15 static void print_constraint_polylib(struct isl_basic_set *bset,
  16         int ineq, int n,
  17         FILE *out, int indent, const char *prefix, const char *suffix)
  18 {
  19         int i;
  20         unsigned dim = isl_basic_set_n_dim(bset);
  21         unsigned nparam = isl_basic_set_n_param(bset);
  22         isl_int *c = ineq ? bset->ineq[n] : bset->eq[n];
  23
  24         fprintf(out, "%*s%s", indent, "", prefix ? prefix : "");
  25         fprintf(out, "%d", ineq);
  26         for (i = 0; i < dim; ++i) {
  27                 fprintf(out, " ");
  28                 isl_int_print(out, c[1+nparam+i], 5);
  29         }
  30         for (i = 0; i < bset->n_div; ++i) {
  31                 fprintf(out, " ");
  32                 isl_int_print(out, c[1+nparam+dim+i], 5);
  33         }
  34         for (i = 0; i < nparam; ++i) {
  35                 fprintf(out, " ");
  36                 isl_int_print(out, c[1+i], 5);
  37         }
  38         fprintf(out, " ");
  39         isl_int_print(out, c[0], 5);
  40         fprintf(out, "%s\n", suffix ? suffix : "");
  41 }
  42
  43 static void print_constraints_polylib(struct isl_basic_set *bset,
  44         FILE *out, int indent, const char *prefix, const char *suffix)
  45 {
  46         int i;
  47
  48         for (i = 0; i < bset->n_eq; ++i)
  49                 print_constraint_polylib(bset, 0, i, out,
  50                                         indent, prefix, suffix);
  51         for (i = 0; i < bset->n_ineq; ++i)
  52                 print_constraint_polylib(bset, 1, i, out,
  53                                         indent, prefix, suffix);
  54 }
  55
  56 static void isl_basic_set_print_polylib(struct isl_basic_set *bset, FILE *out,
  57         int indent, const char *prefix, const char *suffix)
  58 {
  59         unsigned total = isl_basic_set_total_dim(bset);
  60         fprintf(out, "%*s%s", indent, "", prefix ? prefix : "");
  61         fprintf(out, "%d %d", bset->n_eq + bset->n_ineq, 1 + total + 1);
  62         fprintf(out, "%s\n", suffix ? suffix : "");
  63         print_constraints_polylib(bset, out, indent, prefix, suffix);
  64 }
  65
  66 static void isl_set_print_polylib(struct isl_set *set, FILE *out, int indent)
  67 {
  68         int i;
  69
  70         fprintf(out, "%*s", indent, "");
  71         fprintf(out, "%d\n", set->n);
  72         for (i = 0; i < set->n; ++i) {
  73                 fprintf(out, "\n");
  74                 isl_basic_set_print_polylib(set->p[i], out, indent, NULL, NULL);
  75         }
  76 }
  77
  78 static print_name(struct isl_dim *dim, FILE *out,
  79         enum isl_dim_type type, unsigned pos, int set)
  80 {
  81         const char *name;
  82
  83         name = type == isl_dim_div ? NULL : isl_dim_get_name(dim, type, pos);
  84
  85         if (name)
  86                 fprintf(out, "%s", name);
  87         else {
  88                 const char *prefix;
  89                 if (type == isl_dim_param)
  90                         prefix = "p";
  91                 else if (type == isl_dim_div)
  92                         prefix = "e";
  93                 else if (set || type == isl_dim_in)
  94                         prefix = "i";
  95                 else
  96                         prefix = "o";
  97                 fprintf(out, "%s%d", prefix, pos);
  98         }
  99 }
 100
 101 static void print_var_list(struct isl_dim *dim, FILE *out,
 102         enum isl_dim_type type, int set)
 103 {
 104         int i;
 105
 106         for (i = 0; i < isl_dim_size(dim, type); ++i) {
 107                 if (i)
 108                         fprintf(out, ", ");
 109                 print_name(dim, out, type, i, set);
 110         }
 111 }
 112
 113 static void print_tuple(__isl_keep isl_dim *dim, FILE *out,
 114         enum isl_dim_type type, int set)
 115 {
 116         fprintf(out, "[");
 117         print_var_list(dim, out, type, set);
 118         fprintf(out, "]");
 119 }
 120
 121 static void print_term(__isl_keep isl_dim *dim,
 122                         isl_int c, int pos, FILE *out, int set)
 123 {
 124         enum isl_dim_type type;
 125         unsigned n_in = isl_dim_size(dim, isl_dim_in);
 126         unsigned n_out = isl_dim_size(dim, isl_dim_out);
 127         unsigned nparam = isl_dim_size(dim, isl_dim_param);
 128
 129         if (pos == 0) {
 130                 isl_int_print(out, c, 0);
 131                 return;
 132         }
 133
 134         if (!isl_int_is_one(c))
 135                 isl_int_print(out, c, 0);
 136         if (pos < 1 + nparam) {
 137                 type = isl_dim_param;
 138                 pos -= 1;
 139         } else if (pos < 1 + nparam + n_in) {
 140                 type = isl_dim_in;
 141                 pos -= 1 + nparam;
 142         } else if (pos < 1 + nparam + n_in + n_out) {
 143                 type = isl_dim_out;
 144                 pos -= 1 + nparam + n_in;
 145         } else {
 146                 type = isl_dim_div;
 147                 pos -= 1 + nparam + n_in + n_out;
 148         }
 149         print_name(dim, out, type, pos, set);
 150 }
 151
 152 static void print_affine(__isl_keep isl_basic_map *bmap, FILE *out,
 153         isl_int *c, int set)
 154 {
 155         int i;
 156         int first;
 157         unsigned len = 1 + isl_basic_map_total_dim(bmap);
 158
 159         for (i = 0, first = 1; i < len; ++i) {
 160                 if (isl_int_is_zero(c[i]))
 161                         continue;
 162                 if (!first && isl_int_is_pos(c[i]))
 163                         fprintf(out, " + ");
 164                 first = 0;
 165                 print_term(bmap->dim, c[i], i, out, set);
 166         }
 167         if (first)
 168                 fprintf(out, "0");
 169 }
 170
 171 static void print_constraint(struct isl_basic_map *bmap, FILE *out,
 172         isl_int *c, const char *suffix, int first_constraint, int set)
 173 {
 174         if (!first_constraint)
 175                 fprintf(out, " and ");
 176
 177         print_affine(bmap, out, c, set);
 178
 179         fprintf(out, " %s", suffix);
 180 }
 181
 182 static void print_constraints(__isl_keep isl_basic_map *bmap, FILE *out,
 183         int set)
 184 {
 185         int i;
 186
 187         for (i = 0; i < bmap->n_eq; ++i)
 188                 print_constraint(bmap, out, bmap->eq[i], "= 0", !i, set);
 189         for (i = 0; i < bmap->n_ineq; ++i)
 190                 print_constraint(bmap, out, bmap->ineq[i], ">= 0",
 191                                         !bmap->n_eq && !i, set);
 192 }
 193
 194 static void print_disjunct(__isl_keep isl_basic_map *bmap, FILE *out, int set)
 195 {
 196         if (bmap->n_div > 0) {
 197                 int i;
 198                 fprintf(out, "exists (");
 199                 for (i = 0; i < bmap->n_div; ++i) {
 200                         if (i)
 201                                 fprintf(out, ", ");
 202                         print_name(bmap->dim, out, isl_dim_div, i, 0);
 203                         if (isl_int_is_zero(bmap->div[i][0]))
 204                                 continue;
 205                         fprintf(out, " = [(");
 206                         print_affine(bmap, out, bmap->div[i] + 1, set);
 207                         fprintf(out, ")/");
 208                         isl_int_print(out, bmap->div[i][0], 0);
 209                         fprintf(out, "]");
 210                 }
 211                 fprintf(out, ": ");
 212         }
 213
 214         print_constraints(bmap, out, set);
 215
 216         if (bmap->n_div > 0)
 217                 fprintf(out, ")");
 218 }
 219
 220 static void isl_basic_map_print_isl(__isl_keep isl_basic_map *bmap, FILE *out,
 221         int indent, const char *prefix, const char *suffix)
 222 {
 223         int i;
 224
 225         fprintf(out, "%*s%s", indent, "", prefix ? prefix : "");
 226         if (isl_basic_map_dim(bmap, isl_dim_param) > 0) {
 227                 print_tuple(bmap->dim, out, isl_dim_param, 0);
 228                 fprintf(out, " -> ");
 229         }
 230         fprintf(out, "{ ");
 231         print_tuple(bmap->dim, out, isl_dim_in, 0);
 232         fprintf(out, " -> ");
 233         print_tuple(bmap->dim, out, isl_dim_out, 0);
 234         fprintf(out, " : ");
 235         print_disjunct(bmap, out, 0);
 236         fprintf(out, " }%s\n", suffix ? suffix : "");
 237 }
 238
 239 static void isl_basic_set_print_isl(__isl_keep isl_basic_set *bset, FILE *out,
 240         int indent, const char *prefix, const char *suffix)
 241 {
 242         int i;
 243
 244         fprintf(out, "%*s%s", indent, "", prefix ? prefix : "");
 245         if (isl_basic_set_dim(bset, isl_dim_param) > 0) {
 246                 print_tuple(bset->dim, out, isl_dim_param, 0);
 247                 fprintf(out, " -> ");
 248         }
 249         fprintf(out, "{ ");
 250         print_tuple(bset->dim, out, isl_dim_set, 1);
 251         fprintf(out, " : ");
 252         print_disjunct((isl_basic_map *)bset, out, 1);
 253         fprintf(out, " }%s\n", suffix ? suffix : "");
 254 }
 255
 256 static void isl_map_print_isl(__isl_keep isl_map *map, FILE *out, int indent)
 257 {
 258         int i;
 259
 260         fprintf(out, "%*s", indent, "");
 261         if (isl_map_dim(map, isl_dim_param) > 0) {
 262                 print_tuple(map->dim, out, isl_dim_param, 0);
 263                 fprintf(out, " -> ");
 264         }
 265         fprintf(out, "{ ");
 266         print_tuple(map->dim, out, isl_dim_in, 0);
 267         fprintf(out, " -> ");
 268         print_tuple(map->dim, out, isl_dim_out, 0);
 269         fprintf(out, " : ");
 270         if (map->n == 0)
 271                 fprintf(out, "1 = 0");
 272         for (i = 0; i < map->n; ++i) {
 273                 if (i)
 274                         fprintf(out, " or ");
 275                 print_disjunct(map->p[i], out, 0);
 276         }
 277         fprintf(out, " }\n");
 278 }
 279
 280 static void isl_set_print_isl(__isl_keep isl_set *set, FILE *out, int indent)
 281 {
 282         int i;
 283
 284         fprintf(out, "%*s", indent, "");
 285         if (isl_set_dim(set, isl_dim_param) > 0) {
 286                 print_tuple(set->dim, out, isl_dim_param, 0);
 287                 fprintf(out, " -> ");
 288         }
 289         fprintf(out, "{ ");
 290         print_tuple(set->dim, out, isl_dim_set, 1);
 291         fprintf(out, " : ");
 292         if (set->n == 0)
 293                 fprintf(out, "1 = 0");
 294         for (i = 0; i < set->n; ++i) {
 295                 if (i)
 296                         fprintf(out, " or ");
 297                 print_disjunct((isl_basic_map *)set->p[i], out, 1);
 298         }
 299         fprintf(out, " }\n");
 300 }
 301
 302 void isl_basic_map_print(__isl_keep isl_basic_map *bmap, FILE *out, int indent,
 303         const char *prefix, const char *suffix, unsigned output_format)
 304 {
 305         if (!bmap)
 306                 return;
 307         if (output_format == ISL_FORMAT_ISL)
 308                 isl_basic_map_print_isl(bmap, out, indent, prefix, suffix);
 309         else
 310                 isl_assert(bmap->ctx, 0, return);
 311 }
 312
 313 void isl_basic_set_print(struct isl_basic_set *bset, FILE *out, int indent,
 314         const char *prefix, const char *suffix, unsigned output_format)
 315 {
 316         if (!bset)
 317                 return;
 318         if (output_format == ISL_FORMAT_ISL)
 319                 isl_basic_set_print_isl(bset, out, indent, prefix, suffix);
 320         else if (output_format == ISL_FORMAT_POLYLIB)
 321                 isl_basic_set_print_polylib(bset, out, indent, prefix, suffix);
 322         else if (output_format == ISL_FORMAT_POLYLIB_CONSTRAINTS)
 323                 print_constraints_polylib(bset, out, indent, prefix, suffix);
 324         else
 325                 isl_assert(bset->ctx, 0, return);
 326 }
 327
 328 void isl_set_print(struct isl_set *set, FILE *out, int indent,
 329         unsigned output_format)
 330 {
 331         if (!set)
 332                 return;
 333         if (output_format == ISL_FORMAT_ISL)
 334                 isl_set_print_isl(set, out, indent);
 335         else if (output_format == ISL_FORMAT_POLYLIB)
 336                 isl_set_print_polylib(set, out, indent);
 337         else
 338                 isl_assert(set->ctx, 0, return);
 339 }
 340
 341 void isl_map_print(__isl_keep isl_map *map, FILE *out, int indent,
 342         unsigned output_format)
 343 {
 344         if (!map)
 345                 return;
 346         if (output_format == ISL_FORMAT_ISL)
 347                 isl_map_print_isl(map, out, indent);
 348         else
 349                 isl_assert(map->ctx, 0, return);
 350 }