|
1 /* cplex.c (CPLEX-like interface to GLPK API) */ |
|
2 |
|
3 /*********************************************************************** |
|
4 * This code is part of GLPK (GNU Linear Programming Kit). |
|
5 * |
|
6 * Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, |
|
7 * 2009, 2010 Andrew Makhorin, Department for Applied Informatics, |
|
8 * Moscow Aviation Institute, Moscow, Russia. All rights reserved. |
|
9 * E-mail: <mao@gnu.org>. |
|
10 * |
|
11 * GLPK is free software: you can redistribute it and/or modify it |
|
12 * under the terms of the GNU General Public License as published by |
|
13 * the Free Software Foundation, either version 3 of the License, or |
|
14 * (at your option) any later version. |
|
15 * |
|
16 * GLPK is distributed in the hope that it will be useful, but WITHOUT |
|
17 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY |
|
18 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public |
|
19 * License for more details. |
|
20 * |
|
21 * You should have received a copy of the GNU General Public License |
|
22 * along with GLPK. If not, see <http://www.gnu.org/licenses/>. |
|
23 ***********************************************************************/ |
|
24 |
|
25 #include <ctype.h> |
|
26 #include <stdarg.h> |
|
27 #include <stdio.h> |
|
28 #include <stdlib.h> |
|
29 #include <string.h> |
|
30 #include <glpk.h> |
|
31 #include "cplex.h" |
|
32 |
|
33 struct CPXENV |
|
34 { /* environment block */ |
|
35 CPXLP *list; |
|
36 /* linked list of problem objects */ |
|
37 int *intparam; /* int intparam[]; */ |
|
38 /* integer control parameters */ |
|
39 double *dblparam; /* double dblparam[]; */ |
|
40 /* floating-point control parameters */ |
|
41 }; |
|
42 |
|
43 struct CPXLP |
|
44 { /* problem object */ |
|
45 CPXENV *env; |
|
46 /* pointer to environment block */ |
|
47 glp_prob *prob; |
|
48 /* pointer to underlying GLPK problem object */ |
|
49 int rflen; |
|
50 /* length of the array rflag */ |
|
51 char *rflag; /* char rflag[rflen]; */ |
|
52 /* rflag[i], i = 0,...,nrows-1, is a flag of i-th row: */ |
|
53 #define RF_NOT_RANGED 0 /* not ranged */ |
|
54 #define RF_RANGED_POS 1 /* ranged, RHS = lower bound */ |
|
55 #define RF_RANGED_NEG 2 /* ranged, RHS = upper bound */ |
|
56 int stat; |
|
57 /* solution status reported by CPXgetstat; zero means no solution |
|
58 exists */ |
|
59 int meth; |
|
60 /* method indicator reported by CPXgetmethod */ |
|
61 int iwlen; |
|
62 /* length of the working array */ |
|
63 int *iwork; /* int iwork[iwlen] */ |
|
64 /* working array initialized by binary zeros */ |
|
65 CPXLP *link; |
|
66 /* pointer to another problem object */ |
|
67 }; |
|
68 |
|
69 struct intparam |
|
70 { int which; |
|
71 int defv; |
|
72 int minv; |
|
73 int maxv; |
|
74 }; |
|
75 |
|
76 struct dblparam |
|
77 { int which; |
|
78 double defv; |
|
79 double minv; |
|
80 double maxv; |
|
81 }; |
|
82 |
|
83 struct errstring |
|
84 { int code; |
|
85 const char *string; |
|
86 }; |
|
87 |
|
88 #define BIGINT 2100000000 |
|
89 #define BIGDBL 1e75 |
|
90 |
|
91 static const struct intparam intparam[] = |
|
92 { {CPX_PARAM_ADVIND, 0, 0, 2}, |
|
93 {CPX_PARAM_AGGIND, -1, -1, BIGINT}, |
|
94 {CPX_PARAM_DATACHECK, CPX_OFF, CPX_OFF, CPX_ON}, |
|
95 {CPX_PARAM_DPRIIND, CPX_DPRIIND_AUTO, CPX_DPRIIND_AUTO, |
|
96 CPX_DPRIIND_DEVEX}, |
|
97 {CPX_PARAM_FASTMIP, CPX_OFF, CPX_OFF, CPX_ON}, /* ??? */ |
|
98 {CPX_PARAM_ITLIM, BIGINT, 0, BIGINT}, |
|
99 {CPX_PARAM_PERIND, CPX_OFF, CPX_OFF, CPX_ON}, |
|
100 {CPX_PARAM_PPRIIND, CPX_PPRIIND_AUTO, CPX_PPRIIND_PARTIAL, |
|
101 CPX_PPRIIND_FULL}, |
|
102 {CPX_PARAM_PREIND, CPX_ON, CPX_OFF, CPX_ON}, |
|
103 {CPX_PARAM_REINV, 0, 0, 10000}, |
|
104 {CPX_PARAM_SCRIND, CPX_OFF, CPX_OFF, CPX_ON}, |
|
105 {CPX_PARAM_SIMDISPLAY, 1, 0, 2}, |
|
106 }; |
|
107 |
|
108 static const struct dblparam dblparam[] = |
|
109 { {CPX_PARAM_EPOPT, 1e-6, 1e-9, 1e-1}, |
|
110 {CPX_PARAM_EPPER, 1e-6, 1e-8, BIGDBL}, |
|
111 {CPX_PARAM_EPRHS, 1e-6, 1e-9, 1e-1}, |
|
112 {CPX_PARAM_OBJLLIM, -BIGDBL, -BIGDBL, +BIGDBL}, |
|
113 {CPX_PARAM_OBJULIM, +BIGDBL, -BIGDBL, +BIGDBL}, |
|
114 }; |
|
115 |
|
116 static const struct errstring errstring[] = |
|
117 { {CPXERR_ARRAY_NOT_ASCENDING, "Array entry %d not ascending"}, |
|
118 {CPXERR_BAD_ARGUMENT, "Invalid argument"}, |
|
119 {CPXERR_BAD_CTYPE, "Invalid ctype entry %d"}, |
|
120 {CPXERR_BAD_FILETYPE, "Invalid filetype"}, |
|
121 {CPXERR_BAD_LUB, "Invalid bound change indicator entry %d"}, |
|
122 {CPXERR_BAD_PARAM_NUM, "Invalid parameter number"}, |
|
123 {CPXERR_BAD_SENSE, "Invalid sense entry %d"}, |
|
124 {CPXERR_BAD_STATUS, "Invalid status entry %d for basis specificat" |
|
125 "ion"}, |
|
126 {CPXERR_COL_INDEX_RANGE, "Column index %d out of range"}, |
|
127 {CPXERR_COUNT_RANGE, "Count entry %d negative or larger than allo" |
|
128 "wed"}, |
|
129 {CPXERR_DUP_ENTRY, "Duplicate entry"}, |
|
130 {CPXERR_FAIL_OPEN_WRITE, "Could not open file '%s' for writing"}, |
|
131 {CPXERR_INDEX_RANGE, "Index is outside range of valid values"}, |
|
132 {CPXERR_NEGATIVE_SURPLUS, "Insufficient array length"}, |
|
133 {CPXERR_NO_BASIC_SOLN, "No basic solution exists"}, |
|
134 {CPXERR_NO_ENVIRONMENT, "No environment exists"}, |
|
135 {CPXERR_NO_FILENAME, "File name not specified"}, |
|
136 {CPXERR_NO_MEMORY, "Out of memory"}, |
|
137 {CPXERR_NO_PROBLEM, "No problem exists"}, |
|
138 {CPXERR_NO_SOLN, "No solution exists"}, |
|
139 {CPXERR_NOT_FIXED, "Only fixed variables are pivoted out"}, |
|
140 {CPXERR_NULL_NAME, "Null pointer %d in name array"}, |
|
141 {CPXERR_NULL_POINTER, "Null pointer for required data"}, |
|
142 {CPXERR_PARAM_TOO_BIG, "Parameter value too big"}, |
|
143 {CPXERR_PARAM_TOO_SMALL, "Parameter value too small"}, |
|
144 {CPXERR_ROW_INDEX_RANGE, "Row index %d out of range"}, |
|
145 }; |
|
146 |
|
147 /**********************************************************************/ |
|
148 |
|
149 #define xassert glp_assert |
|
150 #define xprintf glp_printf |
|
151 #define xmalloc glp_malloc |
|
152 #define xcalloc glp_calloc |
|
153 #define xfree glp_free |
|
154 |
|
155 /**********************************************************************/ |
|
156 |
|
157 static int findintparam(int whichparam) |
|
158 { int k, card; |
|
159 card = sizeof(intparam) / sizeof(struct intparam); |
|
160 for (k = 0; k < card; k++) |
|
161 if (intparam[k].which == whichparam) return k; |
|
162 return -1; |
|
163 } |
|
164 |
|
165 static int getintparam(CPXENV *env, int whichparam) |
|
166 { int k; |
|
167 xassert(env != NULL); |
|
168 k = findintparam(whichparam); |
|
169 xassert(k >= 0); |
|
170 return env->intparam[k]; |
|
171 } |
|
172 |
|
173 static int finddblparam(int whichparam) |
|
174 { int k, card; |
|
175 card = sizeof(dblparam) / sizeof(struct dblparam); |
|
176 for (k = 0; k < card; k++) |
|
177 if (dblparam[k].which == whichparam) return k; |
|
178 return -1; |
|
179 } |
|
180 |
|
181 static double getdblparam(CPXENV *env, int whichparam) |
|
182 { int k; |
|
183 xassert(env != NULL); |
|
184 k = finddblparam(whichparam); |
|
185 xassert(k >= 0); |
|
186 return env->dblparam[k]; |
|
187 } |
|
188 |
|
189 static const char *finderrstring(int errcode) |
|
190 { int k, card; |
|
191 card = sizeof(errstring) / sizeof(struct errstring); |
|
192 for (k = 0; k < card; k++) |
|
193 { if (errstring[k].code == errcode) |
|
194 return errstring[k].string; |
|
195 } |
|
196 return NULL; |
|
197 } |
|
198 |
|
199 static int error(CPXENV *env, int errcode, ...) |
|
200 { va_list arg; |
|
201 char buffer[510]; |
|
202 xassert(env != NULL); |
|
203 if (getintparam(env, CPX_PARAM_SCRIND) == CPX_ON) |
|
204 { xassert(CPXgeterrorstring(env, errcode, buffer) == buffer); |
|
205 va_start(arg, errcode); |
|
206 vprintf(buffer, arg); |
|
207 va_end(arg); |
|
208 } |
|
209 return errcode; |
|
210 } |
|
211 |
|
212 static int checkenv(CPXENV *env) |
|
213 { int errcode; |
|
214 if (env == NULL) |
|
215 errcode = CPXERR_NO_ENVIRONMENT; |
|
216 else |
|
217 errcode = 0; |
|
218 return errcode; |
|
219 } |
|
220 |
|
221 static checklp(CPXENV *env, CPXLP *lp) |
|
222 { int errcode; |
|
223 errcode = checkenv(env); |
|
224 if (errcode) goto done; |
|
225 if (lp == NULL) |
|
226 errcode = error(env, CPXERR_NO_PROBLEM); |
|
227 done: return errcode; |
|
228 } |
|
229 |
|
230 static void invalidate(CPXLP *lp) |
|
231 { lp->stat = 0; |
|
232 lp->meth = CPX_ALG_NONE; |
|
233 return; |
|
234 } |
|
235 |
|
236 static void enlargerflag(CPXLP *lp) |
|
237 { int m; |
|
238 xassert(lp != NULL); |
|
239 m = glp_get_num_rows(lp->prob); |
|
240 if (lp->rflen < m) |
|
241 { int rflen = lp->rflen; |
|
242 char *rflag = lp->rflag; |
|
243 while (lp->rflen < m) |
|
244 { lp->rflen += lp->rflen; |
|
245 xassert(lp->rflen > 0); |
|
246 } |
|
247 lp->rflag = xcalloc(lp->rflen, sizeof(char)); |
|
248 memcpy(lp->rflag, rflag, rflen); |
|
249 xfree(rflag); |
|
250 } |
|
251 return; |
|
252 } |
|
253 |
|
254 static void enlargeiwork(CPXLP *lp, int len) |
|
255 { xassert(len >= 0); |
|
256 if (lp->iwlen < len) |
|
257 { xfree(lp->iwork); |
|
258 while (lp->iwlen < len) |
|
259 { lp->iwlen += lp->iwlen; |
|
260 xassert(lp->iwlen > 0); |
|
261 } |
|
262 lp->iwork = xcalloc(lp->iwlen, sizeof(int)); |
|
263 memset(lp->iwork, 0, lp->iwlen * sizeof(int)); |
|
264 } |
|
265 return; |
|
266 } |
|
267 |
|
268 /**********************************************************************/ |
|
269 |
|
270 int CPXaddcols(CPXENV *env, CPXLP *lp, int ccnt, int nzcnt, |
|
271 const double obj[], const int cmatbeg[], const int cmatind[], |
|
272 const double cmatval[], const double lb[], const double ub[], |
|
273 char *colname[]) |
|
274 { int j, k, m, n, beg, end, type, errcode; |
|
275 double lbnd, ubnd; |
|
276 errcode = checklp(env, lp); |
|
277 if (errcode) goto done; |
|
278 if (ccnt < 0 || nzcnt < 0) |
|
279 { errcode = error(env, CPXERR_BAD_ARGUMENT); |
|
280 goto done; |
|
281 } |
|
282 if (ccnt > 0) |
|
283 { if (cmatbeg == NULL || cmatind == NULL || cmatval == NULL) |
|
284 { errcode = error(env, CPXERR_NULL_POINTER); |
|
285 goto done; |
|
286 } |
|
287 } |
|
288 m = glp_get_num_rows(lp->prob); |
|
289 n = glp_get_num_cols(lp->prob); |
|
290 enlargeiwork(lp, m); |
|
291 for (j = 0; j < ccnt; j++) |
|
292 { beg = cmatbeg[j]; |
|
293 if (j > 0 && !(cmatbeg[j-1] <= beg)) |
|
294 { errcode = error(env, CPXERR_ARRAY_NOT_ASCENDING, j); |
|
295 goto done; |
|
296 } |
|
297 if (!(0 <= beg && beg <= nzcnt)) |
|
298 { errcode = error(env, CPXERR_INDEX_RANGE); |
|
299 goto done; |
|
300 } |
|
301 end = (j < ccnt-1 ? cmatbeg[j+1] : nzcnt); |
|
302 for (k = beg; k < end; k++) |
|
303 { if (!(0 <= cmatind[k] && cmatind[k] < m)) |
|
304 { errcode = error(env, CPXERR_ROW_INDEX_RANGE, k); |
|
305 goto done; |
|
306 } |
|
307 } |
|
308 errcode = 0; |
|
309 for (k = beg; k < end; k++) |
|
310 { if (lp->iwork[cmatind[k]]) |
|
311 { errcode = error(env, CPXERR_DUP_ENTRY); |
|
312 break; |
|
313 } |
|
314 lp->iwork[cmatind[k]] = 1; |
|
315 } |
|
316 for (k = beg; k < end; k++) |
|
317 lp->iwork[cmatind[k]] = 0; |
|
318 if (errcode) goto done; |
|
319 if (colname != NULL) |
|
320 { if (colname[j] == NULL) |
|
321 { errcode = error(env, CPXERR_NULL_NAME, j); |
|
322 goto done; |
|
323 } |
|
324 } |
|
325 } |
|
326 errcode = 0; |
|
327 invalidate(lp); |
|
328 if (ccnt > 0) |
|
329 glp_add_cols(lp->prob, ccnt); |
|
330 for (j = 0; j < ccnt; j++) |
|
331 { if (colname != NULL) |
|
332 glp_set_col_name(lp->prob, n+j+1, colname[j]); |
|
333 lbnd = (lb == NULL ? 0.0 : lb[j]); |
|
334 ubnd = (ub == NULL ? +CPX_INFBOUND : ub[j]); |
|
335 if (lbnd <= -CPX_INFBOUND && ubnd >= +CPX_INFBOUND) |
|
336 type = GLP_FR; |
|
337 else if (ubnd >= +CPX_INFBOUND) |
|
338 type = GLP_LO; |
|
339 else if (lbnd <= -CPX_INFBOUND) |
|
340 type = GLP_UP; |
|
341 else if (lbnd != ubnd) |
|
342 type = GLP_DB; |
|
343 else |
|
344 type = GLP_FX; |
|
345 glp_set_col_bnds(lp->prob, n+j+1, type, lbnd, ubnd); |
|
346 if (obj != NULL) |
|
347 glp_set_obj_coef(lp->prob, n+j+1, obj[j]); |
|
348 beg = cmatbeg[j]; |
|
349 end = (j < ccnt-1 ? cmatbeg[j+1] : nzcnt); |
|
350 for (k = beg; k < end; k++) |
|
351 lp->iwork[k-beg] = cmatind[k]+1; |
|
352 glp_set_mat_col(lp->prob, n+j+1, end-beg, lp->iwork-1, |
|
353 cmatval+beg-1); |
|
354 for (k = beg; k < end; k++) |
|
355 lp->iwork[k-beg] = 0; |
|
356 } |
|
357 done: return errcode; |
|
358 } |
|
359 |
|
360 int CPXaddrows(CPXENV *env, CPXLP *lp, int ccnt, int rcnt, int nzcnt, |
|
361 const double rhs[], const char sense[], const int rmatbeg[], |
|
362 const int rmatind[], const double rmatval[], char *colname[], |
|
363 char *rowname[]) |
|
364 { int i, j, k, m, n, beg, end, type, errcode; |
|
365 double temp; |
|
366 errcode = checklp(env, lp); |
|
367 if (errcode) goto done; |
|
368 if (ccnt < 0 || rcnt < 0 || nzcnt < 0) |
|
369 { errcode = error(env, CPXERR_BAD_ARGUMENT); |
|
370 goto done; |
|
371 } |
|
372 if (rcnt > 0) |
|
373 { if (rmatbeg == NULL || rmatind == NULL || rmatval == NULL) |
|
374 { errcode = error(env, CPXERR_NULL_POINTER); |
|
375 goto done; |
|
376 } |
|
377 } |
|
378 m = glp_get_num_rows(lp->prob); |
|
379 n = glp_get_num_cols(lp->prob); |
|
380 enlargeiwork(lp, n+ccnt); |
|
381 for (i = 0; i < rcnt; i++) |
|
382 { if (sense != NULL) |
|
383 { if (!(sense[i] == 'L' || sense[i] == 'E' || |
|
384 sense[i] == 'G' || sense[i] == 'R')) |
|
385 { errcode = error(env, CPXERR_BAD_SENSE, i); |
|
386 goto done; |
|
387 } |
|
388 } |
|
389 beg = rmatbeg[i]; |
|
390 if (i > 0 && !(rmatbeg[i-1] <= beg)) |
|
391 { errcode = error(env, CPXERR_ARRAY_NOT_ASCENDING, i); |
|
392 goto done; |
|
393 } |
|
394 if (!(0 <= beg && beg <= nzcnt)) |
|
395 { errcode = error(env, CPXERR_INDEX_RANGE); |
|
396 goto done; |
|
397 } |
|
398 end = (i < rcnt-1 ? rmatbeg[i+1] : nzcnt); |
|
399 for (k = beg; k < end; k++) |
|
400 { if (!(0 <= rmatind[k] && rmatind[k] < n+ccnt)) |
|
401 { errcode = error(env, CPXERR_COL_INDEX_RANGE, k); |
|
402 goto done; |
|
403 } |
|
404 } |
|
405 errcode = 0; |
|
406 for (k = beg; k < end; k++) |
|
407 { if (lp->iwork[rmatind[k]]) |
|
408 { errcode = error(env, CPXERR_DUP_ENTRY); |
|
409 break; |
|
410 } |
|
411 lp->iwork[rmatind[k]] = 1; |
|
412 } |
|
413 for (k = beg; k < end; k++) |
|
414 lp->iwork[rmatind[k]] = 0; |
|
415 if (errcode) goto done; |
|
416 if (rowname != NULL) |
|
417 { if (rowname[i] == NULL) |
|
418 { errcode = error(env, CPXERR_NULL_NAME, i); |
|
419 goto done; |
|
420 } |
|
421 } |
|
422 } |
|
423 for (j = 0; j < ccnt; j++) |
|
424 { if (colname != NULL) |
|
425 { if (colname[j] == NULL) |
|
426 { errcode = error(env, CPXERR_NULL_NAME, j); |
|
427 goto done; |
|
428 } |
|
429 } |
|
430 } |
|
431 errcode = 0; |
|
432 invalidate(lp); |
|
433 if (rcnt > 0) |
|
434 glp_add_rows(lp->prob, rcnt); |
|
435 if (ccnt > 0) |
|
436 glp_add_cols(lp->prob, ccnt); |
|
437 enlargerflag(lp); |
|
438 for (i = 0; i < rcnt; i++) |
|
439 { if (rowname != NULL) |
|
440 glp_set_row_name(lp->prob, m+i+1, rowname[i]); |
|
441 temp = (rhs == NULL ? 0.0 : rhs[i]); |
|
442 if (sense == NULL || sense[i] == 'E') |
|
443 { lp->rflag[m+i] = RF_NOT_RANGED; |
|
444 type = GLP_FX; |
|
445 } |
|
446 else if (sense[i] == 'L') |
|
447 { lp->rflag[m+i] = RF_NOT_RANGED; |
|
448 type = GLP_UP; |
|
449 } |
|
450 else if (sense[i] == 'G') |
|
451 { lp->rflag[m+i] = RF_NOT_RANGED; |
|
452 type = GLP_LO; |
|
453 } |
|
454 else if (sense[i] == 'R') |
|
455 { lp->rflag[m+i] = RF_RANGED_POS; |
|
456 type = GLP_FX; |
|
457 } |
|
458 else |
|
459 xassert(sense != sense); |
|
460 glp_set_row_bnds(lp->prob, m+i+1, type, temp, temp); |
|
461 beg = rmatbeg[i]; |
|
462 end = (i < rcnt-1 ? rmatbeg[i+1] : nzcnt); |
|
463 for (k = beg; k < end; k++) |
|
464 lp->iwork[k-beg] = rmatind[k]+1; |
|
465 glp_set_mat_row(lp->prob, m+i+1, end-beg, lp->iwork-1, |
|
466 rmatval+beg-1); |
|
467 for (k = beg; k < end; k++) |
|
468 lp->iwork[k-beg] = 0; |
|
469 } |
|
470 for (j = 0; j < ccnt; j++) |
|
471 { if (colname != NULL) |
|
472 glp_set_col_name(lp->prob, n+j+1, colname[j]); |
|
473 glp_set_col_bnds(lp->prob, n+j+1, GLP_LO, 0.0, 0.0); |
|
474 } |
|
475 done: return errcode; |
|
476 } |
|
477 |
|
478 int CPXbaropt(CPXENV *env, CPXLP *lp) |
|
479 { xassert(env == env); |
|
480 xassert(lp == lp); |
|
481 xprintf("CPXbaropt: not implemented yet\n"); |
|
482 exit(EXIT_FAILURE); |
|
483 return -1; |
|
484 } |
|
485 |
|
486 int CPXbinvrow(CPXENV *env, CPXLP *lp, int i, double y[]) |
|
487 { xassert(env == env); |
|
488 xassert(lp == lp); |
|
489 xassert(i == i); |
|
490 xassert(y == y); |
|
491 xprintf("CPXbinvrow: not implemented yet\n"); |
|
492 exit(EXIT_FAILURE); |
|
493 return -1; |
|
494 } |
|
495 |
|
496 int CPXchgbds(CPXENV *env, CPXLP *lp, int cnt, const int indices[], |
|
497 const char lu[], const double bd[]) |
|
498 { int j, n, type, errcode; |
|
499 double lbnd, ubnd; |
|
500 errcode = checklp(env, lp); |
|
501 if (errcode) goto done; |
|
502 if (cnt < 0) |
|
503 { errcode = error(env, CPXERR_BAD_ARGUMENT); |
|
504 goto done; |
|
505 } |
|
506 if (cnt > 0) |
|
507 { if (indices == NULL || lu == NULL || bd == NULL) |
|
508 { errcode = error(env, CPXERR_NULL_POINTER); |
|
509 goto done; |
|
510 } |
|
511 } |
|
512 n = glp_get_num_cols(lp->prob); |
|
513 for (j = 0; j < cnt; j++) |
|
514 { if (!(0 <= indices[j] && indices[j] < n)) |
|
515 { errcode = error(env, CPXERR_COL_INDEX_RANGE, j); |
|
516 goto done; |
|
517 } |
|
518 if (!(lu[j] == 'L' || lu[j] == 'U' || lu[j] == 'B')) |
|
519 { errcode = error(env, CPXERR_BAD_LUB, j); |
|
520 goto done; |
|
521 } |
|
522 } |
|
523 errcode = 0; |
|
524 invalidate(lp); |
|
525 for (j = 0; j < cnt; j++) |
|
526 { type = glp_get_col_type(lp->prob, indices[j]+1); |
|
527 lbnd = glp_get_col_lb(lp->prob, indices[j]+1); |
|
528 ubnd = glp_get_col_ub(lp->prob, indices[j]+1); |
|
529 if (type == GLP_FR || type == GLP_UP) |
|
530 lbnd = -CPX_INFBOUND; |
|
531 if (type == GLP_FR || type == GLP_LO) |
|
532 ubnd = +CPX_INFBOUND; |
|
533 if (lu[j] == 'L') |
|
534 lbnd = bd[j]; |
|
535 else if (lu[j] == 'U') |
|
536 ubnd = bd[j]; |
|
537 else if (lu[j] == 'B') |
|
538 lbnd = ubnd = bd[j]; |
|
539 else |
|
540 xassert(lu != lu); |
|
541 if (lbnd <= -CPX_INFBOUND && ubnd >= +CPX_INFBOUND) |
|
542 type = GLP_FR; |
|
543 else if (ubnd >= +CPX_INFBOUND) |
|
544 type = GLP_LO; |
|
545 else if (lbnd <= -CPX_INFBOUND) |
|
546 type = GLP_UP; |
|
547 else if (lbnd != ubnd) |
|
548 type = GLP_DB; |
|
549 else |
|
550 type = GLP_FX; |
|
551 glp_set_col_bnds(lp->prob, indices[j]+1, type, lbnd, ubnd); |
|
552 } |
|
553 done: return errcode; |
|
554 } |
|
555 |
|
556 int CPXchgcoeflist(CPXENV *env, CPXLP *lp, int numcoefs, |
|
557 const int rowlist[], const int collist[], const double vallist[]) |
|
558 { int i, j, k, m, n, rcnt, ccnt, len, ptr, errcode; |
|
559 int *head, *next, *ind; |
|
560 double *val; |
|
561 errcode = checklp(env, lp); |
|
562 if (errcode) goto done; |
|
563 if (numcoefs < 0) |
|
564 { errcode = error(env, CPXERR_BAD_ARGUMENT); |
|
565 goto done; |
|
566 } |
|
567 if (numcoefs == 0) |
|
568 { errcode = 0; |
|
569 goto done; |
|
570 } |
|
571 if (rowlist == NULL || collist == NULL || vallist == NULL) |
|
572 { errcode = error(env, CPXERR_NULL_POINTER); |
|
573 goto done; |
|
574 } |
|
575 /* check triplets and determine the number of rows and columns |
|
576 to be changed */ |
|
577 m = glp_get_num_rows(lp->prob); |
|
578 n = glp_get_num_cols(lp->prob); |
|
579 enlargeiwork(lp, m); |
|
580 enlargeiwork(lp, n); |
|
581 rcnt = ccnt = 0; |
|
582 for (k = 0; k < numcoefs; k++) |
|
583 { i = rowlist[k]; |
|
584 if (!(0 <= i && i < m)) |
|
585 { errcode = error(env, CPXERR_ROW_INDEX_RANGE, i); |
|
586 goto done; |
|
587 } |
|
588 if (!(lp->iwork[i] & 0x01)) |
|
589 rcnt++, lp->iwork[i] |= 0x01; |
|
590 j = collist[k]; |
|
591 if (!(0 <= j && j < n)) |
|
592 { errcode = error(env, CPXERR_COL_INDEX_RANGE, j); |
|
593 goto done; |
|
594 } |
|
595 if (!(lp->iwork[j] & 0x02)) |
|
596 ccnt++, lp->iwork[j] |= 0x02; |
|
597 } |
|
598 memset(lp->iwork, 0, m * sizeof(int)); |
|
599 memset(lp->iwork, 0, n * sizeof(int)); |
|
600 errcode = 0; |
|
601 invalidate(lp); |
|
602 if (rcnt <= ccnt) |
|
603 { /* change the matrix by rows */ |
|
604 /* build the linked list of triplets: |
|
605 head[i] is a pointer to first triplet for row i |
|
606 next[k] is a pointer to next triplet for the same row */ |
|
607 head = xcalloc(m, sizeof(int)); |
|
608 for (i = 0; i < m; i++) |
|
609 head[i] = -1; |
|
610 next = xcalloc(numcoefs, sizeof(int)); |
|
611 for (k = 0; k < numcoefs; k++) |
|
612 { i = rowlist[k]; |
|
613 next[k] = head[i]; |
|
614 head[i] = k; |
|
615 } |
|
616 /* check duplicate columns */ |
|
617 for (i = 0; i < m; i++) |
|
618 { for (k = head[i]; k >= 0; k = next[k]) |
|
619 { j = collist[k]; |
|
620 if (lp->iwork[j]) |
|
621 { xfree(head); |
|
622 xfree(next); |
|
623 errcode = error(env, CPXERR_DUP_ENTRY); |
|
624 goto done; |
|
625 } |
|
626 lp->iwork[j] = 1; |
|
627 } |
|
628 for (k = head[i]; k >= 0; k = next[k]) |
|
629 lp->iwork[collist[k]] = 0; |
|
630 } |
|
631 /* perform operation */ |
|
632 ind = xcalloc(1+n, sizeof(int)); |
|
633 val = xcalloc(1+n, sizeof(double)); |
|
634 for (i = 0; i < m; i++) |
|
635 { if (head[i] < 0) continue; |
|
636 len = glp_get_mat_row(lp->prob, i+1, ind, val); |
|
637 for (ptr = 1; ptr <= len; ptr++) |
|
638 { j = ind[ptr]-1; |
|
639 xassert(lp->iwork[j] == 0); |
|
640 lp->iwork[j] = ptr; |
|
641 } |
|
642 for (k = head[i]; k >= 0; k = next[k]) |
|
643 { j = collist[k]; |
|
644 if (lp->iwork[j] == 0) |
|
645 lp->iwork[j] = ++len; |
|
646 ptr = lp->iwork[j]; |
|
647 ind[ptr] = j+1, val[ptr] = vallist[k]; |
|
648 } |
|
649 glp_set_mat_row(lp->prob, i+1, len, ind, val); |
|
650 for (ptr = 1; ptr <= len; ptr++) |
|
651 lp->iwork[ind[ptr]-1] = 0; |
|
652 } |
|
653 } |
|
654 else |
|
655 { /* change the matrix by columns */ |
|
656 /* build the linked lists of triplets: |
|
657 head[j] is a pointer to first triplet for column j |
|
658 next[k] is a pointer to next triplet for the same column */ |
|
659 head = xcalloc(n, sizeof(int)); |
|
660 for (j = 0; j < n; j++) |
|
661 head[j] = -1; |
|
662 next = xcalloc(numcoefs, sizeof(int)); |
|
663 for (k = 0; k < numcoefs; k++) |
|
664 { j = collist[k]; |
|
665 next[k] = head[j]; |
|
666 head[j] = k; |
|
667 } |
|
668 /* check duplicate rows */ |
|
669 for (j = 0; j < n; j++) |
|
670 { for (k = head[j]; k >= 0; k = next[k]) |
|
671 { i = rowlist[k]; |
|
672 if (lp->iwork[i]) |
|
673 { xfree(head); |
|
674 xfree(next); |
|
675 errcode = error(env, CPXERR_DUP_ENTRY); |
|
676 goto done; |
|
677 } |
|
678 lp->iwork[i] = 1; |
|
679 } |
|
680 for (k = head[j]; k >= 0; k = next[k]) |
|
681 lp->iwork[rowlist[k]] = 0; |
|
682 } |
|
683 /* perform operation */ |
|
684 ind = xcalloc(1+m, sizeof(int)); |
|
685 val = xcalloc(1+m, sizeof(double)); |
|
686 for (j = 0; j < n; j++) |
|
687 { if (head[j] < 0) continue; |
|
688 len = glp_get_mat_col(lp->prob, j+1, ind, val); |
|
689 for (ptr = 1; ptr <= len; ptr++) |
|
690 { i = ind[ptr]-1; |
|
691 xassert(lp->iwork[i] == 0); |
|
692 lp->iwork[i] = ptr; |
|
693 } |
|
694 for (k = head[j]; k >= 0; k = next[k]) |
|
695 { i = rowlist[k]; |
|
696 if (lp->iwork[i] == 0) |
|
697 lp->iwork[i] = ++len; |
|
698 ptr = lp->iwork[i]; |
|
699 ind[ptr] = i+1, val[ptr] = vallist[k]; |
|
700 } |
|
701 glp_set_mat_col(lp->prob, j+1, len, ind, val); |
|
702 for (ptr = 1; ptr <= len; ptr++) |
|
703 lp->iwork[ind[ptr]-1] = 0; |
|
704 } |
|
705 } |
|
706 xfree(head); |
|
707 xfree(next); |
|
708 xfree(ind); |
|
709 xfree(val); |
|
710 done: return errcode; |
|
711 } |
|
712 |
|
713 void CPXchgobjsen(CPXENV *env, CPXLP *lp, int maxormin) |
|
714 { int errcode; |
|
715 errcode = checklp(env, lp); |
|
716 if (errcode) goto done; |
|
717 if (!(maxormin == CPX_MIN || maxormin == CPX_MAX)) |
|
718 { errcode = error(env, CPXERR_BAD_ARGUMENT); |
|
719 goto done; |
|
720 } |
|
721 errcode = 0; |
|
722 invalidate(lp); |
|
723 if (maxormin == CPX_MIN) |
|
724 glp_set_obj_dir(lp->prob, GLP_MIN); |
|
725 else |
|
726 glp_set_obj_dir(lp->prob, GLP_MAX); |
|
727 done: xassert(errcode == errcode); |
|
728 return; |
|
729 } |
|
730 |
|
731 int CPXchgsense(CPXENV *env, CPXLP *lp, int cnt, const int indices[], |
|
732 const char sense[]) |
|
733 { int i, m, type, errcode; |
|
734 double rhs; |
|
735 errcode = checklp(env, lp); |
|
736 if (errcode) goto done; |
|
737 if (cnt < 0) |
|
738 { errcode = error(env, CPXERR_BAD_ARGUMENT); |
|
739 goto done; |
|
740 } |
|
741 if (cnt > 0 && (indices == NULL || sense == NULL)) |
|
742 { errcode = error(env, CPXERR_NULL_POINTER); |
|
743 goto done; |
|
744 } |
|
745 m = glp_get_num_rows(lp->prob); |
|
746 for (i = 0; i < cnt; i++) |
|
747 { if (!(0 <= indices[i] && indices[i] < m)) |
|
748 { errcode = error(env, CPXERR_ROW_INDEX_RANGE, i); |
|
749 goto done; |
|
750 } |
|
751 if (!(sense[i] == 'L' || sense[i] == 'E' || sense[i] == 'G' || |
|
752 sense[i] == 'R')) |
|
753 { errcode = error(env, CPXERR_BAD_SENSE, i); |
|
754 goto done; |
|
755 } |
|
756 } |
|
757 errcode = 0; |
|
758 invalidate(lp); |
|
759 for (i = 0; i < cnt; i++) |
|
760 { type = glp_get_row_type(lp->prob, indices[i]+1); |
|
761 if (lp->rflag[indices[i]] == RF_NOT_RANGED) |
|
762 { if (type == GLP_LO || type == GLP_FX) |
|
763 rhs = glp_get_row_lb(lp->prob, indices[i]+1); |
|
764 else if (type == GLP_UP) |
|
765 rhs = glp_get_row_ub(lp->prob, indices[i]+1); |
|
766 else |
|
767 xassert(type != type); |
|
768 } |
|
769 else if (lp->rflag[indices[i]] == RF_RANGED_POS) |
|
770 { xassert(type == GLP_DB || type == GLP_FX); |
|
771 rhs = glp_get_row_lb(lp->prob, indices[i]+1); |
|
772 } |
|
773 else if (lp->rflag[indices[i]] == RF_RANGED_NEG) |
|
774 { xassert(type == GLP_DB); |
|
775 rhs = glp_get_row_ub(lp->prob, indices[i]+1); |
|
776 } |
|
777 else |
|
778 xassert(lp != lp); |
|
779 if (sense[i] == 'L') |
|
780 { lp->rflag[indices[i]] = RF_NOT_RANGED; |
|
781 type = GLP_UP; |
|
782 } |
|
783 else if (sense[i] == 'E') |
|
784 { lp->rflag[indices[i]] = RF_NOT_RANGED; |
|
785 type = GLP_FX; |
|
786 } |
|
787 else if (sense[i] == 'G') |
|
788 { lp->rflag[indices[i]] = RF_NOT_RANGED; |
|
789 type = GLP_LO; |
|
790 } |
|
791 else if (sense[i] == 'R') |
|
792 { lp->rflag[indices[i]] = RF_RANGED_POS; |
|
793 type = GLP_FX; |
|
794 } |
|
795 else |
|
796 xassert(sense != sense); |
|
797 glp_set_row_bnds(lp->prob, indices[i]+1, type, rhs, rhs); |
|
798 } |
|
799 done: return errcode; |
|
800 } |
|
801 |
|
802 int CPXcloseCPLEX(CPXENV **_env) |
|
803 { CPXENV *env; |
|
804 CPXLP *lp; |
|
805 int errcode; |
|
806 if (_env == NULL) |
|
807 { errcode = CPXERR_NULL_POINTER; |
|
808 goto done; |
|
809 } |
|
810 env = *_env; |
|
811 errcode = checkenv(env); |
|
812 if (errcode) goto done; |
|
813 while (env->list != NULL) |
|
814 { lp = env->list; |
|
815 errcode = CPXfreeprob(env, &lp); |
|
816 xassert(!errcode); |
|
817 } |
|
818 xfree(env->intparam); |
|
819 xfree(env->dblparam); |
|
820 xfree(env); |
|
821 *_env = NULL; |
|
822 errcode = 0; |
|
823 done: return errcode; |
|
824 } |
|
825 |
|
826 int CPXcopybase(CPXENV *env, CPXLP *lp, const int cstat[], |
|
827 const int rstat[]) |
|
828 { int i, j, m, n, stat, errcode; |
|
829 errcode = checklp(env, lp); |
|
830 if (errcode) goto done; |
|
831 m = glp_get_num_rows(lp->prob); |
|
832 n = glp_get_num_cols(lp->prob); |
|
833 if (m > 0 && rstat == NULL || n > 0 && cstat == NULL) |
|
834 { errcode = error(env, CPXERR_NULL_POINTER); |
|
835 goto done; |
|
836 } |
|
837 for (i = 0; i < m; i++) |
|
838 { if (!(rstat[i] == CPX_AT_LOWER || rstat[i] == CPX_BASIC || |
|
839 rstat[i] == CPX_AT_UPPER)) |
|
840 { errcode = error(env, CPXERR_BAD_STATUS, i); |
|
841 goto done; |
|
842 } |
|
843 } |
|
844 for (j = 0; j < n; j++) |
|
845 { if (!(cstat[j] == CPX_AT_LOWER || cstat[j] == CPX_BASIC || |
|
846 cstat[j] == CPX_AT_UPPER || cstat[j] == CPX_FREE_SUPER)) |
|
847 { errcode = error(env, CPXERR_BAD_STATUS, j); |
|
848 goto done; |
|
849 } |
|
850 } |
|
851 errcode = 0; |
|
852 invalidate(lp); |
|
853 for (i = 0; i < m; i++) |
|
854 { if (rstat[i] == CPX_AT_LOWER) |
|
855 stat = GLP_NL; |
|
856 else if (rstat[i] == CPX_BASIC) |
|
857 stat = GLP_BS; |
|
858 else if (rstat[i] == CPX_AT_UPPER) |
|
859 stat = GLP_NU; |
|
860 else |
|
861 xassert(rstat != rstat); |
|
862 glp_set_row_stat(lp->prob, i+1, stat); |
|
863 } |
|
864 for (j = 0; j < n; j++) |
|
865 { if (cstat[j] == CPX_AT_LOWER) |
|
866 stat = GLP_NL; |
|
867 else if (cstat[j] == CPX_BASIC) |
|
868 stat = GLP_BS; |
|
869 else if (cstat[j] == CPX_AT_UPPER) |
|
870 stat = GLP_NU; |
|
871 else if (cstat[j] == CPX_FREE_SUPER) |
|
872 stat = GLP_NF; |
|
873 else |
|
874 xassert(cstat != cstat); |
|
875 glp_set_col_stat(lp->prob, j+1, stat); |
|
876 } |
|
877 done: return errcode; |
|
878 } |
|
879 |
|
880 int CPXcopybasednorms(CPXENV *env, CPXLP *lp, const int cstat[], |
|
881 const int rstat[], const double dnorm[]) |
|
882 { int errcode; |
|
883 errcode = CPXcopybase(env, lp, cstat, rstat); |
|
884 xassert(dnorm == dnorm); |
|
885 return errcode; |
|
886 } |
|
887 |
|
888 int CPXcopylp(CPXENV *env, CPXLP *lp, int numcols, int numrows, |
|
889 int objsen, const double obj[], const double rhs[], |
|
890 const char sense[], const int matbeg[], const int matcnt[], |
|
891 const int matind[], const double matval[], const double lb[], |
|
892 const double ub[], const double rngval[]) |
|
893 { int errcode; |
|
894 errcode = CPXcopylpwnames(env, lp, numcols, numrows, objsen, obj, |
|
895 rhs, sense, matbeg, matcnt, matind, matval, lb, ub, rngval, |
|
896 NULL, NULL); |
|
897 return errcode; |
|
898 } |
|
899 |
|
900 int CPXcopylpwnames(CPXENV *env, CPXLP *lp, int numcols, int numrows, |
|
901 int objsen, const double obj[], const double rhs[], |
|
902 const char sense[], const int matbeg[], const int matcnt[], |
|
903 const int matind[], const double matval[], const double lb[], |
|
904 const double ub[], const double rngval[], char *colname[], |
|
905 char *rowname[]) |
|
906 { int i, j, k, beg, end, type, errcode; |
|
907 double lbnd, ubnd; |
|
908 char name[255+1]; |
|
909 errcode = checklp(env, lp); |
|
910 if (errcode) goto done; |
|
911 if (numcols < 0 || numrows < 0) |
|
912 { errcode = error(env, CPXERR_BAD_ARGUMENT); |
|
913 goto done; |
|
914 } |
|
915 if (!(objsen == CPX_MIN || objsen == CPX_MAX)) |
|
916 { errcode = error(env, CPXERR_BAD_ARGUMENT); |
|
917 goto done; |
|
918 } |
|
919 if (numcols > 0) |
|
920 { if (matbeg == NULL || matcnt == NULL || matind == NULL || |
|
921 matval == NULL) |
|
922 { errcode = error(env, CPXERR_NULL_POINTER); |
|
923 goto done; |
|
924 } |
|
925 } |
|
926 for (i = 0; i < numrows; i++) |
|
927 { if (sense != NULL) |
|
928 { if (!(sense[i] == 'L' || sense[i] == 'E' || |
|
929 sense[i] == 'G' || sense[i] == 'R')) |
|
930 { errcode = error(env, CPXERR_BAD_SENSE, i); |
|
931 goto done; |
|
932 } |
|
933 } |
|
934 if (rowname != NULL) |
|
935 { if (rowname[i] == NULL) |
|
936 { errcode = error(env, CPXERR_NULL_NAME, i); |
|
937 goto done; |
|
938 } |
|
939 } |
|
940 } |
|
941 enlargeiwork(lp, numrows); |
|
942 for (j = 0; j < numcols; j++) |
|
943 { beg = matbeg[j]; |
|
944 if (j > 0 && !(matbeg[j-1] <= beg)) |
|
945 { errcode = error(env, CPXERR_ARRAY_NOT_ASCENDING, j); |
|
946 goto done; |
|
947 } |
|
948 if (beg < 0) |
|
949 { errcode = error(env, CPXERR_INDEX_RANGE); |
|
950 goto done; |
|
951 } |
|
952 end = beg + matcnt[j]; |
|
953 if (!(beg <= end) || j < numcols-1 && !(end <= matbeg[j+1])) |
|
954 { errcode = error(env, CPXERR_COUNT_RANGE, j); |
|
955 goto done; |
|
956 } |
|
957 for (k = beg; k < end; k++) |
|
958 { if (!(0 <= matind[k] && matind[k] < numrows)) |
|
959 { errcode = error(env, CPXERR_ROW_INDEX_RANGE, k); |
|
960 goto done; |
|
961 } |
|
962 } |
|
963 errcode = 0; |
|
964 for (k = beg; k < end; k++) |
|
965 { if (lp->iwork[matind[k]]) |
|
966 { errcode = error(env, CPXERR_DUP_ENTRY); |
|
967 break; |
|
968 } |
|
969 lp->iwork[matind[k]] = 1; |
|
970 } |
|
971 for (k = beg; k < end; k++) |
|
972 lp->iwork[matind[k]] = 0; |
|
973 if (errcode) goto done; |
|
974 if (colname != NULL) |
|
975 { if (colname[j] != NULL) |
|
976 { errcode = error(env, CPXERR_NULL_NAME, j); |
|
977 goto done; |
|
978 } |
|
979 } |
|
980 } |
|
981 errcode = 0; |
|
982 invalidate(lp); |
|
983 if (glp_get_prob_name(lp->prob) == NULL) |
|
984 name[0] = '\0'; |
|
985 else |
|
986 strcpy(name, glp_get_prob_name(lp->prob)); |
|
987 glp_erase_prob(lp->prob); |
|
988 glp_set_prob_name(lp->prob, name); |
|
989 if (objsen == CPX_MIN) |
|
990 glp_set_obj_dir(lp->prob, GLP_MIN); |
|
991 else if (objsen == CPX_MAX) |
|
992 glp_set_obj_dir(lp->prob, GLP_MAX); |
|
993 else |
|
994 xassert(objsen != objsen); |
|
995 if (numrows > 0) |
|
996 glp_add_rows(lp->prob, numrows); |
|
997 enlargerflag(lp); |
|
998 for (i = 0; i < numrows; i++) |
|
999 { if (rowname != NULL) |
|
1000 glp_set_row_name(lp->prob, i+1, rowname[i]); |
|
1001 lbnd = ubnd = (rhs == NULL ? 0.0 : rhs[i]); |
|
1002 if (sense == NULL || sense[i] == 'E') |
|
1003 { lp->rflag[i] = RF_NOT_RANGED; |
|
1004 type = GLP_FX; |
|
1005 } |
|
1006 else if (sense[i] == 'L') |
|
1007 { lp->rflag[i] = RF_NOT_RANGED; |
|
1008 type = GLP_UP; |
|
1009 } |
|
1010 else if (sense[i] == 'G') |
|
1011 { lp->rflag[i] = RF_NOT_RANGED; |
|
1012 type = GLP_LO; |
|
1013 } |
|
1014 else if (sense[i] == 'R') |
|
1015 { if (rngval == NULL || rngval[i] == 0.0) |
|
1016 { lp->rflag[i] = RF_RANGED_POS; |
|
1017 type = GLP_FX; |
|
1018 } |
|
1019 else if (rngval[i] > 0.0) |
|
1020 { lp->rflag[i] = RF_RANGED_POS; |
|
1021 type = GLP_DB; |
|
1022 ubnd += rngval[i]; |
|
1023 } |
|
1024 else /* rngval[i] < 0.0 */ |
|
1025 { lp->rflag[i] = RF_RANGED_NEG; |
|
1026 type = GLP_DB; |
|
1027 lbnd += rngval[i]; |
|
1028 } |
|
1029 } |
|
1030 else |
|
1031 xassert(sense != sense); |
|
1032 glp_set_row_bnds(lp->prob, i+1, type, lbnd, ubnd); |
|
1033 } |
|
1034 if (numcols > 0) |
|
1035 glp_add_cols(lp->prob, numcols); |
|
1036 for (j = 0; j < numcols; j++) |
|
1037 { if (colname != NULL) |
|
1038 glp_set_col_name(lp->prob, j+1, colname[j]); |
|
1039 lbnd = (lb == NULL ? 0.0 : lb[j]); |
|
1040 ubnd = (ub == NULL ? +CPX_INFBOUND : ub[j]); |
|
1041 if (lbnd <= -CPX_INFBOUND && ubnd >= +CPX_INFBOUND) |
|
1042 type = GLP_FR; |
|
1043 else if (ubnd >= +CPX_INFBOUND) |
|
1044 type = GLP_LO; |
|
1045 else if (lbnd <= -CPX_INFBOUND) |
|
1046 type = GLP_UP; |
|
1047 else if (lbnd != ubnd) |
|
1048 type = GLP_DB; |
|
1049 else |
|
1050 type = GLP_FX; |
|
1051 glp_set_col_bnds(lp->prob, j+1, type, lbnd, ubnd); |
|
1052 if (obj != NULL) |
|
1053 glp_set_obj_coef(lp->prob, j+1, obj[j]); |
|
1054 beg = matbeg[j]; |
|
1055 end = beg + matcnt[j]; |
|
1056 for (k = beg; k < end; k++) |
|
1057 lp->iwork[k-beg] = matind[k]+1; |
|
1058 glp_set_mat_col(lp->prob, j+1, end-beg, lp->iwork-1, |
|
1059 matval+beg-1); |
|
1060 for (k = beg; k < end; k++) |
|
1061 lp->iwork[k-beg] = 0; |
|
1062 } |
|
1063 done: return errcode; |
|
1064 } |
|
1065 |
|
1066 CPXLP *CPXcreateprob(CPXENV *env, int *status, const char *probname) |
|
1067 { CPXLP *lp = NULL; |
|
1068 int errcode; |
|
1069 errcode = checkenv(env); |
|
1070 if (errcode) goto done; |
|
1071 lp = xmalloc(sizeof(struct CPXLP)); |
|
1072 lp->env = env; |
|
1073 lp->prob = glp_create_prob(); |
|
1074 glp_set_prob_name(lp->prob, probname); |
|
1075 lp->rflen = 100; |
|
1076 lp->rflag = xcalloc(lp->rflen, sizeof(char)); |
|
1077 lp->iwlen = 100; |
|
1078 lp->iwork = xcalloc(lp->iwlen, sizeof(int)); |
|
1079 memset(lp->iwork, 0, lp->iwlen * sizeof(int)); |
|
1080 lp->link = env->list; |
|
1081 env->list = lp; |
|
1082 invalidate(lp); |
|
1083 done: if (status != NULL) *status = errcode; |
|
1084 return lp; |
|
1085 } |
|
1086 |
|
1087 int CPXdelcols(CPXENV *env, CPXLP *lp, int begin, int end) |
|
1088 { int j, n, errcode; |
|
1089 errcode = checklp(env, lp); |
|
1090 if (errcode) goto done; |
|
1091 n = glp_get_num_cols(lp->prob); |
|
1092 if (!(0 <= begin && begin <= end && end < n)) |
|
1093 { errcode = error(env, CPXERR_INDEX_RANGE); |
|
1094 goto done; |
|
1095 } |
|
1096 errcode = 0; |
|
1097 invalidate(lp); |
|
1098 enlargeiwork(lp, end-begin+1); |
|
1099 for (j = begin; j <= end; j++) |
|
1100 lp->iwork[j-begin] = j+1; |
|
1101 glp_del_cols(lp->prob, end-begin+1, lp->iwork-1); |
|
1102 for (j = begin; j <= end; j++) |
|
1103 lp->iwork[j-begin] = 0; |
|
1104 done: return errcode; |
|
1105 } |
|
1106 |
|
1107 int CPXdelrows(CPXENV *env, CPXLP *lp, int begin, int end) |
|
1108 { int i, m, errcode; |
|
1109 errcode = checklp(env, lp); |
|
1110 if (errcode) goto done; |
|
1111 m = glp_get_num_rows(lp->prob); |
|
1112 if (!(0 <= begin && begin <= end && end < m)) |
|
1113 { errcode = error(env, CPXERR_INDEX_RANGE); |
|
1114 goto done; |
|
1115 } |
|
1116 errcode = 0; |
|
1117 invalidate(lp); |
|
1118 enlargeiwork(lp, end-begin+1); |
|
1119 for (i = begin; i <= end; i++) |
|
1120 lp->iwork[i-begin] = i+1; |
|
1121 glp_del_rows(lp->prob, end-begin+1, lp->iwork-1); |
|
1122 for (i = begin; i <= end; i++) |
|
1123 lp->iwork[i-begin] = 0; |
|
1124 for (i = end+1; i < m; i++) |
|
1125 lp->rflag[i-(end-begin+1)] = lp->rflag[i]; |
|
1126 done: return errcode; |
|
1127 } |
|
1128 |
|
1129 int CPXdelsetcols(CPXENV *env, CPXLP *lp, int delstat[]) |
|
1130 { xassert(env == env); |
|
1131 xassert(lp == lp); |
|
1132 xassert(delstat == delstat); |
|
1133 xprintf("CPXdelsetcols: not implemented yet\n"); |
|
1134 exit(EXIT_FAILURE); |
|
1135 return -1; |
|
1136 } |
|
1137 |
|
1138 int CPXdelsetrows(CPXENV *env, CPXLP *lp, int delstat[]) |
|
1139 { int i, m, cnt, ind, errcode; |
|
1140 errcode = checklp(env, lp); |
|
1141 if (errcode) goto done; |
|
1142 m = glp_get_num_rows(lp->prob); |
|
1143 if (m > 0 && delstat == NULL) |
|
1144 { errcode = error(env, CPXERR_NULL_POINTER); |
|
1145 goto done; |
|
1146 } |
|
1147 errcode = 0; |
|
1148 invalidate(lp); |
|
1149 enlargeiwork(lp, m); |
|
1150 cnt = ind = 0; |
|
1151 for (i = 0; i < m; i++) |
|
1152 { if (delstat[i] == 1) |
|
1153 { delstat[i] = -1; |
|
1154 lp->iwork[cnt++] = i+1; |
|
1155 } |
|
1156 else |
|
1157 { delstat[i] = ind; |
|
1158 lp->rflag[ind++] = lp->rflag[i]; |
|
1159 } |
|
1160 } |
|
1161 if (cnt > 0) |
|
1162 glp_del_rows(lp->prob, cnt, lp->iwork-1); |
|
1163 for (i = 0; i < cnt; i++) |
|
1164 lp->iwork[i] = 0; |
|
1165 done: return errcode; |
|
1166 } |
|
1167 |
|
1168 int CPXdualopt(CPXENV *env, CPXLP *lp); |
|
1169 |
|
1170 int CPXfreeprob(CPXENV *env, CPXLP **_lp) |
|
1171 { CPXLP *lp; |
|
1172 int errcode; |
|
1173 errcode = checkenv(env); |
|
1174 if (errcode) goto done; |
|
1175 if (_lp == NULL) |
|
1176 { errcode = error(env, CPXERR_NULL_POINTER); |
|
1177 goto done; |
|
1178 } |
|
1179 lp = *_lp; |
|
1180 errcode = checklp(env, lp); |
|
1181 if (errcode) goto done; |
|
1182 errcode = 0; |
|
1183 env = lp->env; |
|
1184 if (env->list == lp) |
|
1185 env->list = lp->link; |
|
1186 else |
|
1187 { CPXLP *pp; |
|
1188 for (pp = env->list; pp != NULL; pp = pp->link) |
|
1189 if (pp->link == lp) break; |
|
1190 xassert(pp != NULL); |
|
1191 pp->link = lp->link; |
|
1192 } |
|
1193 glp_delete_prob(lp->prob); |
|
1194 xfree(lp->rflag); |
|
1195 xfree(lp->iwork); |
|
1196 xfree(lp); |
|
1197 *_lp = NULL; |
|
1198 done: return errcode; |
|
1199 } |
|
1200 |
|
1201 int CPXgetbase(CPXENV *env, CPXLP *lp, int cstat[], int rstat[]) |
|
1202 { int i, j, m, n, stat, errcode; |
|
1203 errcode = checklp(env, lp); |
|
1204 if (errcode) goto done; |
|
1205 if (!lp->stat) |
|
1206 { errcode = error(env, CPXERR_NO_SOLN); |
|
1207 goto done; |
|
1208 } |
|
1209 if (lp->meth == CPX_ALG_PRIMAL || lp->meth == CPX_ALG_DUAL) |
|
1210 ; |
|
1211 else |
|
1212 { errcode = error(env, CPXERR_NO_BASIC_SOLN); |
|
1213 goto done; |
|
1214 } |
|
1215 errcode = 0; |
|
1216 if (rstat != NULL) |
|
1217 { m = glp_get_num_rows(lp->prob); |
|
1218 for (i = 0; i < m; i++) |
|
1219 { stat = glp_get_row_stat(lp->prob, i+1); |
|
1220 if (stat == GLP_BS) |
|
1221 rstat[i] = CPX_BASIC; |
|
1222 else if (lp->rflag[i] == RF_NOT_RANGED || stat != GLP_NU) |
|
1223 rstat[i] = CPX_AT_LOWER; |
|
1224 else |
|
1225 rstat[i] = CPX_AT_UPPER; |
|
1226 } |
|
1227 } |
|
1228 if (cstat != NULL) |
|
1229 { n = glp_get_num_cols(lp->prob); |
|
1230 for (j = 0; j < n; j++) |
|
1231 { stat = glp_get_col_stat(lp->prob, j+1); |
|
1232 if (stat == GLP_BS) |
|
1233 cstat[j] = CPX_BASIC; |
|
1234 else if (stat == GLP_NU) |
|
1235 cstat[j] = CPX_AT_UPPER; |
|
1236 else if (stat == GLP_NF) |
|
1237 cstat[j] = CPX_FREE_SUPER; |
|
1238 else |
|
1239 cstat[j] = CPX_AT_LOWER; |
|
1240 } |
|
1241 } |
|
1242 done: return errcode; |
|
1243 } |
|
1244 |
|
1245 int CPXgetbasednorms(CPXENV *env, CPXLP *lp, int cstat[], int rstat[], |
|
1246 double dnorm[]) |
|
1247 { int i, m, errcode; |
|
1248 errcode = CPXgetbase(env, lp, cstat, rstat); |
|
1249 if (errcode) goto done; |
|
1250 if (dnorm != NULL) |
|
1251 { m = glp_get_num_rows(lp->prob); |
|
1252 for (i = 0; i < m; i++) dnorm[i] = 1.0; |
|
1253 } |
|
1254 done: return errcode; |
|
1255 } |
|
1256 |
|
1257 int CPXgetbhead(CPXENV *env, CPXLP *lp, int head[], double x[]) |
|
1258 { xassert(env == env); |
|
1259 xassert(lp == lp); |
|
1260 xassert(head == head); |
|
1261 xassert(x == x); |
|
1262 xprintf("CPXgetbhead: not implemented yet\n"); |
|
1263 exit(EXIT_FAILURE); |
|
1264 return -1; |
|
1265 } |
|
1266 |
|
1267 int CPXgetdblparam(CPXENV *env, int whichparam, double *value) |
|
1268 { int k, errcode; |
|
1269 errcode = checkenv(env); |
|
1270 if (errcode) goto done; |
|
1271 k = finddblparam(whichparam); |
|
1272 if (k < 0) |
|
1273 { errcode = error(env, CPXERR_BAD_PARAM_NUM); |
|
1274 goto done; |
|
1275 } |
|
1276 errcode = 0; |
|
1277 if (value != NULL) |
|
1278 *value = env->dblparam[k]; |
|
1279 done: return errcode; |
|
1280 } |
|
1281 |
|
1282 int CPXgetdj(CPXENV *env, CPXLP *lp, double dj[], int begin, int end) |
|
1283 { int j, n, errcode; |
|
1284 errcode = checklp(env, lp); |
|
1285 if (errcode) goto done; |
|
1286 n = glp_get_num_cols(lp->prob); |
|
1287 if (!(0 <= begin && begin <= end && end < n)) |
|
1288 { errcode = error(env, CPXERR_INDEX_RANGE); |
|
1289 goto done; |
|
1290 } |
|
1291 if (!lp->stat) |
|
1292 { errcode = error(env, CPXERR_NO_SOLN); |
|
1293 goto done; |
|
1294 } |
|
1295 errcode = 0; |
|
1296 if (lp->meth == CPX_ALG_PRIMAL || lp->meth == CPX_ALG_DUAL) |
|
1297 { if (dj != NULL) |
|
1298 { for (j = begin; j <= end; j++) |
|
1299 dj[j-begin] = glp_get_col_dual(lp->prob, j+1); |
|
1300 } |
|
1301 } |
|
1302 else |
|
1303 xassert(lp != lp); |
|
1304 done: return errcode; |
|
1305 } |
|
1306 |
|
1307 char *CPXgeterrorstring(CPXENV *env, int errcode, char *buffer) |
|
1308 { const char *string; |
|
1309 xassert(env == env); |
|
1310 string = finderrstring(errcode); |
|
1311 if (string == NULL) |
|
1312 buffer = NULL; |
|
1313 else |
|
1314 sprintf(buffer, "CPLEX Error %5d: %s.\n", errcode, string); |
|
1315 return buffer; |
|
1316 } |
|
1317 |
|
1318 int CPXgetijdiv(CPXENV *env, CPXLP *lp, int *idiv, int *jdiv) |
|
1319 { xassert(env == env); |
|
1320 xassert(lp == lp); |
|
1321 xassert(idiv == idiv); |
|
1322 xassert(jdiv == jdiv); |
|
1323 xprintf("CPXgetijdiv: not implemented yet\n"); |
|
1324 exit(EXIT_FAILURE); |
|
1325 return -1; |
|
1326 } |
|
1327 |
|
1328 int CPXgetintparam(CPXENV *env, int whichparam, int *value) |
|
1329 { int k, errcode; |
|
1330 errcode = checkenv(env); |
|
1331 if (errcode) goto done; |
|
1332 k = findintparam(whichparam); |
|
1333 if (k < 0) |
|
1334 { errcode = error(env, CPXERR_BAD_PARAM_NUM); |
|
1335 goto done; |
|
1336 } |
|
1337 errcode = 0; |
|
1338 if (value != NULL) |
|
1339 *value = env->intparam[k]; |
|
1340 done: return errcode; |
|
1341 } |
|
1342 |
|
1343 int CPXgetlb(CPXENV *env, CPXLP *lp, double lb[], int begin, int end) |
|
1344 { xassert(env == env); |
|
1345 xassert(lp == lp); |
|
1346 xassert(lb == lb); |
|
1347 xassert(begin == begin); |
|
1348 xassert(end == end); |
|
1349 xprintf("CPXgetlb: not implemented yet\n"); |
|
1350 exit(EXIT_FAILURE); |
|
1351 return -1; |
|
1352 } |
|
1353 |
|
1354 int CPXgetmethod(CPXENV *env, CPXLP *lp) |
|
1355 { int method; |
|
1356 if (checklp(env, lp)) |
|
1357 method = CPX_ALG_NONE; |
|
1358 else |
|
1359 method = lp->meth; |
|
1360 return method; |
|
1361 } |
|
1362 |
|
1363 int CPXgetnumcols(CPXENV *env, CPXLP *lp) |
|
1364 { int numcols; |
|
1365 if (checklp(env, lp)) |
|
1366 numcols = 0; |
|
1367 else |
|
1368 numcols = glp_get_num_cols(lp->prob); |
|
1369 return numcols; |
|
1370 } |
|
1371 |
|
1372 int CPXgetnumnz(CPXENV *env, CPXLP *lp) |
|
1373 { int numnz; |
|
1374 if (checklp(env, lp)) |
|
1375 numnz = 0; |
|
1376 else |
|
1377 numnz = glp_get_num_nz(lp->prob); |
|
1378 return numnz; |
|
1379 } |
|
1380 |
|
1381 int CPXgetnumrows(CPXENV *env, CPXLP *lp) |
|
1382 { int numrows; |
|
1383 if (checklp(env, lp)) |
|
1384 numrows = 0; |
|
1385 else |
|
1386 numrows = glp_get_num_rows(lp->prob); |
|
1387 return numrows; |
|
1388 } |
|
1389 |
|
1390 int CPXgetobjval(CPXENV *env, CPXLP *lp, double *objval) |
|
1391 { int errcode; |
|
1392 errcode = checklp(env, lp); |
|
1393 if (errcode) goto done; |
|
1394 if (!lp->stat) |
|
1395 { errcode = error(env, CPXERR_NO_SOLN); |
|
1396 goto done; |
|
1397 } |
|
1398 errcode = 0; |
|
1399 if (lp->meth == CPX_ALG_PRIMAL || lp->meth == CPX_ALG_DUAL) |
|
1400 { if (objval != NULL) |
|
1401 *objval = glp_get_obj_val(lp->prob); |
|
1402 } |
|
1403 else |
|
1404 xassert(lp != lp); |
|
1405 done: return errcode; |
|
1406 } |
|
1407 |
|
1408 int CPXgetpi(CPXENV *env, CPXLP *lp, double pi[], int begin, int end) |
|
1409 { int i, m, errcode; |
|
1410 errcode = checklp(env, lp); |
|
1411 if (errcode) goto done; |
|
1412 m = glp_get_num_rows(lp->prob); |
|
1413 if (!(0 <= begin && begin <= end && end < m)) |
|
1414 { errcode = error(env, CPXERR_INDEX_RANGE); |
|
1415 goto done; |
|
1416 } |
|
1417 if (!lp->stat) |
|
1418 { errcode = error(env, CPXERR_NO_SOLN); |
|
1419 goto done; |
|
1420 } |
|
1421 errcode = 0; |
|
1422 if (lp->meth == CPX_ALG_PRIMAL || lp->meth == CPX_ALG_DUAL) |
|
1423 { if (pi != NULL) |
|
1424 { for (i = begin; i <= end; i++) |
|
1425 pi[i-begin] = glp_get_row_dual(lp->prob, i+1); |
|
1426 } |
|
1427 } |
|
1428 else |
|
1429 xassert(lp != lp); |
|
1430 done: return errcode; |
|
1431 } |
|
1432 |
|
1433 int CPXgetsense(CPXENV *env, CPXLP *lp, char sense[], int begin, |
|
1434 int end) |
|
1435 { xassert(env == env); |
|
1436 xassert(lp == lp); |
|
1437 xassert(sense == sense); |
|
1438 xassert(begin == begin); |
|
1439 xassert(end == end); |
|
1440 xprintf("CPXgetsense: not implemented yet\n"); |
|
1441 exit(EXIT_FAILURE); |
|
1442 return -1; |
|
1443 } |
|
1444 |
|
1445 int CPXgetslack(CPXENV *env, CPXLP *lp, double slack[], int begin, |
|
1446 int end) |
|
1447 { int i, m, type, errcode; |
|
1448 double temp; |
|
1449 errcode = checklp(env, lp); |
|
1450 if (errcode) goto done; |
|
1451 m = glp_get_num_rows(lp->prob); |
|
1452 if (!(0 <= begin && begin <= end && end < m)) |
|
1453 { errcode = error(env, CPXERR_INDEX_RANGE); |
|
1454 goto done; |
|
1455 } |
|
1456 if (!lp->stat) |
|
1457 { errcode = error(env, CPXERR_NO_SOLN); |
|
1458 goto done; |
|
1459 } |
|
1460 errcode = 0; |
|
1461 if (lp->meth == CPX_ALG_PRIMAL || lp->meth == CPX_ALG_DUAL) |
|
1462 { if (slack != NULL) |
|
1463 { for (i = begin; i <= end; i++) |
|
1464 { type = glp_get_row_type(lp->prob, i+1); |
|
1465 temp = glp_get_row_prim(lp->prob, i+1); |
|
1466 if (lp->rflag[i] == RF_NOT_RANGED) |
|
1467 { if (type == GLP_LO || type == GLP_FX) |
|
1468 slack[i-begin] = |
|
1469 glp_get_row_lb(lp->prob, i+1) - temp; |
|
1470 else if (type == GLP_UP) |
|
1471 slack[i-begin] = |
|
1472 glp_get_row_ub(lp->prob, i+1) - temp; |
|
1473 else |
|
1474 xassert(type != type); |
|
1475 } |
|
1476 else if (lp->rflag[i] == RF_RANGED_POS) |
|
1477 { xassert(type == GLP_DB || type == GLP_FX); |
|
1478 slack[i-begin] = |
|
1479 temp - glp_get_row_lb(lp->prob, i+1); |
|
1480 } |
|
1481 else if (lp->rflag[i] == RF_RANGED_NEG) |
|
1482 { xassert(type == GLP_DB); |
|
1483 slack[i-begin] = |
|
1484 temp - glp_get_row_ub(lp->prob, i+1); |
|
1485 } |
|
1486 else |
|
1487 xassert(lp != lp); |
|
1488 } |
|
1489 } |
|
1490 } |
|
1491 else |
|
1492 xassert(lp != lp); |
|
1493 done: return errcode; |
|
1494 } |
|
1495 |
|
1496 int CPXgetstat(CPXENV *env, CPXLP *lp) |
|
1497 { int stat; |
|
1498 if (checklp(env, lp)) |
|
1499 stat = 0; |
|
1500 else |
|
1501 stat = lp->stat; |
|
1502 return stat; |
|
1503 } |
|
1504 |
|
1505 int CPXgetub(CPXENV *env, CPXLP *lp, double ub[], int begin, int end) |
|
1506 { xassert(env == env); |
|
1507 xassert(lp == lp); |
|
1508 xassert(ub == ub); |
|
1509 xassert(begin == begin); |
|
1510 xassert(end == end); |
|
1511 xprintf("CPXgetub: not implemented yet\n"); |
|
1512 exit(EXIT_FAILURE); |
|
1513 return -1; |
|
1514 } |
|
1515 |
|
1516 int CPXgetweight(CPXENV *env, CPXLP *lp, int rcnt, const int rmatbeg[], |
|
1517 const int rmatind[], const double rmatval[], double weight[], |
|
1518 int dpriind) |
|
1519 { xassert(env == env); |
|
1520 xassert(lp == lp); |
|
1521 xassert(rcnt == rcnt); |
|
1522 xassert(rmatbeg == rmatbeg); |
|
1523 xassert(rmatind == rmatind); |
|
1524 xassert(rmatval == rmatval); |
|
1525 xassert(weight == weight); |
|
1526 xassert(dpriind == dpriind); |
|
1527 xprintf("CPXgetweight: not implemented yet\n"); |
|
1528 exit(EXIT_FAILURE); |
|
1529 return -1; |
|
1530 } |
|
1531 |
|
1532 int CPXgetx(CPXENV *env, CPXLP *lp, double x[], int begin, int end) |
|
1533 { int j, n, errcode; |
|
1534 errcode = checklp(env, lp); |
|
1535 if (errcode) goto done; |
|
1536 n = glp_get_num_cols(lp->prob); |
|
1537 if (!(0 <= begin && begin <= end && end < n)) |
|
1538 { errcode = error(env, CPXERR_INDEX_RANGE); |
|
1539 goto done; |
|
1540 } |
|
1541 if (!lp->stat) |
|
1542 { errcode = error(env, CPXERR_NO_SOLN); |
|
1543 goto done; |
|
1544 } |
|
1545 errcode = 0; |
|
1546 if (lp->meth == CPX_ALG_PRIMAL || lp->meth == CPX_ALG_DUAL) |
|
1547 { if (x != NULL) |
|
1548 { for (j = begin; j <= end; j++) |
|
1549 x[j-begin] = glp_get_col_prim(lp->prob, j+1); |
|
1550 } |
|
1551 } |
|
1552 else |
|
1553 xassert(lp != lp); |
|
1554 done: return errcode; |
|
1555 } |
|
1556 |
|
1557 int CPXinfodblparam(CPXENV *env, int whichparam, double *defvalue, |
|
1558 double *minvalue, double *maxvalue) |
|
1559 { int k, errcode; |
|
1560 errcode = checkenv(env); |
|
1561 if (errcode) goto done; |
|
1562 k = finddblparam(whichparam); |
|
1563 if (k < 0) |
|
1564 { errcode = error(env, CPXERR_BAD_PARAM_NUM); |
|
1565 goto done; |
|
1566 } |
|
1567 errcode = 0; |
|
1568 if (defvalue != NULL) |
|
1569 *defvalue = dblparam[k].defv; |
|
1570 if (minvalue != NULL) |
|
1571 *minvalue = dblparam[k].minv; |
|
1572 if (maxvalue != NULL) |
|
1573 *maxvalue = dblparam[k].maxv; |
|
1574 done: return errcode; |
|
1575 } |
|
1576 |
|
1577 int CPXinfointparam(CPXENV *env, int whichparam, int *defvalue, |
|
1578 int *minvalue, int *maxvalue) |
|
1579 { int k, errcode; |
|
1580 errcode = checkenv(env); |
|
1581 if (errcode) goto done; |
|
1582 k = findintparam(whichparam); |
|
1583 if (k < 0) |
|
1584 { errcode = error(env, CPXERR_BAD_PARAM_NUM); |
|
1585 goto done; |
|
1586 } |
|
1587 errcode = 0; |
|
1588 if (defvalue != NULL) |
|
1589 *defvalue = intparam[k].defv; |
|
1590 if (minvalue != NULL) |
|
1591 *minvalue = intparam[k].minv; |
|
1592 if (maxvalue != NULL) |
|
1593 *maxvalue = intparam[k].maxv; |
|
1594 done: return errcode; |
|
1595 } |
|
1596 |
|
1597 int CPXmdleave(const CPXENV *env, CPXLP *lp, const int goodlist[], |
|
1598 int goodlen, double downratio[], double upratio[]) |
|
1599 { int k; |
|
1600 xassert(env == env); |
|
1601 xassert(lp == lp); |
|
1602 xassert(goodlist == goodlist); |
|
1603 xassert(goodlen >= 0); |
|
1604 xassert(downratio != NULL); |
|
1605 xassert(upratio != NULL); |
|
1606 /* not implemented yet */ |
|
1607 for (k = 0; k < goodlen; k++) |
|
1608 downratio[k] = upratio[k] = 0.0; |
|
1609 return 0; |
|
1610 } |
|
1611 |
|
1612 int CPXnewcols(CPXENV *env, CPXLP *lp, int ccnt, const double obj[], |
|
1613 const double lb[], const double ub[], const char ctype[], |
|
1614 char *colname[]) |
|
1615 { int j, n, kind, type, errcode; |
|
1616 double lbnd, ubnd; |
|
1617 errcode = checklp(env, lp); |
|
1618 if (errcode) goto done; |
|
1619 if (ccnt < 0) |
|
1620 { errcode = error(env, CPXERR_BAD_ARGUMENT); |
|
1621 goto done; |
|
1622 } |
|
1623 for (j = 0; j < ccnt; j++) |
|
1624 { if (ctype != NULL) |
|
1625 { if (!(ctype[j] == 'C' || ctype[j] == 'B' || |
|
1626 ctype[j] == 'I')) |
|
1627 { errcode = error(env, CPXERR_BAD_CTYPE, j); |
|
1628 goto done; |
|
1629 } |
|
1630 } |
|
1631 if (colname != NULL) |
|
1632 { if (colname[j] == NULL) |
|
1633 { errcode = error(env, CPXERR_NULL_NAME, j); |
|
1634 goto done; |
|
1635 } |
|
1636 } |
|
1637 } |
|
1638 errcode = 0; |
|
1639 invalidate(lp); |
|
1640 n = glp_get_num_cols(lp->prob); |
|
1641 if (ccnt > 0) |
|
1642 glp_add_cols(lp->prob, ccnt); |
|
1643 for (j = 0; j < ccnt; j++) |
|
1644 { if (colname != NULL) |
|
1645 glp_set_col_name(lp->prob, n+j+1, colname[j]); |
|
1646 if (obj != NULL) |
|
1647 glp_set_obj_coef(lp->prob, n+j+1, obj[j]); |
|
1648 lbnd = (lb == NULL ? 0.0 : lb[j]); |
|
1649 ubnd = (ub == NULL ? 0.0 : ub[j]); |
|
1650 if (lbnd <= -CPX_INFBOUND && ubnd >= +CPX_INFBOUND) |
|
1651 type = GLP_FR; |
|
1652 else if (ubnd >= +CPX_INFBOUND) |
|
1653 type = GLP_LO; |
|
1654 else if (lbnd <= -CPX_INFBOUND) |
|
1655 type = GLP_UP; |
|
1656 else if (lbnd != ubnd) |
|
1657 type = GLP_DB; |
|
1658 else |
|
1659 type = GLP_FX; |
|
1660 glp_set_col_bnds(lp->prob, n+j+1, type, lbnd, ubnd); |
|
1661 if (ctype != NULL) |
|
1662 { if (ctype[j] == 'C') |
|
1663 kind = GLP_CV; |
|
1664 else if (ctype[j] == 'B') |
|
1665 kind = GLP_BV; |
|
1666 else if (ctype[j] == 'I') |
|
1667 kind = GLP_IV; |
|
1668 else |
|
1669 xassert(ctype != ctype); |
|
1670 glp_set_col_kind(lp->prob, n+j+1, kind); |
|
1671 } |
|
1672 } |
|
1673 done: return errcode; |
|
1674 } |
|
1675 |
|
1676 int CPXnewrows(CPXENV *env, CPXLP *lp, int rcnt, const double rhs[], |
|
1677 const char sense[], const double rngval[], char *rowname[]) |
|
1678 { int i, m, type, errcode; |
|
1679 double lbnd, ubnd; |
|
1680 errcode = checklp(env, lp); |
|
1681 if (errcode) goto done; |
|
1682 if (rcnt < 0) |
|
1683 { errcode = error(env, CPXERR_BAD_ARGUMENT); |
|
1684 goto done; |
|
1685 } |
|
1686 for (i = 0; i < rcnt; i++) |
|
1687 { if (sense != NULL) |
|
1688 { if (!(sense[i] == 'L' || sense[i] == 'E' || |
|
1689 sense[i] == 'G' || sense[i] == 'R')) |
|
1690 { errcode = error(env, CPXERR_BAD_SENSE, i); |
|
1691 goto done; |
|
1692 } |
|
1693 } |
|
1694 if (rowname != NULL) |
|
1695 { if (rowname[i] == NULL) |
|
1696 { errcode = error(env, CPXERR_NULL_NAME, i); |
|
1697 goto done; |
|
1698 } |
|
1699 } |
|
1700 } |
|
1701 errcode = 0; |
|
1702 invalidate(lp); |
|
1703 m = glp_get_num_rows(lp->prob); |
|
1704 if (rcnt > 0) |
|
1705 glp_add_rows(lp->prob, rcnt); |
|
1706 enlargerflag(lp); |
|
1707 for (i = 0; i < rcnt; i++) |
|
1708 { if (rowname != NULL) |
|
1709 glp_set_row_name(lp->prob, m+i+1, rowname[i]); |
|
1710 lbnd = ubnd = (rhs == NULL ? 0.0 : rhs[i]); |
|
1711 if (sense == NULL || sense[i] == 'E') |
|
1712 { lp->rflag[m+i] = RF_NOT_RANGED; |
|
1713 type = GLP_FX; |
|
1714 } |
|
1715 else if (sense[i] == 'L') |
|
1716 { lp->rflag[m+i] = RF_NOT_RANGED; |
|
1717 type = GLP_UP; |
|
1718 } |
|
1719 else if (sense[i] == 'G') |
|
1720 { lp->rflag[m+i] = RF_NOT_RANGED; |
|
1721 type = GLP_LO; |
|
1722 } |
|
1723 else if (sense[i] == 'R') |
|
1724 { if (rngval == NULL || rngval[i] == 0.0) |
|
1725 { lp->rflag[m+i] = RF_RANGED_POS; |
|
1726 type = GLP_FX; |
|
1727 } |
|
1728 else if (rngval[i] > 0.0) |
|
1729 { lp->rflag[m+i] = RF_RANGED_POS; |
|
1730 type = GLP_DB; |
|
1731 ubnd += rngval[i]; |
|
1732 } |
|
1733 else /* rngval[i] < 0.0 */ |
|
1734 { lp->rflag[m+i] = RF_RANGED_NEG; |
|
1735 type = GLP_DB; |
|
1736 lbnd += rngval[i]; |
|
1737 } |
|
1738 } |
|
1739 else |
|
1740 xassert(sense != sense); |
|
1741 glp_set_row_bnds(lp->prob, m+i+1, type, lbnd, ubnd); |
|
1742 } |
|
1743 done: return errcode; |
|
1744 } |
|
1745 |
|
1746 CPXENV *CPXopenCPLEX(int *status) |
|
1747 { CPXENV *env; |
|
1748 int k, card; |
|
1749 env = xmalloc(sizeof(CPXENV)); |
|
1750 env->list = NULL; |
|
1751 card = sizeof(intparam) / sizeof(struct intparam); |
|
1752 env->intparam = xcalloc(card, sizeof(int)); |
|
1753 for (k = 0; k < card; k++) |
|
1754 env->intparam[k] = intparam[k].defv; |
|
1755 card = sizeof(dblparam) / sizeof(struct dblparam); |
|
1756 env->dblparam = xcalloc(card, sizeof(double)); |
|
1757 for (k = 0; k < card; k++) |
|
1758 env->dblparam[k] = dblparam[k].defv; |
|
1759 if (status != NULL) *status = 0; |
|
1760 return env; |
|
1761 } |
|
1762 |
|
1763 int CPXpivotin(CPXENV *env, CPXLP *lp, const int rlist[], int rlen) |
|
1764 { int i, m, errcode; |
|
1765 errcode = checklp(env, lp); |
|
1766 if (errcode) goto done; |
|
1767 if (rlen < 0) |
|
1768 { errcode = error(env, CPXERR_BAD_ARGUMENT); |
|
1769 goto done; |
|
1770 } |
|
1771 if (rlen > 0 && rlist == NULL) |
|
1772 { errcode = error(env, CPXERR_NULL_POINTER); |
|
1773 goto done; |
|
1774 } |
|
1775 m = glp_get_num_rows(lp->prob); |
|
1776 for (i = 0; i < rlen; i++) |
|
1777 { if (!(0 <= rlist[i] && rlist[i] < m)) |
|
1778 { errcode = error(env, CPXERR_ROW_INDEX_RANGE, i); |
|
1779 goto done; |
|
1780 } |
|
1781 } |
|
1782 errcode = 0; |
|
1783 for (i = 0; i < rlen; i++) |
|
1784 { if (glp_get_row_type(lp->prob, rlist[i]+1) != GLP_FX) |
|
1785 { if (glp_get_row_stat(lp->prob, rlist[i]+1) != GLP_BS) |
|
1786 { /* not implemented yet */ |
|
1787 break; |
|
1788 } |
|
1789 } |
|
1790 } |
|
1791 done: return errcode; |
|
1792 } |
|
1793 |
|
1794 int CPXpivotout(CPXENV *env, CPXLP *lp, const int clist[], int clen) |
|
1795 { int j, n, errcode; |
|
1796 errcode = checklp(env, lp); |
|
1797 if (errcode) goto done; |
|
1798 if (clen < 0) |
|
1799 { errcode = error(env, CPXERR_BAD_ARGUMENT); |
|
1800 goto done; |
|
1801 } |
|
1802 if (clen > 0 && clist == NULL) |
|
1803 { errcode = error(env, CPXERR_NULL_POINTER); |
|
1804 goto done; |
|
1805 } |
|
1806 n = glp_get_num_cols(lp->prob); |
|
1807 for (j = 0; j < clen; j++) |
|
1808 { if (!(0 <= clist[j] && clist[j] < n)) |
|
1809 { errcode = error(env, CPXERR_COL_INDEX_RANGE, j); |
|
1810 goto done; |
|
1811 } |
|
1812 if (glp_get_col_type(lp->prob, clist[j]+1) != GLP_FX) |
|
1813 { errcode = error(env, CPXERR_NOT_FIXED); |
|
1814 goto done; |
|
1815 } |
|
1816 } |
|
1817 errcode = 0; |
|
1818 for (j = 0; j < clen; j++) |
|
1819 { if (glp_get_col_stat(lp->prob, clist[j]+1) == GLP_BS) |
|
1820 { /* not implemented yet */ |
|
1821 break; |
|
1822 } |
|
1823 } |
|
1824 done: return errcode; |
|
1825 } |
|
1826 |
|
1827 int CPXprimopt(CPXENV *env, CPXLP *lp); |
|
1828 |
|
1829 int CPXsavwrite(CPXENV *env, CPXLP *lp, const char *filename) |
|
1830 { xassert(env == env); |
|
1831 xassert(lp == lp); |
|
1832 xassert(filename == filename); |
|
1833 xprintf("CPXsavwrite: not implemented yet\n"); |
|
1834 exit(EXIT_FAILURE); |
|
1835 return -1; |
|
1836 } |
|
1837 |
|
1838 int CPXsetdblparam(CPXENV *env, int whichparam, double newvalue) |
|
1839 { int k, errcode; |
|
1840 errcode = checkenv(env); |
|
1841 if (errcode) goto done; |
|
1842 k = finddblparam(whichparam); |
|
1843 if (k < 0) |
|
1844 { errcode = error(env, CPXERR_BAD_PARAM_NUM); |
|
1845 goto done; |
|
1846 } |
|
1847 if (newvalue < dblparam[k].minv) |
|
1848 { errcode = error(env, CPXERR_PARAM_TOO_SMALL); |
|
1849 goto done; |
|
1850 } |
|
1851 if (newvalue > dblparam[k].maxv) |
|
1852 { errcode = error(env, CPXERR_PARAM_TOO_BIG); |
|
1853 goto done; |
|
1854 } |
|
1855 errcode = 0; |
|
1856 env->dblparam[k] = newvalue; |
|
1857 done: return errcode; |
|
1858 } |
|
1859 |
|
1860 int CPXsetintparam(CPXENV *env, int whichparam, int newvalue) |
|
1861 { int k, errcode; |
|
1862 errcode = checkenv(env); |
|
1863 if (errcode) goto done; |
|
1864 k = findintparam(whichparam); |
|
1865 if (k < 0) |
|
1866 { errcode = error(env, CPXERR_BAD_PARAM_NUM); |
|
1867 goto done; |
|
1868 } |
|
1869 if (newvalue < intparam[k].minv) |
|
1870 { errcode = error(env, CPXERR_PARAM_TOO_SMALL); |
|
1871 goto done; |
|
1872 } |
|
1873 if (newvalue > intparam[k].maxv) |
|
1874 { errcode = error(env, CPXERR_PARAM_TOO_BIG); |
|
1875 goto done; |
|
1876 } |
|
1877 errcode = 0; |
|
1878 env->intparam[k] = newvalue; |
|
1879 done: return errcode; |
|
1880 } |
|
1881 |
|
1882 int CPXsolninfo(CPXENV *env, CPXLP *lp, int *solnmethod, int *solntype, |
|
1883 int *pfeasind, int *dfeasind) |
|
1884 { int type, pfeas, dfeas, errcode; |
|
1885 errcode = checklp(env, lp); |
|
1886 if (errcode) goto done; |
|
1887 errcode = 0; |
|
1888 if (!lp->stat) |
|
1889 type = CPX_NO_SOLN, pfeas = dfeas = 0; |
|
1890 else if (lp->meth == CPX_ALG_PRIMAL || lp->meth == CPX_ALG_DUAL) |
|
1891 { type = CPX_BASIC_SOLN; |
|
1892 pfeas = (glp_get_prim_stat(lp->prob) == GLP_FEAS); |
|
1893 dfeas = (glp_get_dual_stat(lp->prob) == GLP_FEAS); |
|
1894 } |
|
1895 else |
|
1896 xassert(lp != lp); |
|
1897 if (solnmethod != NULL) |
|
1898 *solnmethod = lp->meth; |
|
1899 if (solntype != NULL) |
|
1900 *solntype = type; |
|
1901 if (pfeasind != NULL) |
|
1902 *pfeasind = pfeas; |
|
1903 if (dfeasind != NULL) |
|
1904 *dfeasind = dfeas; |
|
1905 done: return errcode; |
|
1906 } |
|
1907 |
|
1908 int CPXsolution(CPXENV *env, CPXLP *lp, int *lpstat, double *objval, |
|
1909 double x[], double pi[], double slack[], double dj[]) |
|
1910 { int m, n, errcode; |
|
1911 errcode = checklp(env, lp); |
|
1912 if (errcode) goto done; |
|
1913 if (!lp->stat) |
|
1914 { errcode = error(env, CPXERR_NO_SOLN); |
|
1915 goto done; |
|
1916 } |
|
1917 errcode = 0; |
|
1918 m = glp_get_num_rows(lp->prob); |
|
1919 n = glp_get_num_cols(lp->prob); |
|
1920 if (lp->meth == CPX_ALG_PRIMAL || lp->meth == CPX_ALG_DUAL) |
|
1921 { if (lpstat != NULL) |
|
1922 *lpstat = CPXgetstat(env, lp); |
|
1923 if (objval != NULL) |
|
1924 xassert(CPXgetobjval(env, lp, objval) == 0); |
|
1925 if (x != NULL) |
|
1926 xassert(CPXgetx(env, lp, x, 0, n-1) == 0); |
|
1927 if (pi != NULL) |
|
1928 xassert(CPXgetpi(env, lp, pi, 0, m-1) == 0); |
|
1929 if (slack != NULL) |
|
1930 xassert(CPXgetslack(env, lp, slack, 0, m-1) == 0); |
|
1931 if (dj != NULL) |
|
1932 xassert(CPXgetdj(env, lp, dj, 0, n-1) == 0); |
|
1933 } |
|
1934 else |
|
1935 xassert(lp != lp); |
|
1936 done: return errcode; |
|
1937 } |
|
1938 |
|
1939 int CPXstrongbranch(CPXENV *env, CPXLP *lp, const int goodlist[], |
|
1940 int goodlen, double downpen[], double uppen[], int itlim) |
|
1941 { int k; |
|
1942 xassert(env == env); |
|
1943 xassert(lp == lp); |
|
1944 xassert(goodlist == goodlist); |
|
1945 xassert(goodlen >= 0); |
|
1946 xassert(downpen != NULL); |
|
1947 xassert(uppen != NULL); |
|
1948 xassert(itlim == itlim); |
|
1949 /* not implemented yet */ |
|
1950 for (k = 0; k < goodlen; k++) |
|
1951 downpen[k] = uppen[k] = 0.0; |
|
1952 return 0; |
|
1953 } |
|
1954 |
|
1955 static int xstrcasecmp(const char *s1, const char *s2) |
|
1956 { int c1, c2; |
|
1957 for (;;) |
|
1958 { c1 = toupper((unsigned char)*s1++); |
|
1959 c2 = toupper((unsigned char)*s2++); |
|
1960 if (c1 == '\0' || c1 != c2) break; |
|
1961 } |
|
1962 return c1 - c2; |
|
1963 } |
|
1964 |
|
1965 static void getfiletype(const char *filename, char type[3+1]) |
|
1966 { /* determine filetype from filename */ |
|
1967 int beg, end; |
|
1968 beg = end = strlen(filename); |
|
1969 while (beg > 0 && filename[beg-1] != '.' && end - beg < 3) |
|
1970 beg--; |
|
1971 if (beg > 0 && filename[beg-1] == '.' && |
|
1972 xstrcasecmp(&filename[beg], "gz") == 0) |
|
1973 { end = --beg; |
|
1974 while (beg > 0 && filename[beg-1] != '.' && end - beg < 3) |
|
1975 beg--; |
|
1976 } |
|
1977 if (beg > 0 && filename[beg-1] == '.') |
|
1978 { memcpy(type, &filename[beg], end - beg); |
|
1979 type[end - beg] = '\0'; |
|
1980 } |
|
1981 else |
|
1982 type[0] = '\0'; |
|
1983 return; |
|
1984 } |
|
1985 |
|
1986 int CPXwriteprob(CPXENV *env, CPXLP *lp, const char *filename, |
|
1987 const char *filetype) |
|
1988 { glp_prob *copy; |
|
1989 int errcode; |
|
1990 char type[3+1]; |
|
1991 errcode = checklp(env, lp); |
|
1992 if (errcode) goto done; |
|
1993 if (filename == NULL) |
|
1994 { errcode = error(env, CPXERR_NO_FILENAME); |
|
1995 goto done; |
|
1996 } |
|
1997 if (filetype == NULL) |
|
1998 getfiletype(filename, type), filetype = type; |
|
1999 if (xstrcasecmp(filetype, "MPS") == 0) |
|
2000 { glp_term_out(GLP_OFF); |
|
2001 errcode = glp_write_mps(lp->prob, GLP_MPS_FILE, NULL, filename) |
|
2002 ; |
|
2003 glp_term_out(GLP_ON); |
|
2004 } |
|
2005 else if (xstrcasecmp(filetype, "LP") == 0) |
|
2006 { glp_term_out(GLP_OFF); |
|
2007 errcode = glp_write_lp(lp->prob, NULL, filename); |
|
2008 glp_term_out(GLP_ON); |
|
2009 } |
|
2010 else if (xstrcasecmp(filetype, "RMP") == 0 || |
|
2011 xstrcasecmp(filetype, "REW") == 0) |
|
2012 { copy = glp_create_prob(); |
|
2013 glp_copy_prob(copy, lp->prob, GLP_OFF); |
|
2014 glp_term_out(GLP_OFF); |
|
2015 errcode = glp_write_mps(copy, GLP_MPS_DECK, NULL, filename); |
|
2016 glp_term_out(GLP_ON); |
|
2017 glp_delete_prob(copy); |
|
2018 } |
|
2019 else if (xstrcasecmp(filetype, "RLP") == 0) |
|
2020 { copy = glp_create_prob(); |
|
2021 glp_copy_prob(copy, lp->prob, GLP_OFF); |
|
2022 glp_term_out(GLP_OFF); |
|
2023 errcode = glp_write_lp(copy, NULL, filename); |
|
2024 glp_term_out(GLP_ON); |
|
2025 glp_delete_prob(copy); |
|
2026 } |
|
2027 else |
|
2028 { errcode = error(env, CPXERR_BAD_FILETYPE); |
|
2029 goto done; |
|
2030 } |
|
2031 if (errcode) |
|
2032 errcode = error(env, CPXERR_FAIL_OPEN_WRITE, filename); |
|
2033 done: return errcode; |
|
2034 } |
|
2035 |
|
2036 /**********************************************************************/ |
|
2037 |
|
2038 static int solvelp(CPXENV *env, CPXLP *lp, int meth) |
|
2039 { glp_smcp parm; |
|
2040 int errcode; |
|
2041 errcode = checklp(env, lp); |
|
2042 if (errcode) goto done; |
|
2043 errcode = 0; |
|
2044 invalidate(lp); |
|
2045 glp_init_smcp(&parm); |
|
2046 switch (meth) |
|
2047 { case CPX_ALG_PRIMAL: |
|
2048 parm.meth = GLP_PRIMAL; |
|
2049 break; |
|
2050 case CPX_ALG_DUAL: |
|
2051 parm.meth = GLP_DUAL; |
|
2052 break; |
|
2053 default: |
|
2054 xassert(meth != meth); |
|
2055 } |
|
2056 switch (getintparam(env, CPX_PARAM_SIMDISPLAY)) |
|
2057 { case 0: |
|
2058 parm.msg_lev = GLP_MSG_OFF; |
|
2059 break; |
|
2060 case 1: |
|
2061 parm.msg_lev = GLP_MSG_ALL; |
|
2062 break; |
|
2063 case 2: |
|
2064 parm.msg_lev = GLP_MSG_ALL; |
|
2065 parm.out_frq = 1; |
|
2066 break; |
|
2067 default: |
|
2068 xassert(env != env); |
|
2069 } |
|
2070 xassert(getdblparam == getdblparam); |
|
2071 switch (getintparam(env, CPX_PARAM_ADVIND)) |
|
2072 { case 0: |
|
2073 glp_term_out(GLP_OFF); |
|
2074 glp_adv_basis(lp->prob, 0); |
|
2075 glp_term_out(GLP_ON); |
|
2076 break; |
|
2077 case 1: |
|
2078 case 2: |
|
2079 break; |
|
2080 default: |
|
2081 xassert(env != env); |
|
2082 } |
|
2083 if (!glp_bf_exists(lp->prob)) |
|
2084 { if (glp_factorize(lp->prob) != 0) |
|
2085 { glp_term_out(GLP_OFF); |
|
2086 glp_adv_basis(lp->prob, 0); |
|
2087 glp_term_out(GLP_ON); |
|
2088 if (glp_factorize(lp->prob) != 0) |
|
2089 glp_std_basis(lp->prob); |
|
2090 } |
|
2091 } |
|
2092 xassert(glp_simplex(lp->prob, &parm) == 0); |
|
2093 switch (glp_get_status(lp->prob)) |
|
2094 { case GLP_OPT: |
|
2095 lp->stat = CPX_STAT_OPTIMAL; |
|
2096 lp->meth = meth; |
|
2097 break; |
|
2098 case GLP_NOFEAS: |
|
2099 lp->stat = CPX_STAT_INFEASIBLE; |
|
2100 lp->meth = meth; |
|
2101 break; |
|
2102 case GLP_UNBND: |
|
2103 lp->stat = CPX_STAT_UNBOUNDED; |
|
2104 lp->meth = meth; |
|
2105 break; |
|
2106 default: |
|
2107 xassert(lp != lp); |
|
2108 } |
|
2109 done: return errcode; |
|
2110 } |
|
2111 |
|
2112 int CPXprimopt(CPXENV *env, CPXLP *lp) |
|
2113 { int errcode; |
|
2114 errcode = solvelp(env, lp, CPX_ALG_PRIMAL); |
|
2115 return errcode; |
|
2116 } |
|
2117 |
|
2118 int CPXdualopt(CPXENV *env, CPXLP *lp) |
|
2119 { int errcode; |
|
2120 errcode = solvelp(env, lp, CPX_ALG_DUAL); |
|
2121 return errcode; |
|
2122 } |
|
2123 |
|
2124 int CPXlpopt(CPXENV *env, CPXLP *lp) |
|
2125 { int errcode; |
|
2126 errcode = solvelp(env, lp, CPX_ALG_PRIMAL); |
|
2127 return errcode; |
|
2128 } |
|
2129 |
|
2130 /* eof */ |