2 * Copyright 2008-2009 Katholieke Universiteit Leuven
3 * Copyright 2010 INRIA Saclay
5 * Use of this software is governed by the GNU LGPLv2.1 license
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
16 static void print_constraint_polylib(struct isl_basic_map
*bmap
,
18 FILE *out
, int indent
, const char *prefix
, const char *suffix
)
21 unsigned n_in
= isl_basic_map_dim(bmap
, isl_dim_in
);
22 unsigned n_out
= isl_basic_map_dim(bmap
, isl_dim_out
);
23 unsigned nparam
= isl_basic_map_dim(bmap
, isl_dim_param
);
24 isl_int
*c
= ineq
? bmap
->ineq
[n
] : bmap
->eq
[n
];
26 fprintf(out
, "%*s%s", indent
, "", prefix
? prefix
: "");
27 fprintf(out
, "%d", ineq
);
28 for (i
= 0; i
< n_out
; ++i
) {
30 isl_int_print(out
, c
[1+nparam
+n_in
+i
], 5);
32 for (i
= 0; i
< n_in
; ++i
) {
34 isl_int_print(out
, c
[1+nparam
+i
], 5);
36 for (i
= 0; i
< bmap
->n_div
; ++i
) {
38 isl_int_print(out
, c
[1+nparam
+n_in
+n_out
+i
], 5);
40 for (i
= 0; i
< nparam
; ++i
) {
42 isl_int_print(out
, c
[1+i
], 5);
45 isl_int_print(out
, c
[0], 5);
46 fprintf(out
, "%s\n", suffix
? suffix
: "");
49 static void print_constraints_polylib(struct isl_basic_map
*bmap
,
50 FILE *out
, int indent
, const char *prefix
, const char *suffix
)
54 for (i
= 0; i
< bmap
->n_eq
; ++i
)
55 print_constraint_polylib(bmap
, 0, i
, out
,
56 indent
, prefix
, suffix
);
57 for (i
= 0; i
< bmap
->n_ineq
; ++i
)
58 print_constraint_polylib(bmap
, 1, i
, out
,
59 indent
, prefix
, suffix
);
62 static void bset_print_constraints_polylib(struct isl_basic_set
*bset
,
63 FILE *out
, int indent
, const char *prefix
, const char *suffix
)
65 print_constraints_polylib((struct isl_basic_map
*)bset
,
66 out
, indent
, prefix
, suffix
);
69 static void isl_basic_map_print_polylib(struct isl_basic_map
*bmap
, FILE *out
,
70 int indent
, const char *prefix
, const char *suffix
)
72 unsigned total
= isl_basic_map_total_dim(bmap
);
73 fprintf(out
, "%*s%s", indent
, "", prefix
? prefix
: "");
74 fprintf(out
, "%d %d", bmap
->n_eq
+ bmap
->n_ineq
, 1 + total
+ 1);
75 fprintf(out
, "%s\n", suffix
? suffix
: "");
76 print_constraints_polylib(bmap
, out
, indent
, prefix
, suffix
);
79 static void isl_basic_set_print_polylib(struct isl_basic_set
*bset
, FILE *out
,
80 int indent
, const char *prefix
, const char *suffix
)
82 isl_basic_map_print_polylib((struct isl_basic_map
*)bset
, out
,
83 indent
, prefix
, suffix
);
86 static void isl_map_print_polylib(struct isl_map
*map
, FILE *out
, int indent
)
90 fprintf(out
, "%*s", indent
, "");
91 fprintf(out
, "%d\n", map
->n
);
92 for (i
= 0; i
< map
->n
; ++i
) {
94 isl_basic_map_print_polylib(map
->p
[i
], out
, indent
, NULL
, NULL
);
98 static void isl_set_print_polylib(struct isl_set
*set
, FILE *out
, int indent
)
100 isl_map_print_polylib((struct isl_map
*)set
, out
, indent
);
103 static print_name(struct isl_dim
*dim
, FILE *out
,
104 enum isl_dim_type type
, unsigned pos
, int set
)
108 name
= type
== isl_dim_div
? NULL
: isl_dim_get_name(dim
, type
, pos
);
111 fprintf(out
, "%s", name
);
114 if (type
== isl_dim_param
)
116 else if (type
== isl_dim_div
)
118 else if (set
|| type
== isl_dim_in
)
122 fprintf(out
, "%s%d", prefix
, pos
);
126 static void print_var_list(struct isl_dim
*dim
, FILE *out
,
127 enum isl_dim_type type
, int set
)
131 for (i
= 0; i
< isl_dim_size(dim
, type
); ++i
) {
134 print_name(dim
, out
, type
, i
, set
);
138 static void print_tuple(__isl_keep isl_dim
*dim
, FILE *out
,
139 enum isl_dim_type type
, int set
)
142 print_var_list(dim
, out
, type
, set
);
146 static void print_omega_parameters(struct isl_dim
*dim
, FILE *out
,
147 int indent
, const char *prefix
, const char *suffix
)
149 if (isl_dim_size(dim
, isl_dim_param
) == 0)
152 fprintf(out
, "%*s%ssymbolic ", indent
, "", prefix
? prefix
: "");
153 print_var_list(dim
, out
, isl_dim_param
, 0);
154 fprintf(out
, ";%s\n", suffix
? suffix
: "");
157 static void print_term(__isl_keep isl_dim
*dim
,
158 isl_int c
, int pos
, FILE *out
, int set
)
160 enum isl_dim_type type
;
161 unsigned n_in
= isl_dim_size(dim
, isl_dim_in
);
162 unsigned n_out
= isl_dim_size(dim
, isl_dim_out
);
163 unsigned nparam
= isl_dim_size(dim
, isl_dim_param
);
166 isl_int_print(out
, c
, 0);
170 if (isl_int_is_one(c
))
172 else if (isl_int_is_negone(c
))
175 isl_int_print(out
, c
, 0);
176 if (pos
< 1 + nparam
) {
177 type
= isl_dim_param
;
179 } else if (pos
< 1 + nparam
+ n_in
) {
182 } else if (pos
< 1 + nparam
+ n_in
+ n_out
) {
184 pos
-= 1 + nparam
+ n_in
;
187 pos
-= 1 + nparam
+ n_in
+ n_out
;
189 print_name(dim
, out
, type
, pos
, set
);
192 static void print_affine(__isl_keep isl_basic_map
*bmap
,
193 __isl_keep isl_dim
*dim
, FILE *out
, isl_int
*c
, int set
)
197 unsigned len
= 1 + isl_basic_map_total_dim(bmap
);
199 for (i
= 0, first
= 1; i
< len
; ++i
) {
201 if (isl_int_is_zero(c
[i
]))
204 if (isl_int_is_neg(c
[i
])) {
206 isl_int_neg(c
[i
], c
[i
]);
212 print_term(dim
, c
[i
], i
, out
, set
);
214 isl_int_neg(c
[i
], c
[i
]);
220 static void print_constraint(struct isl_basic_map
*bmap
,
221 __isl_keep isl_dim
*dim
, FILE *out
,
222 isl_int
*c
, int last
, const char *op
, int first_constraint
, int set
)
224 if (!first_constraint
)
225 fprintf(out
, " and ");
227 isl_int_abs(c
[last
], c
[last
]);
229 print_term(dim
, c
[last
], last
, out
, set
);
231 fprintf(out
, " %s ", op
);
233 isl_int_set_si(c
[last
], 0);
234 print_affine(bmap
, dim
, out
, c
, set
);
237 static void print_constraints(__isl_keep isl_basic_map
*bmap
,
238 __isl_keep isl_dim
*dim
, FILE *out
, int set
)
242 unsigned total
= isl_basic_map_total_dim(bmap
);
244 c
= isl_vec_alloc(bmap
->ctx
, 1 + total
);
248 for (i
= bmap
->n_eq
- 1; i
>= 0; --i
) {
249 int l
= isl_seq_last_non_zero(bmap
->eq
[i
], 1 + total
);
250 isl_assert(bmap
->ctx
, l
>= 0, return);
251 if (isl_int_is_neg(bmap
->eq
[i
][l
]))
252 isl_seq_cpy(c
->el
, bmap
->eq
[i
], 1 + total
);
254 isl_seq_neg(c
->el
, bmap
->eq
[i
], 1 + total
);
255 print_constraint(bmap
, dim
, out
, c
->el
, l
,
256 "=", i
== bmap
->n_eq
- 1, set
);
258 for (i
= 0; i
< bmap
->n_ineq
; ++i
) {
259 int l
= isl_seq_last_non_zero(bmap
->ineq
[i
], 1 + total
);
261 isl_assert(bmap
->ctx
, l
>= 0, return);
262 s
= isl_int_sgn(bmap
->ineq
[i
][l
]);
264 isl_seq_cpy(c
->el
, bmap
->ineq
[i
], 1 + total
);
266 isl_seq_neg(c
->el
, bmap
->ineq
[i
], 1 + total
);
267 print_constraint(bmap
, dim
, out
, c
->el
, l
,
268 s
< 0 ? "<=" : ">=", !bmap
->n_eq
&& !i
, set
);
274 static void print_omega_constraints(__isl_keep isl_basic_map
*bmap
, FILE *out
,
277 if (bmap
->n_eq
+ bmap
->n_ineq
== 0)
281 if (bmap
->n_div
> 0) {
283 fprintf(out
, "exists (");
284 for (i
= 0; i
< bmap
->n_div
; ++i
) {
287 print_name(bmap
->dim
, out
, isl_dim_div
, i
, 0);
291 print_constraints(bmap
, bmap
->dim
, out
, set
);
296 static void basic_map_print_omega(struct isl_basic_map
*bmap
, FILE *out
)
299 print_var_list(bmap
->dim
, out
, isl_dim_in
, 0);
300 fprintf(out
, "] -> [");
301 print_var_list(bmap
->dim
, out
, isl_dim_out
, 0);
303 print_omega_constraints(bmap
, out
, 0);
307 static void isl_basic_map_print_omega(struct isl_basic_map
*bmap
, FILE *out
,
308 int indent
, const char *prefix
, const char *suffix
)
310 print_omega_parameters(bmap
->dim
, out
, indent
, prefix
, suffix
);
312 fprintf(out
, "%*s%s", indent
, "", prefix
? prefix
: "");
313 basic_map_print_omega(bmap
, out
);
314 fprintf(out
, "%s\n", suffix
? suffix
: "");
317 static void basic_set_print_omega(struct isl_basic_set
*bset
, FILE *out
)
320 print_var_list(bset
->dim
, out
, isl_dim_set
, 1);
322 print_omega_constraints((isl_basic_map
*)bset
, out
, 1);
326 static void isl_basic_set_print_omega(struct isl_basic_set
*bset
, FILE *out
,
327 int indent
, const char *prefix
, const char *suffix
)
329 print_omega_parameters(bset
->dim
, out
, indent
, prefix
, suffix
);
331 fprintf(out
, "%*s%s", indent
, "", prefix
? prefix
: "");
332 basic_set_print_omega(bset
, out
);
333 fprintf(out
, "%s\n", suffix
? suffix
: "");
336 static void isl_map_print_omega(struct isl_map
*map
, FILE *out
, int indent
)
340 print_omega_parameters(map
->dim
, out
, indent
, "", "");
342 fprintf(out
, "%*s", indent
, "");
343 for (i
= 0; i
< map
->n
; ++i
) {
345 fprintf(out
, " union ");
346 basic_map_print_omega(map
->p
[i
], out
);
351 static void isl_set_print_omega(struct isl_set
*set
, FILE *out
, int indent
)
355 print_omega_parameters(set
->dim
, out
, indent
, "", "");
357 fprintf(out
, "%*s", indent
, "");
358 for (i
= 0; i
< set
->n
; ++i
) {
360 fprintf(out
, " union ");
361 basic_set_print_omega(set
->p
[i
], out
);
366 static void print_disjunct(__isl_keep isl_basic_map
*bmap
,
367 __isl_keep isl_dim
*dim
, FILE *out
, int set
)
369 if (bmap
->n_div
> 0) {
371 fprintf(out
, "exists (");
372 for (i
= 0; i
< bmap
->n_div
; ++i
) {
375 print_name(dim
, out
, isl_dim_div
, i
, 0);
376 if (isl_int_is_zero(bmap
->div
[i
][0]))
378 fprintf(out
, " = [(");
379 print_affine(bmap
, dim
, out
, bmap
->div
[i
] + 1, set
);
381 isl_int_print(out
, bmap
->div
[i
][0], 0);
387 print_constraints(bmap
, dim
, out
, set
);
393 static void isl_basic_map_print_isl(__isl_keep isl_basic_map
*bmap
, FILE *out
,
394 int indent
, const char *prefix
, const char *suffix
)
398 fprintf(out
, "%*s%s", indent
, "", prefix
? prefix
: "");
399 if (isl_basic_map_dim(bmap
, isl_dim_param
) > 0) {
400 print_tuple(bmap
->dim
, out
, isl_dim_param
, 0);
401 fprintf(out
, " -> ");
404 print_tuple(bmap
->dim
, out
, isl_dim_in
, 0);
405 fprintf(out
, " -> ");
406 print_tuple(bmap
->dim
, out
, isl_dim_out
, 0);
408 print_disjunct(bmap
, bmap
->dim
, out
, 0);
409 fprintf(out
, " }%s\n", suffix
? suffix
: "");
412 static void isl_basic_set_print_isl(__isl_keep isl_basic_set
*bset
, FILE *out
,
413 int indent
, const char *prefix
, const char *suffix
)
417 fprintf(out
, "%*s%s", indent
, "", prefix
? prefix
: "");
418 if (isl_basic_set_dim(bset
, isl_dim_param
) > 0) {
419 print_tuple(bset
->dim
, out
, isl_dim_param
, 0);
420 fprintf(out
, " -> ");
423 print_tuple(bset
->dim
, out
, isl_dim_set
, 1);
425 print_disjunct((isl_basic_map
*)bset
, bset
->dim
, out
, 1);
426 fprintf(out
, " }%s\n", suffix
? suffix
: "");
429 static void isl_map_print_isl(__isl_keep isl_map
*map
, FILE *out
, int indent
)
433 fprintf(out
, "%*s", indent
, "");
434 if (isl_map_dim(map
, isl_dim_param
) > 0) {
435 print_tuple(map
->dim
, out
, isl_dim_param
, 0);
436 fprintf(out
, " -> ");
439 print_tuple(map
->dim
, out
, isl_dim_in
, 0);
440 fprintf(out
, " -> ");
441 print_tuple(map
->dim
, out
, isl_dim_out
, 0);
444 fprintf(out
, "1 = 0");
445 for (i
= 0; i
< map
->n
; ++i
) {
447 fprintf(out
, " or ");
448 if (map
->n
> 1 && map
->p
[i
]->n_eq
+ map
->p
[i
]->n_ineq
> 1)
450 print_disjunct(map
->p
[i
], map
->dim
, out
, 0);
451 if (map
->n
> 1 && map
->p
[i
]->n_eq
+ map
->p
[i
]->n_ineq
> 1)
454 fprintf(out
, " }\n");
457 static void isl_set_print_isl(__isl_keep isl_set
*set
, FILE *out
, int indent
)
461 fprintf(out
, "%*s", indent
, "");
462 if (isl_set_dim(set
, isl_dim_param
) > 0) {
463 print_tuple(set
->dim
, out
, isl_dim_param
, 0);
464 fprintf(out
, " -> ");
467 print_tuple(set
->dim
, out
, isl_dim_set
, 1);
470 fprintf(out
, "1 = 0");
471 for (i
= 0; i
< set
->n
; ++i
) {
473 fprintf(out
, " or ");
474 print_disjunct((isl_basic_map
*)set
->p
[i
], set
->dim
, out
, 1);
476 fprintf(out
, " }\n");
479 void isl_basic_map_print(__isl_keep isl_basic_map
*bmap
, FILE *out
, int indent
,
480 const char *prefix
, const char *suffix
, unsigned output_format
)
484 if (output_format
== ISL_FORMAT_ISL
)
485 isl_basic_map_print_isl(bmap
, out
, indent
, prefix
, suffix
);
486 else if (output_format
== ISL_FORMAT_OMEGA
)
487 isl_basic_map_print_omega(bmap
, out
, indent
, prefix
, suffix
);
489 isl_assert(bmap
->ctx
, 0, return);
492 void isl_basic_set_print(struct isl_basic_set
*bset
, FILE *out
, int indent
,
493 const char *prefix
, const char *suffix
, unsigned output_format
)
497 if (output_format
== ISL_FORMAT_ISL
)
498 isl_basic_set_print_isl(bset
, out
, indent
, prefix
, suffix
);
499 else if (output_format
== ISL_FORMAT_POLYLIB
)
500 isl_basic_set_print_polylib(bset
, out
, indent
, prefix
, suffix
);
501 else if (output_format
== ISL_FORMAT_POLYLIB_CONSTRAINTS
)
502 bset_print_constraints_polylib(bset
, out
, indent
, prefix
, suffix
);
503 else if (output_format
== ISL_FORMAT_OMEGA
)
504 isl_basic_set_print_omega(bset
, out
, indent
, prefix
, suffix
);
506 isl_assert(bset
->ctx
, 0, return);
509 void isl_set_print(struct isl_set
*set
, FILE *out
, int indent
,
510 unsigned output_format
)
514 if (output_format
== ISL_FORMAT_ISL
)
515 isl_set_print_isl(set
, out
, indent
);
516 else if (output_format
== ISL_FORMAT_POLYLIB
)
517 isl_set_print_polylib(set
, out
, indent
);
518 else if (output_format
== ISL_FORMAT_OMEGA
)
519 isl_set_print_omega(set
, out
, indent
);
521 isl_assert(set
->ctx
, 0, return);
524 void isl_map_print(__isl_keep isl_map
*map
, FILE *out
, int indent
,
525 unsigned output_format
)
529 if (output_format
== ISL_FORMAT_ISL
)
530 isl_map_print_isl(map
, out
, indent
);
531 else if (output_format
== ISL_FORMAT_POLYLIB
)
532 isl_map_print_polylib(map
, out
, indent
);
533 else if (output_format
== ISL_FORMAT_OMEGA
)
534 isl_map_print_omega(map
, out
, indent
);
536 isl_assert(map
->ctx
, 0, return);