5548ffe095ebc449148f7d646db03a8ff3f7585c
[platform/upstream/isl.git] / isl_ilp.c
1 /*
2  * Copyright 2008-2009 Katholieke Universiteit Leuven
3  *
4  * Use of this software is governed by the GNU LGPLv2.1 license
5  *
6  * Written by Sven Verdoolaege, K.U.Leuven, Departement
7  * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
8  */
9
10 #include "isl_ilp.h"
11 #include "isl_map_private.h"
12 #include "isl_sample.h"
13 #include "isl_seq.h"
14 #include "isl_equalities.h"
15
16 /* Given a basic set "bset", construct a basic set U such that for
17  * each element x in U, the whole unit box positioned at x is inside
18  * the given basic set.
19  * Note that U may not contain all points that satisfy this property.
20  *
21  * We simply add the sum of all negative coefficients to the constant
22  * term.  This ensures that if x satisfies the resulting constraints,
23  * then x plus any sum of unit vectors satisfies the original constraints.
24  */
25 static struct isl_basic_set *unit_box_base_points(struct isl_basic_set *bset)
26 {
27         int i, j, k;
28         struct isl_basic_set *unit_box = NULL;
29         unsigned total;
30
31         if (!bset)
32                 goto error;
33
34         if (bset->n_eq != 0) {
35                 unit_box = isl_basic_set_empty_like(bset);
36                 isl_basic_set_free(bset);
37                 return unit_box;
38         }
39
40         total = isl_basic_set_total_dim(bset);
41         unit_box = isl_basic_set_alloc_dim(isl_basic_set_get_dim(bset),
42                                         0, 0, bset->n_ineq);
43
44         for (i = 0; i < bset->n_ineq; ++i) {
45                 k = isl_basic_set_alloc_inequality(unit_box);
46                 if (k < 0)
47                         goto error;
48                 isl_seq_cpy(unit_box->ineq[k], bset->ineq[i], 1 + total);
49                 for (j = 0; j < total; ++j) {
50                         if (isl_int_is_nonneg(unit_box->ineq[k][1 + j]))
51                                 continue;
52                         isl_int_add(unit_box->ineq[k][0],
53                                 unit_box->ineq[k][0], unit_box->ineq[k][1 + j]);
54                 }
55         }
56
57         isl_basic_set_free(bset);
58         return unit_box;
59 error:
60         isl_basic_set_free(bset);
61         isl_basic_set_free(unit_box);
62         return NULL;
63 }
64
65 /* Find an integer point in "bset", preferably one that is
66  * close to minimizing "f".
67  *
68  * We first check if we can easily put unit boxes inside bset.
69  * If so, we take the best base point of any of the unit boxes we can find
70  * and round it up to the nearest integer.
71  * If not, we simply pick any integer point in "bset".
72  */
73 static struct isl_vec *initial_solution(struct isl_basic_set *bset, isl_int *f)
74 {
75         enum isl_lp_result res;
76         struct isl_basic_set *unit_box;
77         struct isl_vec *sol;
78
79         unit_box = unit_box_base_points(isl_basic_set_copy(bset));
80
81         res = isl_basic_set_solve_lp(unit_box, 0, f, bset->ctx->one,
82                                         NULL, NULL, &sol);
83         if (res == isl_lp_ok) {
84                 isl_basic_set_free(unit_box);
85                 return isl_vec_ceil(sol);
86         }
87
88         isl_basic_set_free(unit_box);
89
90         return isl_basic_set_sample_vec(isl_basic_set_copy(bset));
91 }
92
93 /* Restrict "bset" to those points with values for f in the interval [l, u].
94  */
95 static struct isl_basic_set *add_bounds(struct isl_basic_set *bset,
96         isl_int *f, isl_int l, isl_int u)
97 {
98         int k;
99         unsigned total;
100
101         total = isl_basic_set_total_dim(bset);
102         bset = isl_basic_set_extend_constraints(bset, 0, 2);
103
104         k = isl_basic_set_alloc_inequality(bset);
105         if (k < 0)
106                 goto error;
107         isl_seq_cpy(bset->ineq[k], f, 1 + total);
108         isl_int_sub(bset->ineq[k][0], bset->ineq[k][0], l);
109
110         k = isl_basic_set_alloc_inequality(bset);
111         if (k < 0)
112                 goto error;
113         isl_seq_neg(bset->ineq[k], f, 1 + total);
114         isl_int_add(bset->ineq[k][0], bset->ineq[k][0], u);
115
116         return bset;
117 error:
118         isl_basic_set_free(bset);
119         return NULL;
120 }
121
122 /* Find an integer point in "bset" that minimizes f (in any) such that
123  * the value of f lies inside the interval [l, u].
124  * Return this integer point if it can be found.
125  * Otherwise, return sol.
126  *
127  * We perform a number of steps until l > u.
128  * In each step, we look for an integer point with value in either
129  * the whole interval [l, u] or half of the interval [l, l+floor(u-l-1/2)].
130  * The choice depends on whether we have found an integer point in the
131  * previous step.  If so, we look for the next point in half of the remaining
132  * interval.
133  * If we find a point, the current solution is updated and u is set
134  * to its value minus 1.
135  * If no point can be found, we update l to the upper bound of the interval
136  * we checked (u or l+floor(u-l-1/2)) plus 1.
137  */
138 static struct isl_vec *solve_ilp_search(struct isl_basic_set *bset,
139         isl_int *f, isl_int *opt, struct isl_vec *sol, isl_int l, isl_int u)
140 {
141         isl_int tmp;
142         int divide = 1;
143
144         isl_int_init(tmp);
145
146         while (isl_int_le(l, u)) {
147                 struct isl_basic_set *slice;
148                 struct isl_vec *sample;
149
150                 if (!divide)
151                         isl_int_set(tmp, u);
152                 else {
153                         isl_int_sub(tmp, u, l);
154                         isl_int_fdiv_q_ui(tmp, tmp, 2);
155                         isl_int_add(tmp, tmp, l);
156                 }
157                 slice = add_bounds(isl_basic_set_copy(bset), f, l, tmp);
158                 sample = isl_basic_set_sample_vec(slice);
159                 if (!sample) {
160                         isl_vec_free(sol);
161                         sol = NULL;
162                         break;
163                 }
164                 if (sample->size > 0) {
165                         isl_vec_free(sol);
166                         sol = sample;
167                         isl_seq_inner_product(f, sol->el, sol->size, opt);
168                         isl_int_sub_ui(u, *opt, 1);
169                         divide = 1;
170                 } else {
171                         isl_vec_free(sample);
172                         if (!divide)
173                                 break;
174                         isl_int_add_ui(l, tmp, 1);
175                         divide = 0;
176                 }
177         }
178
179         isl_int_clear(tmp);
180
181         return sol;
182 }
183
184 /* Find an integer point in "bset" that minimizes f (if any).
185  * If sol_p is not NULL then the integer point is returned in *sol_p.
186  * The optimal value of f is returned in *opt.
187  *
188  * The algorithm maintains a currently best solution and an interval [l, u]
189  * of values of f for which integer solutions could potentially still be found.
190  * The initial value of the best solution so far is any solution.
191  * The initial value of l is minimal value of f over the rationals
192  * (rounded up to the nearest integer).
193  * The initial value of u is the value of f at the initial solution minus 1.
194  *
195  * We then call solve_ilp_search to perform a binary search on the interval.
196  */
197 static enum isl_lp_result solve_ilp(struct isl_basic_set *bset,
198                                       isl_int *f, isl_int *opt,
199                                       struct isl_vec **sol_p)
200 {
201         enum isl_lp_result res;
202         isl_int l, u;
203         struct isl_vec *sol;
204
205         res = isl_basic_set_solve_lp(bset, 0, f, bset->ctx->one,
206                                         opt, NULL, &sol);
207         if (res == isl_lp_ok && isl_int_is_one(sol->el[0])) {
208                 if (sol_p)
209                         *sol_p = sol;
210                 else
211                         isl_vec_free(sol);
212                 return isl_lp_ok;
213         }
214         isl_vec_free(sol);
215         if (res == isl_lp_error || res == isl_lp_empty)
216                 return res;
217
218         sol = initial_solution(bset, f);
219         if (!sol)
220                 return isl_lp_error;
221         if (sol->size == 0) {
222                 isl_vec_free(sol);
223                 return isl_lp_empty;
224         }
225         if (res == isl_lp_unbounded) {
226                 isl_vec_free(sol);
227                 return isl_lp_unbounded;
228         }
229
230         isl_int_init(l);
231         isl_int_init(u);
232
233         isl_int_set(l, *opt);
234
235         isl_seq_inner_product(f, sol->el, sol->size, opt);
236         isl_int_sub_ui(u, *opt, 1);
237
238         sol = solve_ilp_search(bset, f, opt, sol, l, u);
239         if (!sol)
240                 res = isl_lp_error;
241
242         isl_int_clear(l);
243         isl_int_clear(u);
244
245         if (sol_p)
246                 *sol_p = sol;
247         else
248                 isl_vec_free(sol);
249
250         return res;
251 }
252
253 static enum isl_lp_result solve_ilp_with_eq(struct isl_basic_set *bset, int max,
254                                       isl_int *f, isl_int *opt,
255                                       struct isl_vec **sol_p)
256 {
257         unsigned dim;
258         enum isl_lp_result res;
259         struct isl_mat *T = NULL;
260         struct isl_vec *v;
261
262         bset = isl_basic_set_copy(bset);
263         dim = isl_basic_set_total_dim(bset);
264         v = isl_vec_alloc(bset->ctx, 1 + dim);
265         if (!v)
266                 goto error;
267         isl_seq_cpy(v->el, f, 1 + dim);
268         bset = isl_basic_set_remove_equalities(bset, &T, NULL);
269         v = isl_vec_mat_product(v, isl_mat_copy(T));
270         if (!v)
271                 goto error;
272         res = isl_basic_set_solve_ilp(bset, max, v->el, opt, sol_p);
273         isl_vec_free(v);
274         if (res == isl_lp_ok && sol_p) {
275                 *sol_p = isl_mat_vec_product(T, *sol_p);
276                 if (!*sol_p)
277                         res = isl_lp_error;
278         } else
279                 isl_mat_free(T);
280         isl_basic_set_free(bset);
281         return res;
282 error:
283         isl_mat_free(T);
284         isl_basic_set_free(bset);
285         return isl_lp_error;
286 }
287
288 /* Find an integer point in "bset" that minimizes (or maximizes if max is set)
289  * f (if any).
290  * If sol_p is not NULL then the integer point is returned in *sol_p.
291  * The optimal value of f is returned in *opt.
292  *
293  * If there is any equality among the points in "bset", then we first
294  * project it out.  Otherwise, we continue with solve_ilp above.
295  */
296 enum isl_lp_result isl_basic_set_solve_ilp(struct isl_basic_set *bset, int max,
297                                       isl_int *f, isl_int *opt,
298                                       struct isl_vec **sol_p)
299 {
300         unsigned dim;
301         enum isl_lp_result res;
302
303         if (!bset)
304                 return isl_lp_error;
305         if (sol_p)
306                 *sol_p = NULL;
307
308         isl_assert(bset->ctx, isl_basic_set_n_param(bset) == 0, goto error);
309
310         if (isl_basic_set_fast_is_empty(bset))
311                 return isl_lp_empty;
312
313         if (bset->n_eq)
314                 return solve_ilp_with_eq(bset, max, f, opt, sol_p);
315
316         dim = isl_basic_set_total_dim(bset);
317
318         if (max)
319                 isl_seq_neg(f, f, 1 + dim);
320
321         res = solve_ilp(bset, f, opt, sol_p);
322
323         if (max) {
324                 isl_seq_neg(f, f, 1 + dim);
325                 isl_int_neg(*opt, *opt);
326         }
327
328         return res;
329 error:
330         isl_basic_set_free(bset);
331         return isl_lp_error;
332 }