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 #include <isl_polynomial_private.h>
17 #include <isl_printer_private.h>
19 static __isl_give isl_printer
*print_constraint_polylib(
20 struct isl_basic_map
*bmap
, int ineq
, int n
, __isl_take isl_printer
*p
)
23 unsigned n_in
= isl_basic_map_dim(bmap
, isl_dim_in
);
24 unsigned n_out
= isl_basic_map_dim(bmap
, isl_dim_out
);
25 unsigned nparam
= isl_basic_map_dim(bmap
, isl_dim_param
);
26 isl_int
*c
= ineq
? bmap
->ineq
[n
] : bmap
->eq
[n
];
28 p
= isl_printer_start_line(p
);
29 p
= isl_printer_print_int(p
, ineq
);
30 for (i
= 0; i
< n_out
; ++i
) {
31 p
= isl_printer_print_str(p
, " ");
32 p
= isl_printer_print_isl_int(p
, c
[1+nparam
+n_in
+i
]);
34 for (i
= 0; i
< n_in
; ++i
) {
35 p
= isl_printer_print_str(p
, " ");
36 p
= isl_printer_print_isl_int(p
, c
[1+nparam
+i
]);
38 for (i
= 0; i
< bmap
->n_div
; ++i
) {
39 p
= isl_printer_print_str(p
, " ");
40 p
= isl_printer_print_isl_int(p
, c
[1+nparam
+n_in
+n_out
+i
]);
42 for (i
= 0; i
< nparam
; ++i
) {
43 p
= isl_printer_print_str(p
, " ");
44 p
= isl_printer_print_isl_int(p
, c
[1+i
]);
46 p
= isl_printer_print_str(p
, " ");
47 p
= isl_printer_print_isl_int(p
, c
[0]);
48 p
= isl_printer_end_line(p
);
52 static __isl_give isl_printer
*print_constraints_polylib(
53 struct isl_basic_map
*bmap
, __isl_take isl_printer
*p
)
57 p
= isl_printer_set_isl_int_width(p
, 5);
59 for (i
= 0; i
< bmap
->n_eq
; ++i
)
60 p
= print_constraint_polylib(bmap
, 0, i
, p
);
61 for (i
= 0; i
< bmap
->n_ineq
; ++i
)
62 p
= print_constraint_polylib(bmap
, 1, i
, p
);
67 static __isl_give isl_printer
*bset_print_constraints_polylib(
68 struct isl_basic_set
*bset
, __isl_take isl_printer
*p
)
70 return print_constraints_polylib((struct isl_basic_map
*)bset
, p
);
73 static __isl_give isl_printer
*isl_basic_map_print_polylib(
74 __isl_keep isl_basic_map
*bmap
, __isl_take isl_printer
*p
)
76 unsigned total
= isl_basic_map_total_dim(bmap
);
77 p
= isl_printer_start_line(p
);
78 p
= isl_printer_print_int(p
, bmap
->n_eq
+ bmap
->n_ineq
);
79 p
= isl_printer_print_str(p
, " ");
80 p
= isl_printer_print_int(p
, 1 + total
+ 1);
81 p
= isl_printer_end_line(p
);
82 return print_constraints_polylib(bmap
, p
);
85 static __isl_give isl_printer
*isl_basic_set_print_polylib(
86 __isl_keep isl_basic_set
*bset
, __isl_take isl_printer
*p
)
88 return isl_basic_map_print_polylib((struct isl_basic_map
*)bset
, p
);
91 static __isl_give isl_printer
*isl_map_print_polylib(__isl_keep isl_map
*map
,
92 __isl_take isl_printer
*p
)
96 p
= isl_printer_start_line(p
);
97 p
= isl_printer_print_int(p
, map
->n
);
98 p
= isl_printer_end_line(p
);
99 for (i
= 0; i
< map
->n
; ++i
) {
100 p
= isl_printer_start_line(p
);
101 p
= isl_printer_end_line(p
);
102 p
= isl_basic_map_print_polylib(map
->p
[i
], p
);
107 static __isl_give isl_printer
*isl_set_print_polylib(__isl_keep isl_set
*set
,
108 __isl_take isl_printer
*p
)
110 return isl_map_print_polylib((struct isl_map
*)set
, p
);
113 static int count_same_name(__isl_keep isl_dim
*dim
,
114 enum isl_dim_type type
, unsigned pos
, const char *name
)
120 for (t
= isl_dim_param
; t
<= type
&& t
<= isl_dim_out
; ++t
) {
121 s
= t
== type
? pos
: isl_dim_size(dim
, t
);
122 for (p
= 0; p
< s
; ++p
) {
123 const char *n
= isl_dim_get_name(dim
, t
, p
);
124 if (n
&& !strcmp(n
, name
))
131 static __isl_give isl_printer
*print_name(__isl_keep isl_dim
*dim
,
132 __isl_take isl_printer
*p
, enum isl_dim_type type
, unsigned pos
, int set
)
138 name
= type
== isl_dim_div
? NULL
: isl_dim_get_name(dim
, type
, pos
);
142 if (type
== isl_dim_param
)
144 else if (type
== isl_dim_div
)
146 else if (set
|| type
== isl_dim_in
)
150 snprintf(buffer
, sizeof(buffer
), "%s%d", prefix
, pos
);
153 primes
= count_same_name(dim
, name
== buffer
? isl_dim_div
: type
,
155 p
= isl_printer_print_str(p
, name
);
157 p
= isl_printer_print_str(p
, "'");
161 static __isl_give isl_printer
*print_var_list(__isl_keep isl_dim
*dim
,
162 __isl_take isl_printer
*p
, enum isl_dim_type type
, int set
)
166 for (i
= 0; i
< isl_dim_size(dim
, type
); ++i
) {
168 p
= isl_printer_print_str(p
, ", ");
169 p
= print_name(dim
, p
, type
, i
, set
);
174 static __isl_give isl_printer
*print_tuple(__isl_keep isl_dim
*dim
,
175 __isl_take isl_printer
*p
, enum isl_dim_type type
, int set
)
177 p
= isl_printer_print_str(p
, "[");
178 p
= print_var_list(dim
, p
, type
, set
);
179 p
= isl_printer_print_str(p
, "]");
183 static __isl_give isl_printer
*print_omega_parameters(__isl_keep isl_dim
*dim
,
184 __isl_take isl_printer
*p
)
186 if (isl_dim_size(dim
, isl_dim_param
) == 0)
189 p
= isl_printer_start_line(p
);
190 p
= isl_printer_print_str(p
, "symbolic ");
191 p
= print_var_list(dim
, p
, isl_dim_param
, 0);
192 p
= isl_printer_print_str(p
, ";");
193 p
= isl_printer_end_line(p
);
197 static enum isl_dim_type
pos2type(__isl_keep isl_dim
*dim
, unsigned *pos
)
199 enum isl_dim_type type
;
200 unsigned n_in
= isl_dim_size(dim
, isl_dim_in
);
201 unsigned n_out
= isl_dim_size(dim
, isl_dim_out
);
202 unsigned nparam
= isl_dim_size(dim
, isl_dim_param
);
204 if (*pos
< 1 + nparam
) {
205 type
= isl_dim_param
;
207 } else if (*pos
< 1 + nparam
+ n_in
) {
210 } else if (*pos
< 1 + nparam
+ n_in
+ n_out
) {
212 *pos
-= 1 + nparam
+ n_in
;
215 *pos
-= 1 + nparam
+ n_in
+ n_out
;
221 static __isl_give isl_printer
*print_term(__isl_keep isl_dim
*dim
,
222 isl_int c
, unsigned pos
, __isl_take isl_printer
*p
, int set
)
224 enum isl_dim_type type
;
227 return isl_printer_print_isl_int(p
, c
);
229 if (isl_int_is_one(c
))
231 else if (isl_int_is_negone(c
))
232 p
= isl_printer_print_str(p
, "-");
234 p
= isl_printer_print_isl_int(p
, c
);
235 type
= pos2type(dim
, &pos
);
236 p
= print_name(dim
, p
, type
, pos
, set
);
240 static __isl_give isl_printer
*print_affine_of_len(__isl_keep isl_dim
*dim
,
241 __isl_take isl_printer
*p
, isl_int
*c
, int len
, int set
)
246 for (i
= 0, first
= 1; i
< len
; ++i
) {
248 if (isl_int_is_zero(c
[i
]))
251 if (isl_int_is_neg(c
[i
])) {
253 isl_int_neg(c
[i
], c
[i
]);
254 p
= isl_printer_print_str(p
, " - ");
256 p
= isl_printer_print_str(p
, " + ");
259 p
= print_term(dim
, c
[i
], i
, p
, set
);
261 isl_int_neg(c
[i
], c
[i
]);
264 p
= isl_printer_print_str(p
, "0");
268 static __isl_give isl_printer
*print_affine(__isl_keep isl_basic_map
*bmap
,
269 __isl_keep isl_dim
*dim
, __isl_take isl_printer
*p
, isl_int
*c
, int set
)
271 unsigned len
= 1 + isl_basic_map_total_dim(bmap
);
272 return print_affine_of_len(dim
, p
, c
, len
, set
);
275 static __isl_give isl_printer
*print_constraint(struct isl_basic_map
*bmap
,
276 __isl_keep isl_dim
*dim
, __isl_take isl_printer
*p
,
277 isl_int
*c
, int last
, const char *op
, int first_constraint
, int set
)
279 if (!first_constraint
)
280 p
= isl_printer_print_str(p
, " and ");
282 isl_int_abs(c
[last
], c
[last
]);
284 p
= print_term(dim
, c
[last
], last
, p
, set
);
286 p
= isl_printer_print_str(p
, " ");
287 p
= isl_printer_print_str(p
, op
);
288 p
= isl_printer_print_str(p
, " ");
290 isl_int_set_si(c
[last
], 0);
291 p
= print_affine(bmap
, dim
, p
, c
, set
);
296 static __isl_give isl_printer
*print_constraints(__isl_keep isl_basic_map
*bmap
,
297 __isl_keep isl_dim
*dim
, __isl_take isl_printer
*p
, int set
)
301 unsigned total
= isl_basic_map_total_dim(bmap
);
303 c
= isl_vec_alloc(bmap
->ctx
, 1 + total
);
307 for (i
= bmap
->n_eq
- 1; i
>= 0; --i
) {
308 int l
= isl_seq_last_non_zero(bmap
->eq
[i
], 1 + total
);
309 isl_assert(bmap
->ctx
, l
>= 0, goto error
);
310 if (isl_int_is_neg(bmap
->eq
[i
][l
]))
311 isl_seq_cpy(c
->el
, bmap
->eq
[i
], 1 + total
);
313 isl_seq_neg(c
->el
, bmap
->eq
[i
], 1 + total
);
314 p
= print_constraint(bmap
, dim
, p
, c
->el
, l
,
315 "=", i
== bmap
->n_eq
- 1, set
);
317 for (i
= 0; i
< bmap
->n_ineq
; ++i
) {
318 int l
= isl_seq_last_non_zero(bmap
->ineq
[i
], 1 + total
);
320 isl_assert(bmap
->ctx
, l
>= 0, goto error
);
321 s
= isl_int_sgn(bmap
->ineq
[i
][l
]);
323 isl_seq_cpy(c
->el
, bmap
->ineq
[i
], 1 + total
);
325 isl_seq_neg(c
->el
, bmap
->ineq
[i
], 1 + total
);
326 p
= print_constraint(bmap
, dim
, p
, c
->el
, l
,
327 s
< 0 ? "<=" : ">=", !bmap
->n_eq
&& !i
, set
);
338 static __isl_give isl_printer
*print_omega_constraints(
339 __isl_keep isl_basic_map
*bmap
, __isl_take isl_printer
*p
, int set
)
341 if (bmap
->n_eq
+ bmap
->n_ineq
== 0)
344 p
= isl_printer_print_str(p
, ": ");
345 if (bmap
->n_div
> 0) {
347 p
= isl_printer_print_str(p
, "exists (");
348 for (i
= 0; i
< bmap
->n_div
; ++i
) {
350 p
= isl_printer_print_str(p
, ", ");
351 p
= print_name(bmap
->dim
, p
, isl_dim_div
, i
, 0);
353 p
= isl_printer_print_str(p
, ": ");
355 p
= print_constraints(bmap
, bmap
->dim
, p
, set
);
357 p
= isl_printer_print_str(p
, ")");
361 static __isl_give isl_printer
*basic_map_print_omega(
362 __isl_keep isl_basic_map
*bmap
, __isl_take isl_printer
*p
)
364 p
= isl_printer_print_str(p
, "{ [");
365 p
= print_var_list(bmap
->dim
, p
, isl_dim_in
, 0);
366 p
= isl_printer_print_str(p
, "] -> [");
367 p
= print_var_list(bmap
->dim
, p
, isl_dim_out
, 0);
368 p
= isl_printer_print_str(p
, "] ");
369 p
= print_omega_constraints(bmap
, p
, 0);
370 p
= isl_printer_print_str(p
, " }");
374 static __isl_give isl_printer
*isl_basic_map_print_omega(
375 __isl_keep isl_basic_map
*bmap
, __isl_take isl_printer
*p
)
377 p
= print_omega_parameters(bmap
->dim
, p
);
379 p
= isl_printer_start_line(p
);
380 p
= basic_map_print_omega(bmap
, p
);
381 p
= isl_printer_end_line(p
);
385 static __isl_give isl_printer
*basic_set_print_omega(
386 __isl_keep isl_basic_set
*bset
, __isl_take isl_printer
*p
)
388 p
= isl_printer_print_str(p
, "{ [");
389 p
= print_var_list(bset
->dim
, p
, isl_dim_set
, 1);
390 p
= isl_printer_print_str(p
, "] ");
391 p
= print_omega_constraints((isl_basic_map
*)bset
, p
, 1);
392 p
= isl_printer_print_str(p
, " }");
396 static __isl_give isl_printer
*isl_basic_set_print_omega(
397 __isl_keep isl_basic_set
*bset
, __isl_take isl_printer
*p
)
399 p
= print_omega_parameters(bset
->dim
, p
);
401 p
= isl_printer_start_line(p
);
402 p
= basic_set_print_omega(bset
, p
);
403 p
= isl_printer_end_line(p
);
407 static __isl_give isl_printer
*isl_map_print_omega(__isl_keep isl_map
*map
,
408 __isl_take isl_printer
*p
)
412 p
= print_omega_parameters(map
->dim
, p
);
414 p
= isl_printer_start_line(p
);
415 for (i
= 0; i
< map
->n
; ++i
) {
417 p
= isl_printer_print_str(p
, " union ");
418 p
= basic_map_print_omega(map
->p
[i
], p
);
420 p
= isl_printer_end_line(p
);
424 static __isl_give isl_printer
*isl_set_print_omega(__isl_keep isl_set
*set
,
425 __isl_take isl_printer
*p
)
429 p
= print_omega_parameters(set
->dim
, p
);
431 p
= isl_printer_start_line(p
);
432 for (i
= 0; i
< set
->n
; ++i
) {
434 p
= isl_printer_print_str(p
, " union ");
435 p
= basic_set_print_omega(set
->p
[i
], p
);
437 p
= isl_printer_end_line(p
);
441 static __isl_give isl_printer
*print_disjunct(__isl_keep isl_basic_map
*bmap
,
442 __isl_keep isl_dim
*dim
, __isl_take isl_printer
*p
, int set
)
444 if (bmap
->n_div
> 0) {
446 p
= isl_printer_print_str(p
, "exists (");
447 for (i
= 0; i
< bmap
->n_div
; ++i
) {
449 p
= isl_printer_print_str(p
, ", ");
450 p
= print_name(dim
, p
, isl_dim_div
, i
, 0);
451 if (isl_int_is_zero(bmap
->div
[i
][0]))
453 p
= isl_printer_print_str(p
, " = [(");
454 p
= print_affine(bmap
, dim
, p
, bmap
->div
[i
] + 1, set
);
455 p
= isl_printer_print_str(p
, ")/");
456 p
= isl_printer_print_isl_int(p
, bmap
->div
[i
][0]);
457 p
= isl_printer_print_str(p
, "]");
459 p
= isl_printer_print_str(p
, ": ");
462 p
= print_constraints(bmap
, dim
, p
, set
);
465 p
= isl_printer_print_str(p
, ")");
469 static __isl_give isl_printer
*isl_basic_map_print_isl(
470 __isl_keep isl_basic_map
*bmap
, __isl_take isl_printer
*p
)
474 p
= isl_printer_start_line(p
);
475 if (isl_basic_map_dim(bmap
, isl_dim_param
) > 0) {
476 p
= print_tuple(bmap
->dim
, p
, isl_dim_param
, 0);
477 p
= isl_printer_print_str(p
, " -> ");
479 p
= isl_printer_print_str(p
, "{ ");
480 p
= print_tuple(bmap
->dim
, p
, isl_dim_in
, 0);
481 p
= isl_printer_print_str(p
, " -> ");
482 p
= print_tuple(bmap
->dim
, p
, isl_dim_out
, 0);
483 p
= isl_printer_print_str(p
, " : ");
484 p
= print_disjunct(bmap
, bmap
->dim
, p
, 0);
485 p
= isl_printer_print_str(p
, " }");
486 p
= isl_printer_end_line(p
);
490 static __isl_give isl_printer
*isl_basic_set_print_isl(
491 __isl_keep isl_basic_set
*bset
, __isl_take isl_printer
*p
)
495 p
= isl_printer_start_line(p
);
496 if (isl_basic_set_dim(bset
, isl_dim_param
) > 0) {
497 p
= print_tuple(bset
->dim
, p
, isl_dim_param
, 0);
498 p
= isl_printer_print_str(p
, " -> ");
500 p
= isl_printer_print_str(p
, "{ ");
501 p
= print_tuple(bset
->dim
, p
, isl_dim_set
, 1);
502 p
= isl_printer_print_str(p
, " : ");
503 p
= print_disjunct((isl_basic_map
*)bset
, bset
->dim
, p
, 1);
504 p
= isl_printer_print_str(p
, " }");
505 p
= isl_printer_end_line(p
);
509 static __isl_give isl_printer
*print_disjuncts(__isl_keep isl_map
*map
,
510 __isl_take isl_printer
*p
, int set
)
514 if (isl_map_fast_is_universe(map
))
517 p
= isl_printer_print_str(p
, " : ");
519 p
= isl_printer_print_str(p
, "1 = 0");
520 for (i
= 0; i
< map
->n
; ++i
) {
522 p
= isl_printer_print_str(p
, " or ");
523 if (map
->n
> 1 && map
->p
[i
]->n_eq
+ map
->p
[i
]->n_ineq
> 1)
524 p
= isl_printer_print_str(p
, "(");
525 p
= print_disjunct(map
->p
[i
], map
->dim
, p
, set
);
526 if (map
->n
> 1 && map
->p
[i
]->n_eq
+ map
->p
[i
]->n_ineq
> 1)
527 p
= isl_printer_print_str(p
, ")");
532 static __isl_give isl_printer
*isl_map_print_isl(__isl_keep isl_map
*map
,
533 __isl_take isl_printer
*p
)
535 if (isl_map_dim(map
, isl_dim_param
) > 0) {
536 p
= print_tuple(map
->dim
, p
, isl_dim_param
, 0);
537 p
= isl_printer_print_str(p
, " -> ");
539 p
= isl_printer_print_str(p
, "{ ");
540 p
= print_tuple(map
->dim
, p
, isl_dim_in
, 0);
541 p
= isl_printer_print_str(p
, " -> ");
542 p
= print_tuple(map
->dim
, p
, isl_dim_out
, 0);
543 p
= print_disjuncts(map
, p
, 0);
544 p
= isl_printer_print_str(p
, " }");
548 static __isl_give isl_printer
*isl_set_print_isl(__isl_keep isl_set
*set
,
549 __isl_take isl_printer
*p
)
553 if (isl_set_dim(set
, isl_dim_param
) > 0) {
554 p
= print_tuple(set
->dim
, p
, isl_dim_param
, 0);
555 p
= isl_printer_print_str(p
, " -> ");
557 p
= isl_printer_print_str(p
, "{ ");
558 p
= print_tuple(set
->dim
, p
, isl_dim_set
, 1);
559 p
= print_disjuncts((isl_map
*)set
, p
, 1);
560 p
= isl_printer_print_str(p
, " }");
564 __isl_give isl_printer
*isl_printer_print_basic_map(__isl_take isl_printer
*p
,
565 __isl_keep isl_basic_map
*bmap
)
569 if (p
->output_format
== ISL_FORMAT_ISL
)
570 return isl_basic_map_print_isl(bmap
, p
);
571 else if (p
->output_format
== ISL_FORMAT_OMEGA
)
572 return isl_basic_map_print_omega(bmap
, p
);
573 isl_assert(bmap
->ctx
, 0, goto error
);
579 void isl_basic_map_print(__isl_keep isl_basic_map
*bmap
, FILE *out
, int indent
,
580 const char *prefix
, const char *suffix
, unsigned output_format
)
582 isl_printer
*printer
;
587 printer
= isl_printer_to_file(bmap
->ctx
, out
);
588 printer
= isl_printer_set_indent(printer
, indent
);
589 printer
= isl_printer_set_prefix(printer
, prefix
);
590 printer
= isl_printer_set_suffix(printer
, suffix
);
591 printer
= isl_printer_set_output_format(printer
, output_format
);
592 isl_printer_print_basic_map(printer
, bmap
);
594 isl_printer_free(printer
);
597 __isl_give isl_printer
*isl_printer_print_basic_set(__isl_take isl_printer
*p
,
598 __isl_keep isl_basic_set
*bset
)
603 if (p
->output_format
== ISL_FORMAT_ISL
)
604 return isl_basic_set_print_isl(bset
, p
);
605 else if (p
->output_format
== ISL_FORMAT_POLYLIB
)
606 return isl_basic_set_print_polylib(bset
, p
);
607 else if (p
->output_format
== ISL_FORMAT_POLYLIB_CONSTRAINTS
)
608 return bset_print_constraints_polylib(bset
, p
);
609 else if (p
->output_format
== ISL_FORMAT_OMEGA
)
610 return isl_basic_set_print_omega(bset
, p
);
611 isl_assert(p
->ctx
, 0, goto error
);
617 void isl_basic_set_print(struct isl_basic_set
*bset
, FILE *out
, int indent
,
618 const char *prefix
, const char *suffix
, unsigned output_format
)
620 isl_printer
*printer
;
625 printer
= isl_printer_to_file(bset
->ctx
, out
);
626 printer
= isl_printer_set_indent(printer
, indent
);
627 printer
= isl_printer_set_prefix(printer
, prefix
);
628 printer
= isl_printer_set_suffix(printer
, suffix
);
629 printer
= isl_printer_set_output_format(printer
, output_format
);
630 isl_printer_print_basic_set(printer
, bset
);
632 isl_printer_free(printer
);
635 __isl_give isl_printer
*isl_printer_print_set(__isl_take isl_printer
*p
,
636 __isl_keep isl_set
*set
)
640 if (p
->output_format
== ISL_FORMAT_ISL
)
641 return isl_set_print_isl(set
, p
);
642 else if (p
->output_format
== ISL_FORMAT_POLYLIB
)
643 return isl_set_print_polylib(set
, p
);
644 else if (p
->output_format
== ISL_FORMAT_OMEGA
)
645 return isl_set_print_omega(set
, p
);
646 isl_assert(set
->ctx
, 0, goto error
);
652 void isl_set_print(struct isl_set
*set
, FILE *out
, int indent
,
653 unsigned output_format
)
655 isl_printer
*printer
;
660 printer
= isl_printer_to_file(set
->ctx
, out
);
661 printer
= isl_printer_set_indent(printer
, indent
);
662 printer
= isl_printer_set_output_format(printer
, output_format
);
663 printer
= isl_printer_print_set(printer
, set
);
665 isl_printer_free(printer
);
668 __isl_give isl_printer
*isl_printer_print_map(__isl_take isl_printer
*p
,
669 __isl_keep isl_map
*map
)
674 if (p
->output_format
== ISL_FORMAT_ISL
)
675 return isl_map_print_isl(map
, p
);
676 else if (p
->output_format
== ISL_FORMAT_POLYLIB
)
677 return isl_map_print_polylib(map
, p
);
678 else if (p
->output_format
== ISL_FORMAT_OMEGA
)
679 return isl_map_print_omega(map
, p
);
680 isl_assert(map
->ctx
, 0, goto error
);
686 void isl_map_print(__isl_keep isl_map
*map
, FILE *out
, int indent
,
687 unsigned output_format
)
689 isl_printer
*printer
;
694 printer
= isl_printer_to_file(map
->ctx
, out
);
695 printer
= isl_printer_set_indent(printer
, indent
);
696 printer
= isl_printer_set_output_format(printer
, output_format
);
697 printer
= isl_printer_print_map(printer
, map
);
699 isl_printer_free(printer
);
702 static int upoly_rec_n_non_zero(__isl_keep
struct isl_upoly_rec
*rec
)
707 for (i
= 0, n
= 0; i
< rec
->n
; ++i
)
708 if (!isl_upoly_is_zero(rec
->p
[i
]))
714 static __isl_give isl_printer
*print_div(__isl_keep isl_dim
*dim
,
715 __isl_keep isl_mat
*div
, int pos
, __isl_take isl_printer
*p
)
717 int c
= p
->output_format
== ISL_FORMAT_C
;
718 p
= isl_printer_print_str(p
, c
? "floord(" : "[(");
719 p
= print_affine_of_len(dim
, p
, div
->row
[pos
] + 1, div
->n_col
- 1, 1);
720 p
= isl_printer_print_str(p
, c
? ", " : ")/");
721 p
= isl_printer_print_isl_int(p
, div
->row
[pos
][0]);
722 p
= isl_printer_print_str(p
, c
? ")" : "]");
726 static __isl_give isl_printer
*upoly_print_cst(__isl_keep
struct isl_upoly
*up
,
727 __isl_take isl_printer
*p
, int first
)
729 struct isl_upoly_cst
*cst
;
732 cst
= isl_upoly_as_cst(up
);
735 neg
= !first
&& isl_int_is_neg(cst
->n
);
737 p
= isl_printer_print_str(p
, neg
? " - " : " + ");
739 isl_int_neg(cst
->n
, cst
->n
);
740 if (isl_int_is_zero(cst
->d
)) {
741 int sgn
= isl_int_sgn(cst
->n
);
742 p
= isl_printer_print_str(p
, sgn
< 0 ? "-infty" :
743 sgn
== 0 ? "NaN" : "infty");
745 p
= isl_printer_print_isl_int(p
, cst
->n
);
747 isl_int_neg(cst
->n
, cst
->n
);
748 if (!isl_int_is_zero(cst
->d
) && !isl_int_is_one(cst
->d
)) {
749 p
= isl_printer_print_str(p
, "/");
750 p
= isl_printer_print_isl_int(p
, cst
->d
);
758 static __isl_give isl_printer
*print_base(__isl_take isl_printer
*p
,
759 __isl_keep isl_dim
*dim
, __isl_keep isl_mat
*div
, int var
)
763 total
= isl_dim_total(dim
);
765 p
= print_term(dim
, dim
->ctx
->one
, 1 + var
, p
, 1);
767 p
= print_div(dim
, div
, var
- total
, p
);
771 static __isl_give isl_printer
*print_pow(__isl_take isl_printer
*p
,
772 __isl_keep isl_dim
*dim
, __isl_keep isl_mat
*div
, int var
, int exp
)
774 p
= print_base(p
, dim
, div
, var
);
777 if (p
->output_format
== ISL_FORMAT_C
) {
779 for (i
= 1; i
< exp
; ++i
) {
780 p
= isl_printer_print_str(p
, "*");
781 p
= print_base(p
, dim
, div
, var
);
784 p
= isl_printer_print_str(p
, "^");
785 p
= isl_printer_print_int(p
, exp
);
790 static __isl_give isl_printer
*upoly_print(__isl_keep
struct isl_upoly
*up
,
791 __isl_keep isl_dim
*dim
, __isl_keep isl_mat
*div
,
792 __isl_take isl_printer
*p
)
795 struct isl_upoly_rec
*rec
;
797 if (!p
|| !up
|| !dim
|| !div
)
800 if (isl_upoly_is_cst(up
))
801 return upoly_print_cst(up
, p
, 1);
803 rec
= isl_upoly_as_rec(up
);
806 n
= upoly_rec_n_non_zero(rec
);
808 p
= isl_printer_print_str(p
, "(");
809 for (i
= 0, first
= 1; i
< rec
->n
; ++i
) {
810 if (isl_upoly_is_zero(rec
->p
[i
]))
812 if (isl_upoly_is_negone(rec
->p
[i
])) {
814 p
= isl_printer_print_str(p
, "-1");
816 p
= isl_printer_print_str(p
, "-");
818 p
= isl_printer_print_str(p
, " - ");
819 } else if (isl_upoly_is_cst(rec
->p
[i
]) &&
820 !isl_upoly_is_one(rec
->p
[i
]))
821 p
= upoly_print_cst(rec
->p
[i
], p
, first
);
824 p
= isl_printer_print_str(p
, " + ");
825 if (i
== 0 || !isl_upoly_is_one(rec
->p
[i
]))
826 p
= upoly_print(rec
->p
[i
], dim
, div
, p
);
831 if (!isl_upoly_is_one(rec
->p
[i
]) &&
832 !isl_upoly_is_negone(rec
->p
[i
]))
833 p
= isl_printer_print_str(p
, " * ");
834 p
= print_pow(p
, dim
, div
, rec
->up
.var
, i
);
837 p
= isl_printer_print_str(p
, ")");
844 __isl_give isl_printer
*isl_printer_print_qpolynomial(__isl_take isl_printer
*p
,
845 __isl_keep isl_qpolynomial
*qp
)
849 p
= upoly_print(qp
->upoly
, qp
->dim
, qp
->div
, p
);
856 void isl_qpolynomial_print(__isl_keep isl_qpolynomial
*qp
, FILE *out
,
857 unsigned output_format
)
864 isl_assert(qp
->dim
->ctx
, output_format
== ISL_FORMAT_ISL
, return);
865 p
= isl_printer_to_file(qp
->dim
->ctx
, out
);
866 p
= isl_printer_print_qpolynomial(p
, qp
);
870 static __isl_give isl_printer
*qpolynomial_fold_print(
871 __isl_keep isl_qpolynomial_fold
*fold
, __isl_take isl_printer
*p
)
875 if (fold
->type
== isl_fold_min
)
876 p
= isl_printer_print_str(p
, "min");
877 else if (fold
->type
== isl_fold_max
)
878 p
= isl_printer_print_str(p
, "max");
879 p
= isl_printer_print_str(p
, "(");
880 for (i
= 0; i
< fold
->n
; ++i
) {
882 p
= isl_printer_print_str(p
, ", ");
883 p
= isl_printer_print_qpolynomial(p
, fold
->qp
[i
]);
885 p
= isl_printer_print_str(p
, ")");
889 __isl_give isl_printer
*isl_printer_print_qpolynomial_fold(
890 __isl_take isl_printer
*p
, __isl_keep isl_qpolynomial_fold
*fold
)
894 p
= qpolynomial_fold_print(fold
, p
);
901 void isl_qpolynomial_fold_print(__isl_keep isl_qpolynomial_fold
*fold
,
902 FILE *out
, unsigned output_format
)
909 isl_assert(fold
->dim
->ctx
, output_format
== ISL_FORMAT_ISL
, return);
911 p
= isl_printer_to_file(fold
->dim
->ctx
, out
);
912 p
= isl_printer_print_qpolynomial_fold(p
, fold
);
917 static __isl_give isl_printer
*print_pw_qpolynomial_isl(
918 __isl_take isl_printer
*p
, __isl_keep isl_pw_qpolynomial
*pwqp
)
925 if (isl_dim_size(pwqp
->dim
, isl_dim_param
) > 0) {
926 p
= print_tuple(pwqp
->dim
, p
, isl_dim_param
, 0);
927 p
= isl_printer_print_str(p
, " -> ");
929 p
= isl_printer_print_str(p
, "{ ");
931 if (isl_dim_size(pwqp
->dim
, isl_dim_set
) > 0) {
932 p
= print_tuple(pwqp
->dim
, p
, isl_dim_set
, 1);
933 p
= isl_printer_print_str(p
, " -> ");
935 p
= isl_printer_print_str(p
, "0");
937 for (i
= 0; i
< pwqp
->n
; ++i
) {
939 p
= isl_printer_print_str(p
, "; ");
940 if (isl_dim_size(pwqp
->p
[i
].set
->dim
, isl_dim_set
) > 0) {
941 p
= print_tuple(pwqp
->p
[i
].set
->dim
, p
, isl_dim_set
, 1);
942 p
= isl_printer_print_str(p
, " -> ");
944 p
= isl_printer_print_qpolynomial(p
, pwqp
->p
[i
].qp
);
945 p
= print_disjuncts((isl_map
*)pwqp
->p
[i
].set
, p
, 1);
947 p
= isl_printer_print_str(p
, " }");
954 void isl_pw_qpolynomial_print(__isl_keep isl_pw_qpolynomial
*pwqp
, FILE *out
,
955 unsigned output_format
)
962 p
= isl_printer_to_file(pwqp
->dim
->ctx
, out
);
963 p
= isl_printer_set_output_format(p
, output_format
);
964 p
= isl_printer_print_pw_qpolynomial(p
, pwqp
);
969 static __isl_give isl_printer
*print_pw_qpolynomial_fold_isl(
970 __isl_take isl_printer
*p
, __isl_keep isl_pw_qpolynomial_fold
*pwf
)
974 if (isl_dim_size(pwf
->dim
, isl_dim_param
) > 0) {
975 p
= print_tuple(pwf
->dim
, p
, isl_dim_param
, 0);
976 p
= isl_printer_print_str(p
, " -> ");
978 p
= isl_printer_print_str(p
, "{ ");
980 if (isl_dim_size(pwf
->dim
, isl_dim_set
) > 0) {
981 p
= print_tuple(pwf
->dim
, p
, isl_dim_set
, 0);
982 p
= isl_printer_print_str(p
, " -> ");
984 p
= isl_printer_print_str(p
, "0");
986 for (i
= 0; i
< pwf
->n
; ++i
) {
988 p
= isl_printer_print_str(p
, "; ");
989 if (isl_dim_size(pwf
->p
[i
].set
->dim
, isl_dim_set
) > 0) {
990 p
= print_tuple(pwf
->p
[i
].set
->dim
, p
, isl_dim_set
, 0);
991 p
= isl_printer_print_str(p
, " -> ");
993 p
= qpolynomial_fold_print(pwf
->p
[i
].fold
, p
);
994 p
= print_disjuncts((isl_map
*)pwf
->p
[i
].set
, p
, 1);
996 p
= isl_printer_print_str(p
, " }");
1000 static __isl_give isl_printer
*print_affine_c(__isl_take isl_printer
*p
,
1001 __isl_keep isl_basic_set
*bset
, isl_int
*c
);
1003 static __isl_give isl_printer
*print_name_c(__isl_take isl_printer
*p
,
1004 __isl_keep isl_basic_set
*bset
, enum isl_dim_type type
, unsigned pos
)
1006 if (type
== isl_dim_div
) {
1007 p
= isl_printer_print_str(p
, "floord(");
1008 p
= print_affine_c(p
, bset
, bset
->div
[pos
] + 1);
1009 p
= isl_printer_print_str(p
, ", ");
1010 p
= isl_printer_print_isl_int(p
, bset
->div
[pos
][0]);
1011 p
= isl_printer_print_str(p
, ")");
1015 name
= isl_dim_get_name(bset
->dim
, type
, pos
);
1018 p
= isl_printer_print_str(p
, name
);
1023 static __isl_give isl_printer
*print_term_c(__isl_take isl_printer
*p
,
1024 __isl_keep isl_basic_set
*bset
, isl_int c
, unsigned pos
)
1026 enum isl_dim_type type
;
1027 unsigned nparam
= isl_basic_set_dim(bset
, isl_dim_param
);
1030 return isl_printer_print_isl_int(p
, c
);
1032 if (isl_int_is_one(c
))
1034 else if (isl_int_is_negone(c
))
1035 p
= isl_printer_print_str(p
, "-");
1037 p
= isl_printer_print_isl_int(p
, c
);
1038 p
= isl_printer_print_str(p
, "*");
1040 type
= pos2type(bset
->dim
, &pos
);
1041 p
= print_name_c(p
, bset
, type
, pos
);
1045 static __isl_give isl_printer
*print_affine_c(__isl_take isl_printer
*p
,
1046 __isl_keep isl_basic_set
*bset
, isl_int
*c
)
1050 unsigned len
= 1 + isl_basic_set_total_dim(bset
);
1052 for (i
= 0, first
= 1; i
< len
; ++i
) {
1054 if (isl_int_is_zero(c
[i
]))
1057 if (isl_int_is_neg(c
[i
])) {
1059 isl_int_neg(c
[i
], c
[i
]);
1060 p
= isl_printer_print_str(p
, " - ");
1062 p
= isl_printer_print_str(p
, " + ");
1065 p
= print_term(bset
->dim
, c
[i
], i
, p
, 1);
1067 isl_int_neg(c
[i
], c
[i
]);
1070 p
= isl_printer_print_str(p
, "0");
1074 static __isl_give isl_printer
*print_constraint_c(__isl_take isl_printer
*p
,
1075 __isl_keep isl_basic_set
*bset
, isl_int
*c
, const char *op
, int first
)
1078 p
= isl_printer_print_str(p
, " && ");
1080 p
= print_affine_c(p
, bset
, c
);
1081 p
= isl_printer_print_str(p
, " ");
1082 p
= isl_printer_print_str(p
, op
);
1083 p
= isl_printer_print_str(p
, " 0");
1087 static __isl_give isl_printer
*print_basic_set_c(__isl_take isl_printer
*p
,
1088 __isl_keep isl_basic_set
*bset
)
1092 for (i
= 0; i
< bset
->n_eq
; ++i
)
1093 p
= print_constraint_c(p
, bset
, bset
->eq
[i
], "==", !i
);
1094 for (i
= 0; i
< bset
->n_ineq
; ++i
)
1095 p
= print_constraint_c(p
, bset
, bset
->ineq
[i
], ">=",
1100 static __isl_give isl_printer
*print_set_c(__isl_take isl_printer
*p
,
1101 __isl_keep isl_set
*set
)
1106 p
= isl_printer_print_str(p
, "0");
1108 for (i
= 0; i
< set
->n
; ++i
) {
1110 p
= isl_printer_print_str(p
, " || ");
1112 p
= isl_printer_print_str(p
, "(");
1113 p
= print_basic_set_c(p
, set
->p
[i
]);
1115 p
= isl_printer_print_str(p
, ")");
1120 static __isl_give isl_printer
*print_qpolynomial_c(__isl_take isl_printer
*p
,
1121 __isl_keep isl_qpolynomial
*qp
)
1126 isl_qpolynomial_get_den(qp
, &den
);
1127 if (!isl_int_is_one(den
)) {
1129 p
= isl_printer_print_str(p
, "(");
1130 qp
= isl_qpolynomial_copy(qp
);
1131 f
= isl_qpolynomial_rat_cst(isl_dim_copy(qp
->dim
),
1132 den
, qp
->dim
->ctx
->one
);
1133 qp
= isl_qpolynomial_mul(qp
, f
);
1136 p
= upoly_print(qp
->upoly
, qp
->dim
, qp
->div
, p
);
1137 if (!isl_int_is_one(den
)) {
1138 p
= isl_printer_print_str(p
, ")/");
1139 p
= isl_printer_print_isl_int(p
, den
);
1140 isl_qpolynomial_free(qp
);
1146 static __isl_give isl_printer
*print_pw_qpolynomial_c(
1147 __isl_take isl_printer
*p
, __isl_keep isl_pw_qpolynomial
*pwpq
)
1151 if (pwpq
->n
== 1 && isl_set_fast_is_universe(pwpq
->p
[0].set
))
1152 return print_qpolynomial_c(p
, pwpq
->p
[0].qp
);
1154 for (i
= 0; i
< pwpq
->n
; ++i
) {
1155 p
= isl_printer_print_str(p
, "(");
1156 p
= print_set_c(p
, pwpq
->p
[i
].set
);
1157 p
= isl_printer_print_str(p
, ") ? (");
1158 p
= print_qpolynomial_c(p
, pwpq
->p
[i
].qp
);
1159 p
= isl_printer_print_str(p
, ") : ");
1162 p
= isl_printer_print_str(p
, "0");
1166 __isl_give isl_printer
*isl_printer_print_pw_qpolynomial(
1167 __isl_take isl_printer
*p
, __isl_keep isl_pw_qpolynomial
*pwqp
)
1172 if (p
->output_format
== ISL_FORMAT_ISL
)
1173 return print_pw_qpolynomial_isl(p
, pwqp
);
1174 else if (p
->output_format
== ISL_FORMAT_C
)
1175 return print_pw_qpolynomial_c(p
, pwqp
);
1176 isl_assert(p
->ctx
, 0, goto error
);
1178 isl_printer_free(p
);
1182 static __isl_give isl_printer
*print_qpolynomial_fold_c(
1183 __isl_take isl_printer
*p
, __isl_keep isl_qpolynomial_fold
*fold
)
1187 for (i
= 0; i
< fold
->n
- 1; ++i
)
1188 if (fold
->type
== isl_fold_min
)
1189 p
= isl_printer_print_str(p
, "min(");
1190 else if (fold
->type
== isl_fold_max
)
1191 p
= isl_printer_print_str(p
, "max(");
1193 for (i
= 0; i
< fold
->n
; ++i
) {
1195 p
= isl_printer_print_str(p
, ", ");
1196 p
= print_qpolynomial_c(p
, fold
->qp
[i
]);
1198 p
= isl_printer_print_str(p
, ")");
1203 static __isl_give isl_printer
*print_pw_qpolynomial_fold_c(
1204 __isl_take isl_printer
*p
, __isl_keep isl_pw_qpolynomial_fold
*pwf
)
1208 if (pwf
->n
== 1 && isl_set_fast_is_universe(pwf
->p
[0].set
))
1209 return print_qpolynomial_fold_c(p
, pwf
->p
[0].fold
);
1211 for (i
= 0; i
< pwf
->n
; ++i
) {
1212 p
= isl_printer_print_str(p
, "(");
1213 p
= print_set_c(p
, pwf
->p
[i
].set
);
1214 p
= isl_printer_print_str(p
, ") ? (");
1215 p
= print_qpolynomial_fold_c(p
, pwf
->p
[i
].fold
);
1216 p
= isl_printer_print_str(p
, ") : ");
1219 p
= isl_printer_print_str(p
, "0");
1223 __isl_give isl_printer
*isl_printer_print_pw_qpolynomial_fold(
1224 __isl_take isl_printer
*p
, __isl_keep isl_pw_qpolynomial_fold
*pwf
)
1229 if (p
->output_format
== ISL_FORMAT_ISL
)
1230 return print_pw_qpolynomial_fold_isl(p
, pwf
);
1231 else if (p
->output_format
== ISL_FORMAT_C
)
1232 return print_pw_qpolynomial_fold_c(p
, pwf
);
1233 isl_assert(p
->ctx
, 0, goto error
);
1235 isl_printer_free(p
);
1239 void isl_pw_qpolynomial_fold_print(__isl_keep isl_pw_qpolynomial_fold
*pwf
,
1240 FILE *out
, unsigned output_format
)
1247 p
= isl_printer_to_file(pwf
->dim
->ctx
, out
);
1248 p
= isl_printer_set_output_format(p
, output_format
);
1249 p
= isl_printer_print_pw_qpolynomial_fold(p
, pwf
);
1251 isl_printer_free(p
);