4 #include <NTL/vec_ZZ.h>
5 #include <NTL/mat_ZZ.h>
7 #include <polylib/polylibgmp.h>
9 #include <barvinok/barvinok.h>
10 #include <barvinok/evalue.h>
11 #include <barvinok/util.h>
12 #include "conversion.h"
13 #include "decomposer.h"
14 #include "lattice_point.h"
15 #include "reduce_domain.h"
32 #ifdef HAVE_GROWING_CHERNIKOVA
33 #define MAXRAYS (POL_NO_DUAL | POL_INTEGER)
38 /* RANGE : normal range for evalutations (-RANGE -> RANGE) */
41 /* SRANGE : small range for evalutations */
44 /* if dimension >= BIDDIM, use SRANGE */
47 /* VSRANGE : very small range for evalutations */
50 /* if dimension >= VBIDDIM, use VSRANGE */
54 #define getopt_long(a,b,c,d,e) getopt(a,b,c)
57 struct option options
[] = {
58 { "verify", no_argument
, 0, 'T' },
59 { "print-all", no_argument
, 0, 'A' },
60 { "min", required_argument
, 0, 'm' },
61 { "max", required_argument
, 0, 'M' },
62 { "range", required_argument
, 0, 'r' },
63 { "version", no_argument
, 0, 'V' },
68 #define ALLOCN(type,n) (type*)malloc((n) * sizeof(type))
70 static int type_offset(enode
*p
)
72 return p
->type
== fractional
? 1 :
73 p
->type
== flooring
? 1 : 0;
76 static void evalue_denom(evalue
*e
, Value
*d
)
78 if (value_notzero_p(e
->d
)) {
79 value_lcm(*d
, e
->d
, d
);
82 int offset
= type_offset(e
->x
.p
);
83 for (int i
= e
->x
.p
->size
-1; i
>= offset
; --i
)
84 evalue_denom(&e
->x
.p
->arr
[i
], d
);
87 static void evalue_print(std::ostream
& o
, evalue
*e
, char **p
);
88 static void evalue_print(std::ostream
& o
, evalue
*e
, char **p
, int d
)
90 if (value_notzero_p(e
->d
)) {
91 o
<< VALUE_TO_INT(e
->x
.n
) * (d
/ VALUE_TO_INT(e
->d
));
94 assert(e
->x
.p
->type
== polynomial
|| e
->x
.p
->type
== flooring
||
95 e
->x
.p
->type
== fractional
);
96 int offset
= type_offset(e
->x
.p
);
97 for (int i
= e
->x
.p
->size
-1; i
>= offset
; --i
) {
98 if (EVALUE_IS_ZERO(e
->x
.p
->arr
[i
]))
100 if (i
!= e
->x
.p
->size
-1 &&
101 (value_zero_p(e
->x
.p
->arr
[i
].d
) ||
102 value_pos_p(e
->x
.p
->arr
[i
].x
.n
)))
104 if (i
== offset
|| !(value_one_p(e
->x
.p
->arr
[i
].x
.n
) &&
105 d
== VALUE_TO_INT(e
->x
.p
->arr
[i
].d
))) {
106 if (value_zero_p(e
->x
.p
->arr
[i
].d
))
108 evalue_print(o
, &e
->x
.p
->arr
[i
], p
, d
);
109 if (value_zero_p(e
->x
.p
->arr
[i
].d
))
114 for (int j
= 0; j
< i
-offset
; ++j
) {
117 if (e
->x
.p
->type
== flooring
) {
119 evalue_print(o
, &e
->x
.p
->arr
[0], p
);
121 } else if (e
->x
.p
->type
== fractional
) {
123 evalue_print(o
, &e
->x
.p
->arr
[0], p
);
126 o
<< p
[e
->x
.p
->pos
-1];
131 static void evalue_print(std::ostream
& o
, evalue
*e
, char **p
)
137 if (value_notone_p(d
))
139 evalue_print(o
, e
, p
, VALUE_TO_INT(d
));
140 if (value_notone_p(d
))
141 o
<< ")/" << VALUE_TO_INT(d
);
145 struct indicator_term
{
150 indicator_term(unsigned dim
) {
151 den
.SetDims(dim
, dim
);
152 vertex
= new evalue
* [dim
];
154 indicator_term(const indicator_term
& src
) {
157 unsigned dim
= den
.NumCols();
158 vertex
= new evalue
* [dim
];
159 for (int i
= 0; i
< dim
; ++i
) {
160 vertex
[i
] = new evalue();
161 value_init(vertex
[i
]->d
);
162 evalue_copy(vertex
[i
], src
.vertex
[i
]);
166 unsigned dim
= den
.NumCols();
167 for (int i
= 0; i
< dim
; ++i
) {
168 free_evalue_refs(vertex
[i
]);
173 void print(ostream
& os
, char **p
);
174 void substitute(Matrix
*T
);
176 void substitute(evalue
*fract
, evalue
*val
);
177 void substitute(int pos
, evalue
*val
);
178 void reduce_in_domain(Polyhedron
*D
);
181 void indicator_term::reduce_in_domain(Polyhedron
*D
)
183 for (int k
= 0; k
< den
.NumCols(); ++k
) {
184 reduce_evalue_in_domain(vertex
[k
], D
);
185 if (evalue_range_reduction_in_domain(vertex
[k
], D
))
186 reduce_evalue(vertex
[k
]);
190 void indicator_term::print(ostream
& os
, char **p
)
192 unsigned dim
= den
.NumCols();
193 unsigned factors
= den
.NumRows();
199 for (int i
= 0; i
< dim
; ++i
) {
202 evalue_print(os
, vertex
[i
], p
);
205 for (int i
= 0; i
< factors
; ++i
) {
206 os
<< " + t" << i
<< "*[";
207 for (int j
= 0; j
< dim
; ++j
) {
216 /* Perform the substitution specified by T on the variables.
217 * T has dimension (newdim+nparam+1) x (olddim + nparam + 1).
218 * The substitution is performed as in gen_fun::substitute
220 void indicator_term::substitute(Matrix
*T
)
222 unsigned dim
= den
.NumCols();
223 unsigned nparam
= T
->NbColumns
- dim
- 1;
224 unsigned newdim
= T
->NbRows
- nparam
- 1;
227 matrix2zz(T
, trans
, newdim
, dim
);
228 trans
= transpose(trans
);
230 newvertex
= new evalue
* [newdim
];
233 v
.SetLength(nparam
+1);
236 value_init(factor
.d
);
237 value_set_si(factor
.d
, 1);
238 value_init(factor
.x
.n
);
239 for (int i
= 0; i
< newdim
; ++i
) {
240 values2zz(T
->p
[i
]+dim
, v
, nparam
+1);
241 newvertex
[i
] = multi_monom(v
);
243 for (int j
= 0; j
< dim
; ++j
) {
244 if (value_zero_p(T
->p
[i
][j
]))
248 evalue_copy(&term
, vertex
[j
]);
249 value_assign(factor
.x
.n
, T
->p
[i
][j
]);
250 emul(&factor
, &term
);
251 eadd(&term
, newvertex
[i
]);
252 free_evalue_refs(&term
);
255 free_evalue_refs(&factor
);
256 for (int i
= 0; i
< dim
; ++i
) {
257 free_evalue_refs(vertex
[i
]);
264 static void evalue_add_constant(evalue
*e
, ZZ v
)
269 /* go down to constant term */
270 while (value_zero_p(e
->d
))
271 e
= &e
->x
.p
->arr
[type_offset(e
->x
.p
)];
274 value_multiply(tmp
, tmp
, e
->d
);
275 value_addto(e
->x
.n
, e
->x
.n
, tmp
);
280 /* Make all powers in denominator lexico-positive */
281 void indicator_term::normalize()
284 extra_vertex
.SetLength(den
.NumCols());
285 for (int r
= 0; r
< den
.NumRows(); ++r
) {
286 for (int k
= 0; k
< den
.NumCols(); ++k
) {
293 extra_vertex
+= den
[r
];
297 for (int k
= 0; k
< extra_vertex
.length(); ++k
)
298 if (extra_vertex
[k
] != 0)
299 evalue_add_constant(vertex
[k
], extra_vertex
[k
]);
302 static void substitute(evalue
*e
, evalue
*fract
, evalue
*val
)
306 for (t
= e
; value_zero_p(t
->d
); t
= &t
->x
.p
->arr
[type_offset(t
->x
.p
)]) {
307 if (t
->x
.p
->type
== fractional
&& eequal(&t
->x
.p
->arr
[0], fract
))
310 if (value_notzero_p(t
->d
))
313 free_evalue_refs(&t
->x
.p
->arr
[0]);
314 evalue
*term
= &t
->x
.p
->arr
[2];
321 free_evalue_refs(term
);
327 void indicator_term::substitute(evalue
*fract
, evalue
*val
)
329 unsigned dim
= den
.NumCols();
330 for (int i
= 0; i
< dim
; ++i
) {
331 ::substitute(vertex
[i
], fract
, val
);
335 static void substitute(evalue
*e
, int pos
, evalue
*val
)
339 for (t
= e
; value_zero_p(t
->d
); t
= &t
->x
.p
->arr
[type_offset(t
->x
.p
)]) {
340 if (t
->x
.p
->type
== polynomial
&& t
->x
.p
->pos
== pos
)
343 if (value_notzero_p(t
->d
))
346 evalue
*term
= &t
->x
.p
->arr
[1];
353 free_evalue_refs(term
);
359 void indicator_term::substitute(int pos
, evalue
*val
)
361 unsigned dim
= den
.NumCols();
362 for (int i
= 0; i
< dim
; ++i
) {
363 ::substitute(vertex
[i
], pos
, val
);
367 struct indicator_constructor
: public polar_decomposer
, public vertex_decomposer
{
369 vector
<indicator_term
*> *terms
;
370 Matrix
*T
; /* Transformation to original space */
372 indicator_constructor(Polyhedron
*P
, unsigned dim
, unsigned nbV
, Matrix
*T
) :
373 vertex_decomposer(P
, nbV
, this), T(T
) {
374 vertex
.SetLength(dim
);
375 terms
= new vector
<indicator_term
*>[nbV
];
377 ~indicator_constructor() {
378 for (int i
= 0; i
< nbV
; ++i
)
379 for (int j
= 0; j
< terms
[i
].size(); ++j
)
383 void substitute(Matrix
*T
);
385 void print(ostream
& os
, char **p
);
387 virtual void handle_polar(Polyhedron
*P
, int sign
);
390 void indicator_constructor::handle_polar(Polyhedron
*C
, int s
)
392 unsigned dim
= vertex
.length();
394 assert(C
->NbRays
-1 == dim
);
396 indicator_term
*term
= new indicator_term(dim
);
398 terms
[vert
].push_back(term
);
400 lattice_point(V
, C
, vertex
, term
->vertex
);
402 for (int r
= 0; r
< dim
; ++r
) {
403 values2zz(C
->Ray
[r
]+1, term
->den
[r
], dim
);
404 for (int j
= 0; j
< dim
; ++j
) {
405 if (term
->den
[r
][j
] == 0)
407 if (term
->den
[r
][j
] > 0)
409 term
->sign
= -term
->sign
;
410 term
->den
[r
] = -term
->den
[r
];
411 vertex
+= term
->den
[r
];
416 for (int i
= 0; i
< dim
; ++i
) {
417 if (!term
->vertex
[i
]) {
418 term
->vertex
[i
] = new evalue();
419 value_init(term
->vertex
[i
]->d
);
420 value_init(term
->vertex
[i
]->x
.n
);
421 zz2value(vertex
[i
], term
->vertex
[i
]->x
.n
);
422 value_set_si(term
->vertex
[i
]->d
, 1);
427 evalue_add_constant(term
->vertex
[i
], vertex
[i
]);
435 lex_order_rows(term
->den
);
438 void indicator_constructor::print(ostream
& os
, char **p
)
440 for (int i
= 0; i
< nbV
; ++i
)
441 for (int j
= 0; j
< terms
[i
].size(); ++j
) {
442 os
<< "i: " << i
<< ", j: " << j
<< endl
;
443 terms
[i
][j
]->print(os
, p
);
448 void indicator_constructor::normalize()
450 for (int i
= 0; i
< nbV
; ++i
)
451 for (int j
= 0; j
< terms
[i
].size(); ++j
) {
453 vertex
.SetLength(terms
[i
][j
]->den
.NumCols());
454 for (int r
= 0; r
< terms
[i
][j
]->den
.NumRows(); ++r
) {
455 for (int k
= 0; k
< terms
[i
][j
]->den
.NumCols(); ++k
) {
456 if (terms
[i
][j
]->den
[r
][k
] == 0)
458 if (terms
[i
][j
]->den
[r
][k
] > 0)
460 terms
[i
][j
]->sign
= -terms
[i
][j
]->sign
;
461 terms
[i
][j
]->den
[r
] = -terms
[i
][j
]->den
[r
];
462 vertex
+= terms
[i
][j
]->den
[r
];
466 lex_order_rows(terms
[i
][j
]->den
);
467 for (int k
= 0; k
< vertex
.length(); ++k
)
469 evalue_add_constant(terms
[i
][j
]->vertex
[k
], vertex
[k
]);
476 vector
<evalue
*> floors
;
478 EDomain(Polyhedron
*D
) {
479 this->D
= Polyhedron_Copy(D
);
482 EDomain(Polyhedron
*D
, vector
<evalue
*>floors
) {
483 this->D
= Polyhedron_Copy(D
);
487 EDomain(Polyhedron
*D
, EDomain
*ED
, vector
<evalue
*>floors
) {
488 this->D
= Polyhedron_Copy(D
);
489 add_floors(ED
->floors
);
493 void add_floors(vector
<evalue
*>floors
) {
494 for (int i
= 0; i
< floors
.size(); ++i
) {
495 evalue
*f
= new evalue
;
497 evalue_copy(f
, floors
[i
]);
498 this->floors
.push_back(f
);
501 int find_floor(evalue
*needle
) {
502 for (int i
= 0; i
< floors
.size(); ++i
)
503 if (eequal(needle
, floors
[i
]))
507 void print(FILE *out
, char **p
);
509 for (int i
= 0; i
< floors
.size(); ++i
) {
510 free_evalue_refs(floors
[i
]);
519 void EDomain::print(FILE *out
, char **p
)
521 fdostream
os(dup(fileno(out
)));
522 for (int i
= 0; i
< floors
.size(); ++i
) {
523 os
<< "floor " << i
<< ": [";
524 evalue_print(os
, floors
[i
], p
);
527 Polyhedron_Print(out
, P_VALUE_FMT
, D
);
530 static void add_coeff(Value
*cons
, int len
, evalue
*coeff
, int pos
)
534 assert(value_notzero_p(coeff
->d
));
538 value_lcm(cons
[0], coeff
->d
, &tmp
);
539 value_division(tmp
, tmp
, cons
[0]);
540 Vector_Scale(cons
, cons
, tmp
, len
);
541 value_division(tmp
, cons
[0], coeff
->d
);
542 value_addmul(cons
[pos
], tmp
, coeff
->x
.n
);
547 static int evalue2constraint_r(EDomain
*D
, evalue
*E
, Value
*cons
, int len
);
549 static void add_fract(evalue
*e
, Value
*cons
, int len
, int pos
)
553 evalue_set_si(&mone
, -1, 1);
555 /* contribution of alpha * fract(X) is
558 assert(e
->x
.p
->size
== 3);
560 value_init(argument
.d
);
561 evalue_copy(&argument
, &e
->x
.p
->arr
[0]);
562 emul(&e
->x
.p
->arr
[2], &argument
);
563 evalue2constraint_r(NULL
, &argument
, cons
, len
);
564 free_evalue_refs(&argument
);
566 /* - alpha * floor(X) */
567 emul(&mone
, &e
->x
.p
->arr
[2]);
568 add_coeff(cons
, len
, &e
->x
.p
->arr
[2], pos
);
569 emul(&mone
, &e
->x
.p
->arr
[2]);
571 free_evalue_refs(&mone
);
574 static int evalue2constraint_r(EDomain
*D
, evalue
*E
, Value
*cons
, int len
)
577 if (value_zero_p(E
->d
) && E
->x
.p
->type
== fractional
) {
579 assert(E
->x
.p
->size
== 3);
580 r
= evalue2constraint_r(D
, &E
->x
.p
->arr
[1], cons
, len
);
581 assert(value_notzero_p(E
->x
.p
->arr
[2].d
));
582 if (D
&& (i
= D
->find_floor(&E
->x
.p
->arr
[0])) >= 0) {
583 add_fract(E
, cons
, len
, 1+D
->D
->Dimension
-D
->floors
.size()+i
);
585 if (value_pos_p(E
->x
.p
->arr
[2].x
.n
)) {
588 value_init(coeff
.x
.n
);
589 value_set_si(coeff
.d
, 1);
590 evalue_denom(&E
->x
.p
->arr
[0], &coeff
.d
);
591 value_decrement(coeff
.x
.n
, coeff
.d
);
592 emul(&E
->x
.p
->arr
[2], &coeff
);
593 add_coeff(cons
, len
, &coeff
, len
-1);
594 free_evalue_refs(&coeff
);
598 } else if (value_zero_p(E
->d
)) {
599 assert(E
->x
.p
->type
== polynomial
);
600 assert(E
->x
.p
->size
== 2);
601 r
= evalue2constraint_r(D
, &E
->x
.p
->arr
[0], cons
, len
) || r
;
602 add_coeff(cons
, len
, &E
->x
.p
->arr
[1], E
->x
.p
->pos
);
604 add_coeff(cons
, len
, E
, len
-1);
609 static int evalue2constraint(EDomain
*D
, evalue
*E
, Value
*cons
, int len
)
611 Vector_Set(cons
, 0, len
);
612 value_set_si(cons
[0], 1);
613 return evalue2constraint_r(D
, E
, cons
, len
);
616 static void interval_minmax(Polyhedron
*I
, int *min
, int *max
)
618 assert(I
->Dimension
== 1);
621 POL_ENSURE_VERTICES(I
);
622 for (int i
= 0; i
< I
->NbRays
; ++i
) {
623 if (value_pos_p(I
->Ray
[i
][1]))
625 else if (value_neg_p(I
->Ray
[i
][1]))
636 static void interval_minmax(Polyhedron
*D
, Matrix
*T
, int *min
, int *max
,
639 Polyhedron
*I
= Polyhedron_Image(D
, T
, MaxRays
);
640 I
= DomainConstraintSimplify(I
, MaxRays
);
643 I
= Polyhedron_Image(D
, T
, MaxRays
);
645 interval_minmax(I
, min
, max
);
652 vector
<evalue
*> max
;
654 void print(ostream
& os
, char **p
) const;
655 void resolve_existential_vars() const;
656 void substitute(Matrix
*T
, unsigned MaxRays
);
657 Vector
*eval(Value
*val
, unsigned MaxRays
) const;
660 for (int i
= 0; i
< max
.size(); ++i
) {
661 free_evalue_refs(max
[i
]);
664 Polyhedron_Free(domain
);
669 * Project on first dim dimensions
671 Polyhedron
* Polyhedron_Project_Initial(Polyhedron
*P
, int dim
)
677 if (P
->Dimension
== dim
)
678 return Polyhedron_Copy(P
);
680 T
= Matrix_Alloc(dim
+1, P
->Dimension
+1);
681 for (i
= 0; i
< dim
; ++i
)
682 value_set_si(T
->p
[i
][i
], 1);
683 value_set_si(T
->p
[dim
][P
->Dimension
], 1);
684 I
= Polyhedron_Image(P
, T
, P
->NbConstraints
);
690 vector
<indicator_term
*> term
;
693 indicator(const indicator
& ind
) {
694 for (int i
= 0; i
< ind
.term
.size(); ++i
)
695 term
.push_back(new indicator_term(*ind
.term
[i
]));
698 for (int i
= 0; i
< term
.size(); ++i
)
702 void print(ostream
& os
, char **p
);
704 void peel(int i
, int j
);
705 void combine(int i
, int j
);
706 void substitute(evalue
*equation
);
707 void reduce_in_domain(Polyhedron
*D
);
710 static Matrix
*add_ge_constraint(EDomain
*ED
, evalue
*constraint
,
711 vector
<evalue
*>& new_floors
)
713 Polyhedron
*D
= ED
->D
;
716 evalue_set_si(&mone
, -1, 1);
718 for (evalue
*e
= constraint
; value_zero_p(e
->d
);
719 e
= &e
->x
.p
->arr
[type_offset(e
->x
.p
)]) {
721 if (e
->x
.p
->type
!= fractional
)
723 for (i
= 0; i
< ED
->floors
.size(); ++i
)
724 if (eequal(&e
->x
.p
->arr
[0], ED
->floors
[i
]))
726 if (i
< ED
->floors
.size())
731 int rows
= D
->NbConstraints
+2*fract
+1;
732 int cols
= 2+D
->Dimension
+fract
;
733 Matrix
*M
= Matrix_Alloc(rows
, cols
);
734 for (int i
= 0; i
< D
->NbConstraints
; ++i
) {
735 Vector_Copy(D
->Constraint
[i
], M
->p
[i
], 1+D
->Dimension
);
736 value_assign(M
->p
[i
][1+D
->Dimension
+fract
],
737 D
->Constraint
[i
][1+D
->Dimension
]);
739 value_set_si(M
->p
[rows
-1][0], 1);
742 for (e
= constraint
; value_zero_p(e
->d
); e
= &e
->x
.p
->arr
[type_offset(e
->x
.p
)]) {
743 if (e
->x
.p
->type
== fractional
) {
746 i
= ED
->find_floor(&e
->x
.p
->arr
[0]);
748 pos
= D
->Dimension
-ED
->floors
.size()+i
;
750 pos
= D
->Dimension
+fract
;
752 add_fract(e
, M
->p
[rows
-1], cols
, 1+pos
);
754 if (pos
< D
->Dimension
)
757 /* constraints for the new floor */
758 int row
= D
->NbConstraints
+2*fract
;
759 value_set_si(M
->p
[row
][0], 1);
760 evalue2constraint_r(NULL
, &e
->x
.p
->arr
[0], M
->p
[row
], cols
);
761 value_oppose(M
->p
[row
][1+D
->Dimension
+fract
], M
->p
[row
][0]);
762 value_set_si(M
->p
[row
][0], 1);
764 Vector_Scale(M
->p
[row
]+1, M
->p
[row
+1]+1, mone
.x
.n
, cols
-1);
765 value_set_si(M
->p
[row
+1][0], 1);
766 value_addto(M
->p
[row
+1][cols
-1], M
->p
[row
+1][cols
-1],
767 M
->p
[row
+1][1+D
->Dimension
+fract
]);
768 value_decrement(M
->p
[row
+1][cols
-1], M
->p
[row
+1][cols
-1]);
770 evalue
*arg
= new evalue
;
772 evalue_copy(arg
, &e
->x
.p
->arr
[0]);
773 new_floors
.push_back(arg
);
777 assert(e
->x
.p
->type
== polynomial
);
778 assert(e
->x
.p
->size
== 2);
779 add_coeff(M
->p
[rows
-1], cols
, &e
->x
.p
->arr
[1], e
->x
.p
->pos
);
782 add_coeff(M
->p
[rows
-1], cols
, e
, cols
-1);
783 value_set_si(M
->p
[rows
-1][0], 1);
784 free_evalue_refs(&mone
);
788 void indicator::reduce_in_domain(Polyhedron
*D
)
790 for (int i
= 0; i
< term
.size(); ++i
)
791 term
[i
]->reduce_in_domain(D
);
794 void indicator::print(ostream
& os
, char **p
)
796 for (int i
= 0; i
< term
.size(); ++i
) {
797 term
[i
]->print(os
, p
);
802 /* Remove pairs of opposite terms */
803 void indicator::simplify()
805 for (int i
= 0; i
< term
.size(); ++i
) {
806 for (int j
= i
+1; j
< term
.size(); ++j
) {
807 if (term
[i
]->sign
+ term
[j
]->sign
!= 0)
809 if (term
[i
]->den
!= term
[j
]->den
)
812 for (k
= 0; k
< term
[i
]->den
.NumCols(); ++k
)
813 if (!eequal(term
[i
]->vertex
[k
], term
[j
]->vertex
[k
]))
815 if (k
< term
[i
]->den
.NumCols())
819 term
.erase(term
.begin()+j
);
820 term
.erase(term
.begin()+i
);
827 void indicator::peel(int i
, int j
)
835 int dim
= term
[i
]->den
.NumCols();
840 int n_common
= 0, n_i
= 0, n_j
= 0;
842 common
.SetDims(min(term
[i
]->den
.NumRows(), term
[j
]->den
.NumRows()), dim
);
843 rest_i
.SetDims(term
[i
]->den
.NumRows(), dim
);
844 rest_j
.SetDims(term
[j
]->den
.NumRows(), dim
);
847 for (k
= 0, l
= 0; k
< term
[i
]->den
.NumRows() && l
< term
[j
]->den
.NumRows(); ) {
848 int s
= lex_cmp(term
[i
]->den
[k
], term
[j
]->den
[l
]);
850 common
[n_common
++] = term
[i
]->den
[k
];
854 rest_i
[n_i
++] = term
[i
]->den
[k
++];
856 rest_j
[n_j
++] = term
[j
]->den
[l
++];
858 while (k
< term
[i
]->den
.NumRows())
859 rest_i
[n_i
++] = term
[i
]->den
[k
++];
860 while (l
< term
[j
]->den
.NumRows())
861 rest_j
[n_j
++] = term
[j
]->den
[l
++];
862 common
.SetDims(n_common
, dim
);
863 rest_i
.SetDims(n_i
, dim
);
864 rest_j
.SetDims(n_j
, dim
);
866 for (k
= 0; k
<= n_i
; ++k
) {
867 indicator_term
*it
= new indicator_term(*term
[i
]);
868 it
->den
.SetDims(n_common
+ k
, dim
);
869 for (l
= 0; l
< n_common
; ++l
)
870 it
->den
[l
] = common
[l
];
871 for (l
= 0; l
< k
; ++l
)
872 it
->den
[n_common
+l
] = rest_i
[l
];
873 lex_order_rows(it
->den
);
875 for (l
= 0; l
< dim
; ++l
)
876 evalue_add_constant(it
->vertex
[l
], rest_i
[k
-1][l
]);
880 for (k
= 0; k
<= n_j
; ++k
) {
881 indicator_term
*it
= new indicator_term(*term
[j
]);
882 it
->den
.SetDims(n_common
+ k
, dim
);
883 for (l
= 0; l
< n_common
; ++l
)
884 it
->den
[l
] = common
[l
];
885 for (l
= 0; l
< k
; ++l
)
886 it
->den
[n_common
+l
] = rest_j
[l
];
887 lex_order_rows(it
->den
);
889 for (l
= 0; l
< dim
; ++l
)
890 evalue_add_constant(it
->vertex
[l
], rest_j
[k
-1][l
]);
893 term
.erase(term
.begin()+j
);
894 term
.erase(term
.begin()+i
);
897 void indicator::combine(int i
, int j
)
905 int dim
= term
[i
]->den
.NumCols();
910 int n_common
= 0, n_i
= 0, n_j
= 0;
912 common
.SetDims(min(term
[i
]->den
.NumRows(), term
[j
]->den
.NumRows()), dim
);
913 rest_i
.SetDims(term
[i
]->den
.NumRows(), dim
);
914 rest_j
.SetDims(term
[j
]->den
.NumRows(), dim
);
917 for (k
= 0, l
= 0; k
< term
[i
]->den
.NumRows() && l
< term
[j
]->den
.NumRows(); ) {
918 int s
= lex_cmp(term
[i
]->den
[k
], term
[j
]->den
[l
]);
920 common
[n_common
++] = term
[i
]->den
[k
];
924 rest_i
[n_i
++] = term
[i
]->den
[k
++];
926 rest_j
[n_j
++] = term
[j
]->den
[l
++];
928 while (k
< term
[i
]->den
.NumRows())
929 rest_i
[n_i
++] = term
[i
]->den
[k
++];
930 while (l
< term
[j
]->den
.NumRows())
931 rest_j
[n_j
++] = term
[j
]->den
[l
++];
932 common
.SetDims(n_common
, dim
);
933 rest_i
.SetDims(n_i
, dim
);
934 rest_j
.SetDims(n_j
, dim
);
939 for (k
= 0; k
< (1 << n_i
); ++k
) {
940 indicator_term
*it
= new indicator_term(*term
[j
]);
941 it
->den
.SetDims(n_common
+ n_i
+ n_j
, dim
);
942 for (l
= 0; l
< n_common
; ++l
)
943 it
->den
[l
] = common
[l
];
944 for (l
= 0; l
< n_i
; ++l
)
945 it
->den
[n_common
+l
] = rest_i
[l
];
946 for (l
= 0; l
< n_j
; ++l
)
947 it
->den
[n_common
+n_i
+l
] = rest_j
[l
];
948 lex_order_rows(it
->den
);
950 for (l
= 0; l
< n_i
; ++l
) {
954 for (int m
= 0; m
< dim
; ++m
)
955 evalue_add_constant(it
->vertex
[m
], rest_i
[l
][m
]);
958 it
->sign
= -it
->sign
;
962 for (k
= 0; k
< (1 << n_j
); ++k
) {
963 indicator_term
*it
= new indicator_term(*term
[i
]);
964 it
->den
.SetDims(n_common
+ n_i
+ n_j
, dim
);
965 for (l
= 0; l
< n_common
; ++l
)
966 it
->den
[l
] = common
[l
];
967 for (l
= 0; l
< n_i
; ++l
)
968 it
->den
[n_common
+l
] = rest_i
[l
];
969 for (l
= 0; l
< n_j
; ++l
)
970 it
->den
[n_common
+n_i
+l
] = rest_j
[l
];
971 lex_order_rows(it
->den
);
973 for (l
= 0; l
< n_j
; ++l
) {
977 for (int m
= 0; m
< dim
; ++m
)
978 evalue_add_constant(it
->vertex
[m
], rest_j
[l
][m
]);
981 it
->sign
= -it
->sign
;
986 term
.erase(term
.begin()+j
);
987 term
.erase(term
.begin()+i
);
990 void indicator::substitute(evalue
*equation
)
992 evalue
*fract
= NULL
;
993 evalue
*val
= new evalue
;
995 evalue_copy(val
, equation
);
998 value_init(factor
.d
);
999 value_init(factor
.x
.n
);
1002 for (e
= val
; value_zero_p(e
->d
) && e
->x
.p
->type
!= fractional
;
1003 e
= &e
->x
.p
->arr
[type_offset(e
->x
.p
)])
1006 if (value_zero_p(e
->d
) && e
->x
.p
->type
== fractional
)
1007 fract
= &e
->x
.p
->arr
[0];
1009 for (e
= val
; value_zero_p(e
->d
) && e
->x
.p
->type
!= polynomial
;
1010 e
= &e
->x
.p
->arr
[type_offset(e
->x
.p
)])
1012 assert(value_zero_p(e
->d
) && e
->x
.p
->type
== polynomial
);
1015 int offset
= type_offset(e
->x
.p
);
1017 assert(value_notzero_p(e
->x
.p
->arr
[offset
+1].d
));
1018 assert(value_notzero_p(e
->x
.p
->arr
[offset
+1].x
.n
));
1019 if (value_neg_p(e
->x
.p
->arr
[offset
+1].x
.n
)) {
1020 value_oppose(factor
.d
, e
->x
.p
->arr
[offset
+1].x
.n
);
1021 value_assign(factor
.x
.n
, e
->x
.p
->arr
[offset
+1].d
);
1023 value_assign(factor
.d
, e
->x
.p
->arr
[offset
+1].x
.n
);
1024 value_oppose(factor
.x
.n
, e
->x
.p
->arr
[offset
+1].d
);
1027 free_evalue_refs(&e
->x
.p
->arr
[offset
+1]);
1030 *e
= e
->x
.p
->arr
[offset
];
1035 for (int i
= 0; i
< term
.size(); ++i
)
1036 term
[i
]->substitute(fract
, val
);
1038 free_evalue_refs(&p
->arr
[0]);
1040 for (int i
= 0; i
< term
.size(); ++i
)
1041 term
[i
]->substitute(p
->pos
, val
);
1044 free_evalue_refs(&factor
);
1045 free_evalue_refs(val
);
1051 static void print_varlist(ostream
& os
, int n
, char **names
)
1055 for (i
= 0; i
< n
; ++i
) {
1063 static void print_term(ostream
& os
, Value v
, int pos
, int dim
,
1064 char **names
, int *first
)
1066 if (value_zero_p(v
)) {
1067 if (first
&& *first
&& pos
>= dim
)
1073 if (!*first
&& value_pos_p(v
))
1078 if (value_mone_p(v
)) {
1080 } else if (!value_one_p(v
))
1081 os
<< VALUE_TO_INT(v
);
1084 os
<< VALUE_TO_INT(v
);
1087 /* We put all possible existentially quantified variables at the back
1088 * and so if any equalities exist between these variables and the
1089 * other variables, then PolyLib will replace all occurrences of some
1090 * of the other variables by some existentially quantified variables.
1091 * We want the output to have as few as possible references to the
1092 * existentially quantified variables, so we undo what PolyLib did here.
1094 void resolve_existential_vars(Polyhedron
*domain
, unsigned dim
)
1096 int last
= domain
->NbEq
- 1;
1097 /* Matrix "view" of domain for ExchangeRows */
1099 M
.NbRows
= domain
->NbConstraints
;
1100 M
.NbColumns
= domain
->Dimension
+2;
1101 M
.p_Init
= domain
->p_Init
;
1102 M
.p
= domain
->Constraint
;
1105 value_set_si(mone
, -1);
1106 for (int e
= domain
->Dimension
-1; e
>= dim
; --e
) {
1108 for (r
= last
; r
>= 0; --r
)
1109 if (value_notzero_p(domain
->Constraint
[r
][1+e
]))
1114 ExchangeRows(&M
, r
, last
);
1116 /* Combine uses the coefficient as a multiplier, so it must
1117 * be positive, since we are modifying an inequality.
1119 if (value_neg_p(domain
->Constraint
[last
][1+e
]))
1120 Vector_Scale(domain
->Constraint
[last
]+1, domain
->Constraint
[last
]+1,
1121 mone
, domain
->Dimension
+1);
1123 for (int c
= 0; c
< domain
->NbConstraints
; ++c
) {
1126 if (value_notzero_p(domain
->Constraint
[c
][1+e
]))
1127 Combine(domain
->Constraint
[c
], domain
->Constraint
[last
],
1128 domain
->Constraint
[c
], 1+e
, domain
->Dimension
+1);
1135 void max_term::resolve_existential_vars() const
1137 ::resolve_existential_vars(domain
, dim
);
1140 void max_term::print(ostream
& os
, char **p
) const
1143 if (dim
< domain
->Dimension
) {
1144 resolve_existential_vars();
1145 names
= new char * [domain
->Dimension
];
1147 for (i
= 0; i
< dim
; ++i
)
1149 for ( ; i
< domain
->Dimension
; ++i
) {
1150 names
[i
] = new char[10];
1151 snprintf(names
[i
], 10, "a%d", i
- dim
);
1158 print_varlist(os
, dim
, p
);
1161 for (int i
= 0; i
< max
.size(); ++i
) {
1164 evalue_print(os
, max
[i
], p
);
1168 if (dim
< domain
->Dimension
) {
1170 print_varlist(os
, domain
->Dimension
-dim
, names
+dim
);
1173 for (int i
= 0; i
< domain
->NbConstraints
; ++i
) {
1175 int v
= First_Non_Zero(domain
->Constraint
[i
]+1, domain
->Dimension
);
1180 if (value_pos_p(domain
->Constraint
[i
][v
+1])) {
1181 print_term(os
, domain
->Constraint
[i
][v
+1], v
, domain
->Dimension
,
1183 if (value_zero_p(domain
->Constraint
[i
][0]))
1187 for (int j
= v
+1; j
<= domain
->Dimension
; ++j
) {
1188 value_oppose(tmp
, domain
->Constraint
[i
][1+j
]);
1189 print_term(os
, tmp
, j
, domain
->Dimension
,
1193 value_oppose(tmp
, domain
->Constraint
[i
][1+v
]);
1194 print_term(os
, tmp
, v
, domain
->Dimension
,
1196 if (value_zero_p(domain
->Constraint
[i
][0]))
1200 for (int j
= v
+1; j
<= domain
->Dimension
; ++j
)
1201 print_term(os
, domain
->Constraint
[i
][1+j
], j
, domain
->Dimension
,
1208 if (dim
< domain
->Dimension
) {
1209 for (int i
= dim
; i
< domain
->Dimension
; ++i
)
1215 static void evalue_substitute(evalue
*e
, evalue
**subs
)
1219 if (value_notzero_p(e
->d
))
1223 for (int i
= 0; i
< p
->size
; ++i
)
1224 evalue_substitute(&p
->arr
[i
], subs
);
1226 if (p
->type
== polynomial
)
1231 value_set_si(v
->d
, 0);
1232 v
->x
.p
= new_enode(p
->type
, 3, -1);
1233 value_clear(v
->x
.p
->arr
[0].d
);
1234 v
->x
.p
->arr
[0] = p
->arr
[0];
1235 evalue_set_si(&v
->x
.p
->arr
[1], 0, 1);
1236 evalue_set_si(&v
->x
.p
->arr
[2], 1, 1);
1239 int offset
= type_offset(p
);
1241 for (int i
= p
->size
-1; i
>= offset
+1; i
--) {
1242 emul(v
, &p
->arr
[i
]);
1243 eadd(&p
->arr
[i
], &p
->arr
[i
-1]);
1244 free_evalue_refs(&(p
->arr
[i
]));
1247 if (p
->type
!= polynomial
) {
1248 free_evalue_refs(v
);
1253 *e
= p
->arr
[offset
];
1257 /* "align" matrix to have nrows by inserting
1258 * the necessary number of rows and an equal number of columns at the end
1259 * right before the constant row/column
1261 static Matrix
*align_matrix_initial(Matrix
*M
, int nrows
)
1264 int newrows
= nrows
- M
->NbRows
;
1265 Matrix
*M2
= Matrix_Alloc(nrows
, newrows
+ M
->NbColumns
);
1266 for (i
= 0; i
< newrows
; ++i
)
1267 value_set_si(M2
->p
[M
->NbRows
-1+i
][M
->NbColumns
-1+i
], 1);
1268 for (i
= 0; i
< M
->NbRows
-1; ++i
) {
1269 Vector_Copy(M
->p
[i
], M2
->p
[i
], M
->NbColumns
-1);
1270 value_assign(M2
->p
[i
][M2
->NbColumns
-1], M
->p
[i
][M
->NbColumns
-1]);
1272 value_assign(M2
->p
[M2
->NbRows
-1][M2
->NbColumns
-1],
1273 M
->p
[M
->NbRows
-1][M
->NbColumns
-1]);
1277 /* T maps the compressed parameters to the original parameters,
1278 * while this max_term is based on the compressed parameters
1279 * and we want get the original parameters back.
1281 void max_term::substitute(Matrix
*T
, unsigned MaxRays
)
1283 int nexist
= domain
->Dimension
- (T
->NbColumns
-1);
1284 Matrix
*M
= align_matrix_initial(T
, T
->NbRows
+nexist
);
1286 Polyhedron
*D
= DomainImage(domain
, M
, MaxRays
);
1287 Polyhedron_Free(domain
);
1291 assert(T
->NbRows
== T
->NbColumns
);
1292 Matrix
*T2
= Matrix_Copy(T
);
1293 Matrix
*inv
= Matrix_Alloc(T
->NbColumns
, T
->NbRows
);
1294 int ok
= Matrix_Inverse(T2
, inv
);
1299 value_init(denom
.d
);
1300 value_init(denom
.x
.n
);
1301 value_set_si(denom
.x
.n
, 1);
1302 value_assign(denom
.d
, inv
->p
[inv
->NbRows
-1][inv
->NbColumns
-1]);
1305 v
.SetLength(inv
->NbColumns
);
1306 evalue
* subs
[inv
->NbRows
-1];
1307 for (int i
= 0; i
< inv
->NbRows
-1; ++i
) {
1308 values2zz(inv
->p
[i
], v
, v
.length());
1309 subs
[i
] = multi_monom(v
);
1310 emul(&denom
, subs
[i
]);
1312 free_evalue_refs(&denom
);
1314 for (int i
= 0; i
< max
.size(); ++i
) {
1315 evalue_substitute(max
[i
], subs
);
1316 reduce_evalue(max
[i
]);
1319 for (int i
= 0; i
< inv
->NbRows
-1; ++i
) {
1320 free_evalue_refs(subs
[i
]);
1326 int Last_Non_Zero(Value
*p
, unsigned len
)
1328 for (int i
= len
-1; i
>= 0; --i
)
1329 if (value_notzero_p(p
[i
]))
1334 static void SwapColumns(Value
**V
, int n
, int i
, int j
)
1336 for (int r
= 0; r
< n
; ++r
)
1337 value_swap(V
[r
][i
], V
[r
][j
]);
1340 static void SwapColumns(Polyhedron
*P
, int i
, int j
)
1342 SwapColumns(P
->Constraint
, P
->NbConstraints
, i
, j
);
1343 SwapColumns(P
->Ray
, P
->NbRays
, i
, j
);
1346 bool in_domain(Polyhedron
*P
, Value
*val
, unsigned dim
, unsigned MaxRays
)
1348 int nexist
= P
->Dimension
- dim
;
1349 int last
[P
->NbConstraints
];
1350 Value tmp
, min
, max
;
1351 Vector
*all_val
= Vector_Alloc(P
->Dimension
+1);
1356 resolve_existential_vars(P
, dim
);
1358 Vector_Copy(val
, all_val
->p
, dim
);
1359 value_set_si(all_val
->p
[P
->Dimension
], 1);
1362 for (int i
= 0; i
< P
->NbConstraints
; ++i
) {
1363 last
[i
] = Last_Non_Zero(P
->Constraint
[i
]+1+dim
, nexist
);
1364 if (last
[i
] == -1) {
1365 Inner_Product(P
->Constraint
[i
]+1, all_val
->p
, P
->Dimension
+1, &tmp
);
1366 if (value_neg_p(tmp
))
1368 if (i
< P
->NbEq
&& value_pos_p(tmp
))
1375 alternate
= nexist
- 1;
1376 for (i
= 0; i
< nexist
; ++i
) {
1377 bool min_set
= false;
1378 bool max_set
= false;
1379 for (int j
= 0; j
< P
->NbConstraints
; ++j
) {
1382 Inner_Product(P
->Constraint
[j
]+1, all_val
->p
, P
->Dimension
+1, &tmp
);
1383 value_oppose(tmp
, tmp
);
1385 if (!mpz_divisible_p(tmp
, P
->Constraint
[j
][1+dim
+i
]))
1387 value_division(tmp
, tmp
, P
->Constraint
[j
][1+dim
+i
]);
1388 if (!max_set
|| value_lt(tmp
, max
)) {
1390 value_assign(max
, tmp
);
1392 if (!min_set
|| value_gt(tmp
, min
)) {
1394 value_assign(min
, tmp
);
1397 if (value_pos_p(P
->Constraint
[j
][1+dim
+i
])) {
1398 mpz_cdiv_q(tmp
, tmp
, P
->Constraint
[j
][1+dim
+i
]);
1399 if (!min_set
|| value_gt(tmp
, min
)) {
1401 value_assign(min
, tmp
);
1404 mpz_fdiv_q(tmp
, tmp
, P
->Constraint
[j
][1+dim
+i
]);
1405 if (!max_set
|| value_lt(tmp
, max
)) {
1407 value_assign(max
, tmp
);
1412 /* Move another existential variable in current position */
1413 if (!max_set
|| !min_set
) {
1414 if (!(alternate
> i
)) {
1415 Matrix
*M
= Matrix_Alloc(dim
+i
, 1+P
->Dimension
+1);
1416 for (int j
= 0; j
< dim
+i
; ++j
) {
1417 value_set_si(M
->p
[j
][1+j
], -1);
1418 value_assign(M
->p
[j
][1+P
->Dimension
], all_val
->p
[j
]);
1420 Polyhedron
*Q
= AddConstraints(M
->p
[0], dim
+i
, P
, MaxRays
);
1422 Q
= DomainConstraintSimplify(Q
, MaxRays
);
1423 Vector
*sample
= Polyhedron_Sample(Q
, MaxRays
);
1426 Vector_Free(sample
);
1430 assert(alternate
> i
);
1431 SwapColumns(P
, 1+dim
+i
, 1+dim
+alternate
);
1432 resolve_existential_vars(P
, dim
);
1433 for (int j
= 0; j
< P
->NbConstraints
; ++j
) {
1434 if (j
>= P
->NbEq
&& last
[j
] < i
)
1436 last
[j
] = Last_Non_Zero(P
->Constraint
[j
]+1+dim
, nexist
);
1438 Inner_Product(P
->Constraint
[j
]+1, all_val
->p
, P
->Dimension
+1,
1440 if (value_neg_p(tmp
))
1442 if (j
< P
->NbEq
&& value_pos_p(tmp
))
1450 assert(max_set
&& min_set
);
1451 if (value_lt(max
, min
))
1453 if (value_ne(max
, min
)) {
1454 Matrix
*M
= Matrix_Alloc(dim
+i
, 1+P
->Dimension
+1);
1455 for (int j
= 0; j
< dim
+i
; ++j
) {
1456 value_set_si(M
->p
[j
][1+j
], -1);
1457 value_assign(M
->p
[j
][1+P
->Dimension
], all_val
->p
[j
]);
1459 Polyhedron
*Q
= AddConstraints(M
->p
[0], dim
+i
, P
, MaxRays
);
1461 Q
= DomainConstraintSimplify(Q
, MaxRays
);
1462 Vector
*sample
= Polyhedron_Sample(Q
, MaxRays
);
1465 Vector_Free(sample
);
1469 assert(value_eq(max
, min
));
1470 value_assign(all_val
->p
[dim
+i
], max
);
1471 alternate
= nexist
- 1;
1478 Vector_Free(all_val
);
1480 return in
|| (P
->next
&& in_domain(P
->next
, val
, dim
, MaxRays
));
1483 void compute_evalue(evalue
*e
, Value
*val
, Value
*res
)
1485 double d
= compute_evalue(e
, val
);
1490 value_set_double(*res
, d
);
1493 Vector
*max_term::eval(Value
*val
, unsigned MaxRays
) const
1495 if (dim
== domain
->Dimension
) {
1496 if (!in_domain(domain
, val
))
1499 if (!in_domain(domain
, val
, dim
, MaxRays
))
1502 Vector
*res
= Vector_Alloc(max
.size());
1503 for (int i
= 0; i
< max
.size(); ++i
) {
1504 compute_evalue(max
[i
], val
, &res
->p
[i
]);
1509 static Matrix
*remove_equalities(Polyhedron
**P
, unsigned nparam
, unsigned MaxRays
);
1511 Vector
*Polyhedron_not_empty(Polyhedron
*P
, unsigned MaxRays
)
1513 Polyhedron
*Porig
= P
;
1514 Vector
*sample
= NULL
;
1516 POL_ENSURE_VERTICES(P
);
1520 for (int i
= 0; i
< P
->NbRays
; ++i
)
1521 if (value_one_p(P
->Ray
[i
][1+P
->Dimension
])) {
1522 sample
= Vector_Alloc(P
->Dimension
+ 1);
1523 Vector_Copy(P
->Ray
[i
]+1, sample
->p
, P
->Dimension
+1);
1527 Matrix
*T
= remove_equalities(&P
, 0, MaxRays
);
1529 sample
= Polyhedron_Sample(P
, MaxRays
);
1532 Vector
*P_sample
= Vector_Alloc(Porig
->Dimension
+ 1);
1533 Matrix_Vector_Product(T
, sample
->p
, P_sample
->p
);
1534 Vector_Free(sample
);
1548 enum sign
{ le
, ge
, lge
} sign
;
1550 split (evalue
*c
, enum sign s
) : constraint(c
), sign(s
) {}
1553 static void split_on(const split
& sp
, EDomain
*D
,
1554 EDomain
**Dlt
, EDomain
**Deq
, EDomain
**Dgt
,
1558 EDomain
*EDlt
= NULL
, *EDeq
= NULL
, *EDgt
= NULL
;
1562 value_set_si(mone
, -1);
1566 vector
<evalue
*> new_floors
;
1567 M
= add_ge_constraint(D
, sp
.constraint
, new_floors
);
1568 if (sp
.sign
== split::lge
|| sp
.sign
== split::ge
) {
1569 M2
= Matrix_Copy(M
);
1570 value_decrement(M2
->p
[M2
->NbRows
-1][M2
->NbColumns
-1],
1571 M2
->p
[M2
->NbRows
-1][M2
->NbColumns
-1]);
1572 D2
= Constraints2Polyhedron(M2
, MaxRays
);
1573 EDgt
= new EDomain(D2
, D
, new_floors
);
1574 Polyhedron_Free(D2
);
1577 if (sp
.sign
== split::lge
|| sp
.sign
== split::le
) {
1578 M2
= Matrix_Copy(M
);
1579 Vector_Scale(M2
->p
[M2
->NbRows
-1]+1, M2
->p
[M2
->NbRows
-1]+1,
1580 mone
, M2
->NbColumns
-1);
1581 value_decrement(M2
->p
[M2
->NbRows
-1][M2
->NbColumns
-1],
1582 M2
->p
[M2
->NbRows
-1][M2
->NbColumns
-1]);
1583 D2
= Constraints2Polyhedron(M2
, MaxRays
);
1584 EDlt
= new EDomain(D2
, D
, new_floors
);
1585 Polyhedron_Free(D2
);
1589 assert(sp
.sign
== split::lge
|| sp
.sign
== split::ge
|| sp
.sign
== split::le
);
1590 value_set_si(M
->p
[M
->NbRows
-1][0], 0);
1591 D2
= Constraints2Polyhedron(M
, MaxRays
);
1592 EDeq
= new EDomain(D2
, D
, new_floors
);
1593 Polyhedron_Free(D2
);
1596 Vector
*sample
= D
->sample
;
1597 if (sample
&& new_floors
.size() > 0) {
1598 assert(sample
->Size
== D
->D
->Dimension
+1);
1599 sample
= Vector_Alloc(D
->D
->Dimension
+new_floors
.size()+1);
1600 Vector_Copy(D
->sample
->p
, sample
->p
, D
->D
->Dimension
);
1601 value_set_si(sample
->p
[D
->D
->Dimension
+new_floors
.size()], 1);
1602 for (int i
= 0; i
< new_floors
.size(); ++i
)
1603 compute_evalue(new_floors
[i
], sample
->p
, sample
->p
+D
->D
->Dimension
+i
);
1606 for (int i
= 0; i
< new_floors
.size(); ++i
) {
1607 free_evalue_refs(new_floors
[i
]);
1608 delete new_floors
[i
];
1612 if (sample
&& in_domain(EDeq
->D
, sample
->p
, sample
->Size
-1, MaxRays
)) {
1613 EDeq
->sample
= Vector_Alloc(sample
->Size
);
1614 Vector_Copy(sample
->p
, EDeq
->sample
->p
, sample
->Size
);
1615 } else if (!(EDeq
->sample
= Polyhedron_not_empty(EDeq
->D
, MaxRays
))) {
1621 if (sample
&& in_domain(EDgt
->D
, sample
->p
, sample
->Size
-1, MaxRays
)) {
1622 EDgt
->sample
= Vector_Alloc(sample
->Size
);
1623 Vector_Copy(sample
->p
, EDgt
->sample
->p
, sample
->Size
);
1624 } else if (!(EDgt
->sample
= Polyhedron_not_empty(EDgt
->D
, MaxRays
))) {
1630 if (sample
&& in_domain(EDlt
->D
, sample
->p
, sample
->Size
-1, MaxRays
)) {
1631 EDlt
->sample
= Vector_Alloc(sample
->Size
);
1632 Vector_Copy(sample
->p
, EDlt
->sample
->p
, sample
->Size
);
1633 } else if (!(EDlt
->sample
= Polyhedron_not_empty(EDlt
->D
, MaxRays
))) {
1642 if (sample
!= D
->sample
)
1643 Vector_Free(sample
);
1646 ostream
& operator<< (ostream
& os
, const vector
<int> & v
)
1649 for (int i
= 0; i
< v
.size(); ++i
) {
1658 static bool isTranslation(Matrix
*M
)
1661 if (M
->NbRows
!= M
->NbColumns
)
1664 for (i
= 0;i
< M
->NbRows
; i
++)
1665 for (j
= 0; j
< M
->NbColumns
-1; j
++)
1667 if(value_notone_p(M
->p
[i
][j
]))
1670 if(value_notzero_p(M
->p
[i
][j
]))
1673 return value_one_p(M
->p
[M
->NbRows
-1][M
->NbColumns
-1]);
1676 static Matrix
*compress_parameters(Polyhedron
**P
, Polyhedron
**C
,
1677 unsigned nparam
, unsigned MaxRays
)
1681 /* compress_parms doesn't like equalities that only involve parameters */
1682 for (int i
= 0; i
< (*P
)->NbEq
; ++i
)
1683 assert(First_Non_Zero((*P
)->Constraint
[i
]+1, (*P
)->Dimension
-nparam
) != -1);
1685 M
= Matrix_Alloc((*P
)->NbEq
, (*P
)->Dimension
+2);
1686 Vector_Copy((*P
)->Constraint
[0], M
->p
[0], (*P
)->NbEq
* ((*P
)->Dimension
+2));
1687 CP
= compress_parms(M
, nparam
);
1690 if (isTranslation(CP
)) {
1695 T
= align_matrix(CP
, (*P
)->Dimension
+1);
1696 *P
= Polyhedron_Preimage(*P
, T
, MaxRays
);
1699 *C
= Polyhedron_Preimage(*C
, CP
, MaxRays
);
1704 static Matrix
*remove_equalities(Polyhedron
**P
, unsigned nparam
, unsigned MaxRays
)
1706 /* Matrix "view" of equalities */
1708 M
.NbRows
= (*P
)->NbEq
;
1709 M
.NbColumns
= (*P
)->Dimension
+2;
1710 M
.p_Init
= (*P
)->p_Init
;
1711 M
.p
= (*P
)->Constraint
;
1713 Matrix
*T
= compress_variables(&M
, nparam
);
1719 if (isIdentity(T
)) {
1723 *P
= Polyhedron_Preimage(*P
, T
, MaxRays
);
1728 static vector
<max_term
*> lexmin(indicator
& ind
, EDomain
*D
, unsigned nparam
,
1729 unsigned MaxRays
, vector
<int> loc
)
1731 vector
<max_term
*> maxima
;
1732 int len
= 1 + D
->D
->Dimension
+ 1;
1738 evalue_set_si(&mone
, -1, 1);
1742 Vector
*c
= Vector_Alloc(len
);
1743 Matrix
*T
= Matrix_Alloc(2, len
-1);
1744 for (int i
= 0; i
< ind
.term
.size(); ++i
) {
1745 bool restart
= false; /* true if we have modified ind from i up */
1746 bool stop
= false; /* true if i can never be smallest */
1747 int peel
= -1; /* term to peel against */
1748 vector
<split
> splits
;
1749 if (ind
.term
[i
]->sign
< 0)
1751 int dim
= ind
.term
[i
]->den
.NumCols();
1753 for (j
= 0; j
< ind
.term
.size(); ++j
) {
1757 for (k
= 0; k
< dim
; ++k
) {
1758 /* compute ind.term->[i]->vertex[k] - ind.term->[j]->vertex[k] */
1759 evalue
*diff
= new evalue
;
1760 value_init(diff
->d
);
1761 evalue_copy(diff
, ind
.term
[j
]->vertex
[k
]);
1763 eadd(ind
.term
[i
]->vertex
[k
], diff
);
1764 reduce_evalue(diff
);
1765 int fract
= evalue2constraint(D
, diff
, c
->p
, len
);
1766 Vector_Copy(c
->p
+1, T
->p
[0], len
-1);
1767 value_assign(T
->p
[1][len
-2], c
->p
[0]);
1770 interval_minmax(D
->D
, T
, &min
, &max
, MaxRays
);
1772 free_evalue_refs(diff
);
1778 evalue2constraint(D
, diff
, c
->p
, len
);
1780 Vector_Copy(c
->p
+1, T
->p
[0], len
-1);
1781 value_assign(T
->p
[1][len
-2], c
->p
[0]);
1784 interval_minmax(D
->D
, T
, &negmin
, &negmax
, MaxRays
);
1788 free_evalue_refs(diff
);
1793 if (max
== 0 && min
== 0) {
1794 if (!EVALUE_IS_ZERO(*diff
)) {
1795 ind
.substitute(diff
);
1799 free_evalue_refs(diff
);
1805 if (min
< 0 && max
== 0)
1806 splits
.push_back(split(diff
, split::le
));
1807 else if (max
> 0 && min
== 0)
1808 splits
.push_back(split(diff
, split::ge
));
1810 splits
.push_back(split(diff
, split::lge
));
1813 if (k
== dim
&& ind
.term
[j
]->sign
< 0)
1815 if (stop
|| restart
)
1819 /* The ith entry may have been removed, so we have to consider
1823 for (j
= 0; j
< splits
.size(); ++j
) {
1824 free_evalue_refs(splits
[j
].constraint
);
1825 delete splits
[j
].constraint
;
1830 for (j
= 0; j
< splits
.size(); ++j
) {
1831 free_evalue_refs(splits
[j
].constraint
);
1832 delete splits
[j
].constraint
;
1837 // ind.peel(i, peel);
1838 ind
.combine(i
, peel
);
1840 i
= -1; /* start over */
1841 for (j
= 0; j
< splits
.size(); ++j
) {
1842 free_evalue_refs(splits
[j
].constraint
);
1843 delete splits
[j
].constraint
;
1847 if (splits
.size() != 0) {
1848 for (j
= 0; j
< splits
.size(); ++j
)
1849 if (splits
[j
].sign
== split::le
)
1851 if (j
== splits
.size())
1853 EDomain
*Dlt
, *Deq
, *Dgt
;
1854 split_on(splits
[j
], D
, &Dlt
, &Deq
, &Dgt
, MaxRays
);
1855 assert(Dlt
|| Deq
|| Dgt
);
1858 indicator
indeq(ind
);
1859 indeq
.substitute(splits
[j
].constraint
);
1860 Polyhedron
*P
= Polyhedron_Project_Initial(Deq
->D
, nparam
);
1861 P
= DomainConstraintSimplify(P
, MaxRays
);
1862 indeq
.reduce_in_domain(P
);
1865 vector
<max_term
*> maxeq
= lexmin(indeq
, Deq
, nparam
,
1867 maxima
.insert(maxima
.end(), maxeq
.begin(), maxeq
.end());
1873 indicator
indgt(ind
);
1874 Polyhedron
*P
= Polyhedron_Project_Initial(Dgt
->D
, nparam
);
1875 P
= DomainConstraintSimplify(P
, MaxRays
);
1876 indgt
.reduce_in_domain(P
);
1879 vector
<max_term
*> maxeq
= lexmin(indgt
, Dgt
, nparam
,
1881 maxima
.insert(maxima
.end(), maxeq
.begin(), maxeq
.end());
1887 Polyhedron
*P
= Polyhedron_Project_Initial(Dlt
->D
, nparam
);
1888 P
= DomainConstraintSimplify(P
, MaxRays
);
1889 ind
.reduce_in_domain(P
);
1895 if (splits
.size() > 1) {
1896 vector
<max_term
*> maxeq
= lexmin(ind
, Dlt
, nparam
,
1898 maxima
.insert(maxima
.end(), maxeq
.begin(), maxeq
.end());
1899 for (j
= 0; j
< splits
.size(); ++j
) {
1900 free_evalue_refs(splits
[j
].constraint
);
1901 delete splits
[j
].constraint
;
1906 /* the vertex turned out not to be minimal */
1907 for (j
= 0; j
< splits
.size(); ++j
) {
1908 free_evalue_refs(splits
[j
].constraint
);
1909 delete splits
[j
].constraint
;
1914 max_term
*maximum
= new max_term
;
1915 maxima
.push_back(maximum
);
1916 maximum
->dim
= nparam
;
1917 maximum
->domain
= Polyhedron_Copy(D
->D
);
1918 for (int j
= 0; j
< dim
; ++j
) {
1919 evalue
*E
= new evalue
;
1921 evalue_copy(E
, ind
.term
[i
]->vertex
[j
]);
1922 if (evalue_frac2floor_in_domain(E
, D
->D
))
1924 maximum
->max
.push_back(E
);
1933 free_evalue_refs(&mone
);
1939 static vector
<max_term
*> lexmin(Polyhedron
*P
, Polyhedron
*C
, unsigned MaxRays
)
1941 unsigned nparam
= C
->Dimension
;
1942 Param_Polyhedron
*PP
= NULL
;
1943 Polyhedron
*CEq
= NULL
, *pVD
;
1945 Matrix
*T
= NULL
, *CP
= NULL
;
1946 Param_Domain
*D
, *next
;
1948 Polyhedron
*Porig
= P
;
1949 Polyhedron
*Corig
= C
;
1951 vector
<max_term
*> all_max
;
1957 POL_ENSURE_VERTICES(P
);
1962 assert(P
->NbBid
== 0);
1966 CP
= compress_parameters(&P
, &C
, nparam
, MaxRays
);
1968 T
= remove_equalities(&P
, nparam
, MaxRays
);
1969 if (P
!= Q
&& Q
!= Porig
)
1979 PP
= Polyhedron2Param_SimplifiedDomain(&P
,C
,
1980 (MaxRays
& POL_NO_DUAL
) ? 0 : MaxRays
,
1982 if (P
!= Q
&& Q
!= Porig
)
1986 if (isIdentity(CT
)) {
1990 nparam
= CT
->NbRows
- 1;
1993 unsigned dim
= P
->Dimension
- nparam
;
1996 for (nd
= 0, D
=PP
->D
; D
; ++nd
, D
=D
->next
);
1997 Polyhedron
**fVD
= new Polyhedron
*[nd
];
1999 indicator_constructor
ic(P
, dim
, PP
->nbV
, T
);
2001 for (i
= 0, V
= PP
->V
; V
; V
= V
->next
, i
++) {
2002 ic
.decompose_at_vertex(V
, i
, MaxRays
);
2005 for (nd
= 0, D
=PP
->D
; D
; D
=next
) {
2008 Polyhedron
*rVD
= reduce_domain(D
->Domain
, CT
, CEq
,
2013 pVD
= CT
? DomainImage(rVD
,CT
,MaxRays
) : rVD
;
2017 FORALL_PVertex_in_ParamPolyhedron(V
,D
,PP
) // _i is internal counter
2018 for (int j
= 0; j
< ic
.terms
[_i
].size(); ++j
) {
2019 indicator_term
*term
= new indicator_term(*ic
.terms
[_i
][j
]);
2020 term
->reduce_in_domain(pVD
);
2021 ind
.term
.push_back(term
);
2023 END_FORALL_PVertex_in_ParamPolyhedron
;
2029 vector
<max_term
*> maxima
= lexmin(ind
, &epVD
, nparam
, MaxRays
, loc
);
2031 for (int j
= 0; j
< maxima
.size(); ++j
)
2032 maxima
[j
]->substitute(CP
, MaxRays
);
2033 all_max
.insert(all_max
.end(), maxima
.begin(), maxima
.end());
2044 Param_Polyhedron_Free(PP
);
2046 Polyhedron_Free(CEq
);
2047 for (--nd
; nd
>= 0; --nd
) {
2048 Domain_Free(fVD
[nd
]);
2059 static void verify_results(Polyhedron
*A
, Polyhedron
*C
,
2060 vector
<max_term
*>& maxima
, int m
, int M
,
2061 int print_all
, unsigned MaxRays
);
2063 int main(int argc
, char **argv
)
2068 char **iter_names
, **param_names
;
2073 int m
= INT_MAX
, M
= INT_MIN
, r
;
2074 int print_solution
= 1;
2076 while ((c
= getopt_long(argc
, argv
, "TAm:M:r:V", options
, &ind
)) != -1) {
2098 printf(barvinok_version());
2105 C
= Constraints2Polyhedron(MA
, MAXRAYS
);
2107 fscanf(stdin
, " %d", &bignum
);
2108 assert(bignum
== -1);
2110 A
= Constraints2Polyhedron(MA
, MAXRAYS
);
2113 if (A
->Dimension
>= VBIGDIM
)
2115 else if (A
->Dimension
>= BIGDIM
)
2124 if (verify
&& m
> M
) {
2125 fprintf(stderr
,"Nothing to do: min > max !\n");
2131 iter_names
= util_generate_names(A
->Dimension
- C
->Dimension
, "i");
2132 param_names
= util_generate_names(C
->Dimension
, "p");
2133 if (print_solution
) {
2134 Polyhedron_Print(stdout
, P_VALUE_FMT
, A
);
2135 Polyhedron_Print(stdout
, P_VALUE_FMT
, C
);
2137 vector
<max_term
*> maxima
= lexmin(A
, C
, MAXRAYS
);
2139 for (int i
= 0; i
< maxima
.size(); ++i
)
2140 maxima
[i
]->print(cout
, param_names
);
2143 verify_results(A
, C
, maxima
, m
, M
, print_all
, MAXRAYS
);
2145 for (int i
= 0; i
< maxima
.size(); ++i
)
2148 util_free_names(A
->Dimension
- C
->Dimension
, iter_names
);
2149 util_free_names(C
->Dimension
, param_names
);
2156 static bool lexmin(int pos
, Polyhedron
*P
, Value
*context
)
2165 value_init(LB
); value_init(UB
); value_init(k
);
2168 lu_flags
= lower_upper_bounds(pos
,P
,context
,&LB
,&UB
);
2169 assert(!(lu_flags
& LB_INFINITY
));
2171 value_set_si(context
[pos
],0);
2172 if (!lu_flags
&& value_lt(UB
,LB
)) {
2173 value_clear(LB
); value_clear(UB
); value_clear(k
);
2177 value_assign(context
[pos
], LB
);
2178 value_clear(LB
); value_clear(UB
); value_clear(k
);
2181 for (value_assign(k
,LB
); lu_flags
|| value_le(k
,UB
); value_increment(k
,k
)) {
2182 value_assign(context
[pos
],k
);
2183 if ((found
= lexmin(pos
+1, P
->next
, context
)))
2187 value_set_si(context
[pos
],0);
2188 value_clear(LB
); value_clear(UB
); value_clear(k
);
2192 static void print_list(FILE *out
, Value
*z
, char* brackets
, int len
)
2194 fprintf(out
, "%c", brackets
[0]);
2195 value_print(out
, VALUE_FMT
,z
[0]);
2196 for (int k
= 1; k
< len
; ++k
) {
2198 value_print(out
, VALUE_FMT
,z
[k
]);
2200 fprintf(out
, "%c", brackets
[1]);
2203 static int check_poly(Polyhedron
*S
, Polyhedron
*CS
, vector
<max_term
*>& maxima
,
2204 int nparam
, int pos
, Value
*z
, int print_all
, int st
,
2207 if (pos
== nparam
) {
2209 bool found
= lexmin(1, S
, z
);
2213 print_list(stdout
, z
+S
->Dimension
-nparam
+1, "()", nparam
);
2216 print_list(stdout
, z
+1, "[]", S
->Dimension
-nparam
);
2221 for (int i
= 0; i
< maxima
.size(); ++i
)
2222 if ((min
= maxima
[i
]->eval(z
+S
->Dimension
-nparam
+1, MaxRays
)))
2225 int ok
= !(found
^ !!min
);
2227 for (int i
= 0; i
< S
->Dimension
-nparam
; ++i
)
2228 if (value_ne(z
[1+i
], min
->p
[i
])) {
2235 fprintf(stderr
, "Error !\n");
2236 fprintf(stderr
, "lexmin");
2237 print_list(stderr
, z
+S
->Dimension
-nparam
+1, "()", nparam
);
2238 fprintf(stderr
, " should be ");
2240 print_list(stderr
, z
+1, "[]", S
->Dimension
-nparam
);
2241 fprintf(stderr
, " while digging gives ");
2243 print_list(stderr
, min
->p
, "[]", S
->Dimension
-nparam
);
2244 fprintf(stderr
, ".\n");
2246 } else if (print_all
)
2251 for (k
= 1; k
<= S
->Dimension
-nparam
; ++k
)
2252 value_set_si(z
[k
], 0);
2260 !(lower_upper_bounds(1+pos
, CS
, &z
[S
->Dimension
-nparam
], &LB
, &UB
));
2261 for (value_assign(tmp
,LB
); value_le(tmp
,UB
); value_increment(tmp
,tmp
)) {
2263 int k
= VALUE_TO_INT(tmp
);
2264 if (!pos
&& !(k
%st
)) {
2269 value_assign(z
[pos
+S
->Dimension
-nparam
+1],tmp
);
2270 if (!check_poly(S
, CS
->next
, maxima
, nparam
, pos
+1, z
, print_all
, st
,
2278 value_set_si(z
[pos
+S
->Dimension
-nparam
+1],0);
2286 void verify_results(Polyhedron
*A
, Polyhedron
*C
, vector
<max_term
*>& maxima
,
2287 int m
, int M
, int print_all
, unsigned MaxRays
)
2289 Polyhedron
*CC
, *CC2
, *CS
, *S
;
2290 unsigned nparam
= C
->Dimension
;
2295 CC
= Polyhedron_Project(A
, nparam
);
2296 CC2
= DomainIntersection(C
, CC
, MAXRAYS
);
2300 /* Intersect context with range */
2305 MM
= Matrix_Alloc(2*C
->Dimension
, C
->Dimension
+2);
2306 for (int i
= 0; i
< C
->Dimension
; ++i
) {
2307 value_set_si(MM
->p
[2*i
][0], 1);
2308 value_set_si(MM
->p
[2*i
][1+i
], 1);
2309 value_set_si(MM
->p
[2*i
][1+C
->Dimension
], -m
);
2310 value_set_si(MM
->p
[2*i
+1][0], 1);
2311 value_set_si(MM
->p
[2*i
+1][1+i
], -1);
2312 value_set_si(MM
->p
[2*i
+1][1+C
->Dimension
], M
);
2314 CC2
= AddConstraints(MM
->p
[0], 2*CC
->Dimension
, CC
, MAXRAYS
);
2315 U
= Universe_Polyhedron(0);
2316 CS
= Polyhedron_Scan(CC2
, U
, MAXRAYS
& POL_NO_DUAL
? 0 : MAXRAYS
);
2318 Polyhedron_Free(CC2
);
2323 p
= ALLOCN(Value
, A
->Dimension
+2);
2324 for (i
=0; i
<= A
->Dimension
; i
++) {
2326 value_set_si(p
[i
],0);
2329 value_set_si(p
[i
], 1);
2331 S
= Polyhedron_Scan(A
, C
, MAXRAYS
& POL_NO_DUAL
? 0 : MAXRAYS
);
2333 if (!print_all
&& C
->Dimension
> 0) {
2338 for (int i
= m
; i
<= M
; i
+= st
)
2345 if (!(CS
&& emptyQ2(CS
)))
2346 check_poly(S
, CS
, maxima
, nparam
, 0, p
, print_all
, st
, MaxRays
);
2353 for (i
=0; i
<= (A
->Dimension
+1); i
++)
2358 Polyhedron_Free(CC
);