source: trunk/CoinMP/src/CoinMP.cpp @ 361

Last change on this file since 361 was 361, checked in by bjarni, 10 years ago

Move coinComputeIntVariables to CoinProblem?

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 29.6 KB
Line 
1/************************************************************************/
2/*                                                                      */
3/*  CoinMP Solver                                     Maximal Software  */
4/*                                                                      */
5/*  File         :  'coinmp.cpp'                                        */
6/*                                                                      */
7/*  Version      :  1.5                                                 */
8/*                                                                      */
9/*  Author       :  Bjarni Kristjansson, Maximal Software               */
10/*                                                                      */
11/*  Copyright (c) 2002-2009                     Bjarni Kristjansson     */
12/*                                                                      */
13/************************************************************************/
14
15// $Id: CoinMP.cpp 361 2009-11-16 12:54:04Z bjarni $
16
17#include <stdlib.h>
18#include <string.h>
19#include <stdio.h>
20#include <stdarg.h>
21#include <memory.h>
22
23#include "CoinProblem.h"
24#include "CoinResult.h"
25#include "CoinSolver.h"
26
27#include "CoinCbc.h"
28
29
30#ifndef COIN_DBL_MAX
31#define COIN_DBL_MAX DBL_MAX
32#endif
33
34
35#define SOLVER_EXPORT
36#define SOLV_LINK_LIB
37#include "CoinMP.h"
38
39
40#define NEW_STYLE_CBCMAIN
41
42
43const double COINMP_VERSION    = 1.5;
44const char*  COINMP_VERSIONSTR = "1.5";
45const char*  COINMP_NAME       = "CoinMP";
46
47
48/************************************************************************/
49/*  Solver Initialization                                               */
50/************************************************************************/
51
52
53SOLVAPI int SOLVCALL CoinInitSolver(const char* LicenseStr)
54{
55        return SOLV_CALL_SUCCESS;
56}
57
58
59SOLVAPI int SOLVCALL CoinFreeSolver(void)
60{
61        return SOLV_CALL_SUCCESS;
62}
63
64/************************************************************************/
65/*  Solver Queries                                                      */
66/************************************************************************/
67
68
69SOLVAPI const char* SOLVCALL CoinGetSolverName(void)
70{
71        return COINMP_NAME;
72}
73
74
75SOLVAPI int  SOLVCALL CoinGetSolverNameBuf(char* SolverName, int buflen)
76{
77        strncpy(SolverName, CoinGetSolverName(), buflen-1);
78        SolverName[buflen-1] = '\0';
79        return (int)strlen(SolverName);
80}
81
82
83SOLVAPI const char* SOLVCALL CoinGetVersionStr(void)
84{
85        return COINMP_VERSIONSTR;
86}
87
88
89SOLVAPI int  SOLVCALL CoinGetVersionStrBuf(char* VersionStr, int buflen)
90{
91        strncpy(VersionStr, CoinGetVersionStr(), buflen-1);
92        VersionStr[buflen-1] = '\0';
93        return (int)strlen(VersionStr);
94}
95
96
97SOLVAPI double SOLVCALL CoinGetVersion(void)
98{
99        return COINMP_VERSION;
100}
101
102
103SOLVAPI int SOLVCALL CoinGetFeatures(void)
104{
105        return SOLV_FEATURE_LP |
106                        SOLV_FEATURE_MIP;
107}
108
109
110SOLVAPI int SOLVCALL CoinGetMethods(void)
111{
112        return SOLV_METHOD_PRIMAL |
113                        SOLV_METHOD_DUAL | 
114                        SOLV_METHOD_BARRIER;
115}
116
117
118
119SOLVAPI double SOLVCALL CoinGetInfinity(void)
120{
121        return COIN_DBL_MAX;
122}
123
124
125/************************************************************************/
126/*  Coin Problem Info Structure                                         */
127/************************************************************************/
128
129
130typedef struct {
131                                PPROBLEM  pProblem;
132                                PRESULT   pResult;
133                                PSOLVER   pSolver;
134
135                                } COININFO, *PCOIN;
136 
137
138
139//PCOIN global_pCoin;
140
141
142
143/************************************************************************/
144/*  Create/Load Problem                                                 */
145/************************************************************************/
146
147
148SOLVAPI HPROB SOLVCALL CoinCreateProblem(const char* ProblemName)
149{
150        PCOIN pCoin;
151
152        pCoin = (PCOIN) malloc(sizeof(COININFO));
153
154        pCoin->pProblem = coinCreateProblemObject();
155        pCoin->pResult = coinCreateResultObject();
156        pCoin->pSolver = coinCreateSolverObject();
157
158        coinSetProblemName(pCoin->pProblem, ProblemName);
159        coinCopyOptionTable(pCoin->pSolver, CbcGetOptionTable(), CbcGetOptionCount());
160
161        return (HPROB)pCoin;
162}
163
164
165SOLVAPI int SOLVCALL CoinUnloadProblem(HPROB hProb)
166{
167   PCOIN pCoin = (PCOIN)hProb;
168       
169        if (pCoin) {
170                coinClearProblemObject(pCoin->pProblem);
171                coinClearResultObject(pCoin->pResult);
172                coinClearSolverObject(pCoin->pSolver);
173        }
174        free(pCoin);
175        pCoin = NULL;
176        return SOLV_CALL_SUCCESS;
177}
178
179
180
181SOLVAPI int SOLVCALL CoinLoadProblem(HPROB hProb, 
182                                int ColCount, int RowCount, int NZCount, int RangeCount, 
183                                int ObjectSense, double ObjectConst, double* ObjectCoeffs, 
184                                double* LowerBounds, double* UpperBounds, char* RowType, 
185                                double* RHSValues, double* RangeValues, int* MatrixBegin, 
186                                int* MatrixCount, int* MatrixIndex, double* MatrixValues, 
187                                char** ColNames, char** RowNames, char* ObjectName)
188{
189        PCOIN pCoin = (PCOIN)hProb;
190        PPROBLEM pProblem = pCoin->pProblem;
191
192        if (ColCount == 0) {
193                return SOLV_CALL_FAILED;
194        }
195        pProblem->ColCount = ColCount;
196        pProblem->RowCount = RowCount;
197        pProblem->NZCount = NZCount;
198        pProblem->RangeCount = RangeCount;
199        pProblem->ObjectSense = ObjectSense;
200        pProblem->ObjectConst = ObjectConst;
201
202        if (ColNames)   pProblem->lenColNamesBuf = coinGetLenNameListBuf(ColNames, ColCount);
203        if (RowNames)   pProblem->lenRowNamesBuf = coinGetLenNameListBuf(RowNames, RowCount);
204        if (ObjectName) pProblem->lenObjNameBuf  = (int)strlen(ObjectName) + 1;
205
206        if (ObjectCoeffs) pProblem->ObjectCoeffs = (double*) malloc(pProblem->ColCount     * sizeof(double));
207        if (RHSValues)    pProblem->RHSValues    = (double*) malloc(pProblem->RowCount     * sizeof(double));
208        if (RangeValues)  pProblem->RangeValues  = (double*) malloc(pProblem->RowCount     * sizeof(double));
209        if (RowType)      pProblem->RowType      = (char*)   malloc(pProblem->RowCount     * sizeof(char));
210        if (MatrixBegin)  pProblem->MatrixBegin  = (int*)    malloc((pProblem->ColCount+1) * sizeof(int));
211        if (MatrixCount)  pProblem->MatrixCount  = (int*)    malloc(pProblem->ColCount     * sizeof(int));
212        if (MatrixIndex)  pProblem->MatrixIndex  = (int*)    malloc(pProblem->NZCount      * sizeof(int)); 
213        if (MatrixValues) pProblem->MatrixValues = (double*) malloc(pProblem->NZCount      * sizeof(double));
214        if (LowerBounds)  pProblem->LowerBounds  = (double*) malloc(pProblem->ColCount     * sizeof(double));
215        if (UpperBounds)  pProblem->UpperBounds  = (double*) malloc(pProblem->ColCount     * sizeof(double));
216        if (ColNames)     pProblem->ColNamesList = (char**)  malloc(pProblem->ColCount     * sizeof(char* ));
217        if (RowNames)     pProblem->RowNamesList = (char**)  malloc(pProblem->RowCount     * sizeof(char* ));
218        if (ColNames)     pProblem->ColNamesBuf  = (char*)   malloc(pProblem->lenColNamesBuf * sizeof(char));
219        if (RowNames)     pProblem->RowNamesBuf  = (char*)   malloc(pProblem->lenRowNamesBuf * sizeof(char));
220        if (ObjectName)   pProblem->ObjectName   = (char*)   malloc(pProblem->lenObjNameBuf  * sizeof(char));
221
222        if (pProblem->RowCount > 0) {
223                pProblem->RowLower = (double* )malloc(pProblem->RowCount*sizeof(double));
224                pProblem->RowUpper = (double* )malloc(pProblem->RowCount*sizeof(double));
225                if (!pProblem->RowLower || !pProblem->RowUpper) {
226                        return SOLV_CALL_FAILED;
227                }
228        }
229
230        if (pProblem->ObjectCoeffs) memcpy(pProblem->ObjectCoeffs, ObjectCoeffs, pProblem->ColCount     * sizeof(double));
231        if (pProblem->RHSValues)    memcpy(pProblem->RHSValues,    RHSValues,    pProblem->RowCount     * sizeof(double));
232        if (pProblem->RangeValues)  memcpy(pProblem->RangeValues,  RangeValues,  pProblem->RowCount     * sizeof(double));
233        if (pProblem->RowType)      memcpy(pProblem->RowType,      RowType,      pProblem->RowCount     * sizeof(char));
234        if (pProblem->MatrixBegin)  memcpy(pProblem->MatrixBegin,  MatrixBegin,  (pProblem->ColCount+1) * sizeof(int));
235        if (pProblem->MatrixCount)  memcpy(pProblem->MatrixCount,  MatrixCount,  pProblem->ColCount     * sizeof(int));
236        if (pProblem->MatrixIndex)  memcpy(pProblem->MatrixIndex,  MatrixIndex,  pProblem->NZCount      * sizeof(int));
237        if (pProblem->MatrixValues) memcpy(pProblem->MatrixValues, MatrixValues, pProblem->NZCount      * sizeof(double));
238        if (pProblem->LowerBounds)  memcpy(pProblem->LowerBounds,  LowerBounds,  pProblem->ColCount     * sizeof(double));
239        if (pProblem->UpperBounds)  memcpy(pProblem->UpperBounds,  UpperBounds,  pProblem->ColCount     * sizeof(double));
240        if (pProblem->ObjectName)   memcpy(pProblem->ObjectName,   ObjectName,   pProblem->lenObjNameBuf  * sizeof(char));
241
242        coinCopyNamesList(pProblem->ColNamesList, pProblem->ColNamesBuf, ColNames, ColCount);
243        coinCopyNamesList(pProblem->RowNamesList, pProblem->RowNamesBuf, RowNames, RowCount);
244
245        if (!coinComputeRowLowerUpper(pProblem, COIN_DBL_MAX)) {
246                return SOLV_CALL_FAILED;
247        }
248        return SOLV_CALL_SUCCESS;
249}
250
251// CoinLoadProblemBuf accepts ColNamesBuf/RowNamesBuf as character buffer with \0 after each name
252
253SOLVAPI int SOLVCALL CoinLoadProblemBuf(HPROB hProb, 
254                                int ColCount, int RowCount, int NZCount, int RangeCount, 
255                                int ObjectSense, double ObjectConst, double* ObjectCoeffs, 
256                                double* LowerBounds, double* UpperBounds, char* RowType, 
257                                double* RHSValues, double* RangeValues, int* MatrixBegin, 
258                                int* MatrixCount, int* MatrixIndex, double* MatrixValues, 
259                                char* ColNamesBuf, char* RowNamesBuf, char* ObjectName)
260{
261        PCOIN pCoin = (PCOIN)hProb;
262        char** ColNamesList;
263        char** RowNamesList;
264        int result;
265
266        ColNamesList = (char**)malloc(ColCount * sizeof(char*));
267        RowNamesList = (char**)malloc(RowCount * sizeof(char*));
268        coinSetupNamesList(ColNamesList, ColNamesBuf, ColCount);
269        coinSetupNamesList(RowNamesList, RowNamesBuf, RowCount);
270        result = CoinLoadProblem(hProb, ColCount, RowCount, NZCount, RangeCount,
271                                ObjectSense, ObjectConst, ObjectCoeffs, LowerBounds, UpperBounds, RowType,
272                                RHSValues, RangeValues, MatrixBegin, MatrixCount, MatrixIndex, MatrixValues,
273                                ColNamesList, RowNamesList, ObjectName);
274        if (ColNamesList) free(ColNamesList);
275        if (RowNamesList) free(RowNamesList);
276        return result;
277}
278
279
280SOLVAPI int SOLVCALL CoinLoadInitValues(HPROB hProb, double* InitValues)
281{
282        PCOIN pCoin = (PCOIN)hProb;
283        PPROBLEM pProblem = pCoin->pProblem;
284
285        if (!InitValues) {
286                return SOLV_CALL_FAILED;
287        }       
288        if (InitValues)   pProblem->InitValues   = (double* ) malloc(pProblem->ColCount     * sizeof(double));
289
290        if (pProblem->InitValues)   memcpy(pProblem->InitValues,   InitValues,   pProblem->ColCount     * sizeof(double));
291        return SOLV_CALL_SUCCESS;
292}
293
294
295SOLVAPI int SOLVCALL CoinLoadInteger(HPROB hProb, char* ColType)
296{   
297        PCOIN pCoin = (PCOIN)hProb;
298        PPROBLEM pProblem = pCoin->pProblem;
299
300        if (pProblem->ColCount == 0) {
301                return SOLV_CALL_FAILED;
302        }
303        if (!ColType) {
304                return SOLV_CALL_FAILED;
305        }
306        pProblem->ColType = (char* )malloc(pProblem->ColCount * sizeof(char));
307        if (!pProblem->ColType) {
308                return SOLV_CALL_FAILED;
309        }
310        memcpy(pProblem->ColType, ColType, pProblem->ColCount * sizeof(char));
311
312        if (!coinComputeIntVariables(pProblem)) {
313                return SOLV_CALL_FAILED;
314        }
315        pProblem->SolveAsMIP = 1;
316        return SOLV_CALL_SUCCESS;
317}
318
319
320
321SOLVAPI int SOLVCALL CoinLoadPriority(HPROB hProb, int PriorCount, int* PriorIndex, 
322                                                                          int* PriorValues, int* PriorBranch)
323{
324        PCOIN pCoin = (PCOIN)hProb;
325        PPROBLEM pProblem = pCoin->pProblem;
326
327        if (PriorCount == 0) {
328                return SOLV_CALL_FAILED;
329        }
330        pProblem->PriorCount = PriorCount;
331        if (PriorIndex)  pProblem->PriorIndex  = (int* )malloc(PriorCount * sizeof(int));
332        if (PriorValues) pProblem->PriorValues = (int* )malloc(PriorCount * sizeof(int));
333        if (PriorBranch) pProblem->PriorBranch = (int* )malloc(PriorCount * sizeof(int));
334        if (pProblem->PriorIndex)  memcpy(pProblem->PriorIndex,  PriorIndex,  PriorCount * sizeof(int));
335        if (pProblem->PriorValues) memcpy(pProblem->PriorValues, PriorValues, PriorCount * sizeof(int));
336        if (pProblem->PriorBranch) memcpy(pProblem->PriorBranch, PriorBranch, PriorCount * sizeof(int));
337
338        return SOLV_CALL_SUCCESS;
339}
340
341
342SOLVAPI int SOLVCALL CoinLoadSos(HPROB hProb, int SosCount, int SosNZCount, 
343                                                                int* SosType, int* SosPrior, int* SosBegin, 
344                                                                int* SosIndex, double* SosRef)
345{
346        PCOIN pCoin = (PCOIN)hProb;
347        PPROBLEM pProblem = pCoin->pProblem;
348
349        if ((SosCount == 0) || (SosNZCount == 0)) {
350                return SOLV_CALL_FAILED;
351        }
352        pProblem->SosCount = SosCount;
353        pProblem->SosNZCount = SosNZCount;
354
355        if (SosType)  pProblem->SosType  = (int* )malloc(SosCount     * sizeof(int));
356        if (SosPrior) pProblem->SosPrior = (int* )malloc(SosCount     * sizeof(int));
357        if (SosBegin) pProblem->SosBegin = (int* )malloc((SosCount+1) * sizeof(int));
358        if (SosIndex) pProblem->SosIndex = (int* )malloc(SosNZCount   * sizeof(int));
359        if (SosRef)   pProblem->SosRef   = (double* )malloc(SosNZCount* sizeof(double));
360
361        if (pProblem->SosType)  memcpy(pProblem->SosType,  SosType,  SosCount     * sizeof(int));
362        if (pProblem->SosPrior) memcpy(pProblem->SosPrior, SosPrior, SosCount     * sizeof(int));
363        if (pProblem->SosBegin) memcpy(pProblem->SosBegin, SosBegin, (SosCount+1) * sizeof(int));
364        if (pProblem->SosIndex) memcpy(pProblem->SosIndex, SosIndex, SosNZCount   * sizeof(int));
365        if (pProblem->SosRef)   memcpy(pProblem->SosRef,   SosRef,   SosNZCount   * sizeof(double));
366
367        pProblem->SolveAsMIP = 1;
368        return SOLV_CALL_SUCCESS;
369}
370
371
372
373SOLVAPI int SOLVCALL CoinLoadSemiCont(HPROB hProb, int SemiCount, int* SemiIndex)
374{
375        PCOIN pCoin = (PCOIN)hProb;
376        PPROBLEM pProblem = pCoin->pProblem;
377
378        if (SemiCount == 0) {
379                return SOLV_CALL_FAILED;
380        }
381        if (!SemiIndex) {
382                return SOLV_CALL_FAILED;
383        }
384        pProblem->SemiCount = SemiCount;
385        pProblem->SemiIndex = (int* )malloc(pProblem->SemiCount * sizeof(int));
386        if (!pProblem->SemiIndex) {
387                return SOLV_CALL_FAILED;
388        }
389        memcpy(pProblem->SemiIndex, SemiIndex, pProblem->SemiCount * sizeof(int));
390
391        pProblem->SolveAsMIP = 1;
392        return SOLV_CALL_SUCCESS;
393}
394
395
396SOLVAPI int SOLVCALL CoinLoadQuadratic(HPROB hProb, int* QuadBegin, int* QuadCount, 
397                                                                                int* QuadIndex, double* QuadValues)
398{
399        return SOLV_CALL_FAILED;
400}
401
402
403SOLVAPI int SOLVCALL CoinLoadNonlinear(HPROB hProb, int NlpTreeCount, int NlpLineCount, 
404                                                                                int* NlpBegin, int* NlpOper, int* NlpArg1, 
405                                                                                int* NlpArg2, int* NlpIndex1, int* NlpIndex2, 
406                                                                                double* NlpValue1, double* NlpValue2)
407{
408        return SOLV_CALL_FAILED;
409}
410
411
412
413
414#define CHECK_MAXNAMELEN   100
415
416
417SOLVAPI int SOLVCALL CoinCheckProblem(HPROB hProb)
418{
419        PCOIN pCoin = (PCOIN)hProb;
420        PPROBLEM pProblem = pCoin->pProblem;
421        int i;
422
423        if (pProblem->ColCount == 0) {
424                return SOLV_CHECK_COLCOUNT;
425        }
426        if ((pProblem->RowCount < 0) ||
427                (pProblem->NZCount < 0) ||
428                (pProblem->RangeCount < 0)) {
429                return SOLV_CHECK_ROWCOUNT;
430        }
431        if ((pProblem->RangeCount > pProblem->RowCount)) {
432                return SOLV_CHECK_RANGECOUNT;
433        }
434        if ((pProblem->ObjectSense < -1) || 
435                (pProblem->ObjectSense > 1)) {
436                return SOLV_CHECK_OBJSENSE;
437        }
438        if (pProblem->RowType && (pProblem->RowCount > 0)) {
439                for (i = 0; i < pProblem->RowCount; i++) {
440                        if ((pProblem->RowType[i] != 'L') &&
441                                (pProblem->RowType[i] != 'E') &&
442                                (pProblem->RowType[i] != 'G') &&
443                                (pProblem->RowType[i] != 'R') &&
444                                (pProblem->RowType[i] != 'N')) {
445                                return SOLV_CHECK_ROWTYPE;
446                        }
447                }
448        }
449        if (pProblem->NZCount > 0) {
450                for (i = 0; i < pProblem->ColCount; i++) {
451                        if (pProblem->MatrixBegin[i] < 0) {
452                                return SOLV_CHECK_MATBEGIN;
453                        }
454                        if (pProblem->MatrixCount[i] < 0) {
455                                return SOLV_CHECK_MATCOUNT;
456                        }
457                        if (pProblem->MatrixBegin[i+1] - pProblem->MatrixBegin[i] != pProblem->MatrixCount[i]) {
458                                return SOLV_CHECK_MATBEGCNT;
459                        }
460                }
461                if (pProblem->MatrixBegin[pProblem->ColCount] != pProblem->NZCount) {
462                        return 100 + pProblem->MatrixBegin[pProblem->ColCount];
463                }
464                for (i = 0; i < pProblem->NZCount; i++) {
465                        if (pProblem->MatrixIndex[i] < 0) {
466                                return SOLV_CHECK_MATINDEX;
467                        }
468                        if (pProblem->MatrixIndex[i] >= pProblem->RowCount) {
469                                return SOLV_CHECK_MATINDEXROW;
470                        }
471                }
472        }
473        if (pProblem->LowerBounds && pProblem->UpperBounds) {
474                for (i = 0; i < pProblem->ColCount; i++) {
475                        if (pProblem->LowerBounds[i] > pProblem->UpperBounds[i]) {
476                                return SOLV_CHECK_BOUNDS;
477                        }
478                }
479        }
480        if (pProblem->ColType) {
481                for (i = 0; i < pProblem->ColCount; i++) {
482                        if ((pProblem->ColType[i] != 'C') &&
483                                (pProblem->ColType[i] != 'B') &&
484                                (pProblem->ColType[i] != 'I')) {
485                                return SOLV_CHECK_COLTYPE;
486                        }
487                }
488        }
489        if (pProblem->ColNamesBuf) {
490                if (pProblem->lenColNamesBuf <= 0) {
491                        return SOLV_CHECK_COLNAMES;
492                }
493                if (pProblem->lenColNamesBuf > pProblem->ColCount * CHECK_MAXNAMELEN) {
494                        return SOLV_CHECK_COLNAMESLEN;
495                }
496        }
497        if (pProblem->RowNamesBuf) {
498                if (pProblem->lenRowNamesBuf <= 0) {
499                        return SOLV_CHECK_ROWNAMES;
500                }
501                if (pProblem->lenRowNamesBuf > pProblem->RowCount * CHECK_MAXNAMELEN) {
502                        return SOLV_CHECK_ROWNAMSLEN;
503                }
504        }
505        return SOLV_CALL_SUCCESS;
506}
507
508
509
510/************************************************************************/
511/*  Problem Queries                                                     */
512/************************************************************************/
513
514
515SOLVAPI const char* SOLVCALL CoinGetProblemName(HPROB hProb)
516{
517        PCOIN pCoin = (PCOIN)hProb;
518
519        return pCoin->pProblem->ProblemName;
520}
521
522
523SOLVAPI int SOLVCALL CoinGetProblemNameBuf(HPROB hProb, char* ProbName, int buflen)
524{
525        strncpy(ProbName, CoinGetProblemName(hProb), buflen-1);
526        ProbName[buflen-1] = '\0';
527        return (int)strlen(ProbName);
528}
529
530
531
532SOLVAPI int SOLVCALL CoinGetColCount(HPROB hProb)
533{
534        PCOIN pCoin = (PCOIN)hProb;
535
536        return pCoin->pProblem->ColCount;
537}
538
539
540SOLVAPI int SOLVCALL CoinGetRowCount(HPROB hProb)
541{
542        PCOIN pCoin = (PCOIN)hProb;
543
544        return pCoin->pProblem->RowCount;
545}
546
547
548
549SOLVAPI const char* SOLVCALL CoinGetColName(HPROB hProb, int col)
550{
551        PCOIN pCoin = (PCOIN)hProb;
552
553        return pCoin->pProblem->ColNamesList[col];
554}
555
556
557SOLVAPI int SOLVCALL CoinGetColNameBuf(HPROB hProb, int col, char* ColName, int buflen)
558{
559        strncpy(ColName, CoinGetColName(hProb, col), buflen-1);
560        ColName[buflen-1] = '\0';
561        return (int)strlen(ColName);
562}
563
564
565SOLVAPI const char* SOLVCALL CoinGetRowName(HPROB hProb, int row)
566{
567        PCOIN pCoin = (PCOIN)hProb;
568
569        return pCoin->pProblem->RowNamesList[row];
570}
571
572
573SOLVAPI int SOLVCALL CoinGetRowNameBuf(HPROB hProb, int row, char* RowName, int buflen)
574{
575        strncpy(RowName, CoinGetRowName(hProb, row), buflen-1);
576        RowName[buflen-1] = '\0';
577        return (int)strlen(RowName);
578}
579
580
581
582SOLVAPI int SOLVCALL CoinSetMsgLogCallback(HPROB hProb, MSGLOGCALLBACK MsgLogCallback)
583{
584        PCOIN pCoin = (PCOIN)hProb;
585
586        pCoin->pSolver->MsgLogCallback = MsgLogCallback;
587        return SOLV_CALL_SUCCESS;
588}
589
590SOLVAPI int SOLVCALL CoinSetIterCallback(HPROB hProb, ITERCALLBACK IterCallback)
591{
592        PCOIN pCoin = (PCOIN)hProb;
593
594        pCoin->pSolver->IterCallback = IterCallback;
595        return SOLV_CALL_SUCCESS;
596}
597
598SOLVAPI int SOLVCALL CoinSetMipNodeCallback(HPROB hProb, MIPNODECALLBACK MipNodeCallback)
599{
600        PCOIN pCoin = (PCOIN)hProb;
601
602        pCoin->pSolver->MipNodeCallback = MipNodeCallback;
603        return SOLV_CALL_SUCCESS;
604}
605
606
607
608/************************************************************************/
609/*  Optimization                                                        */
610/************************************************************************/
611
612
613SOLVAPI int SOLVCALL CoinOptimizeProblem(HPROB hProb, int Method)
614{               
615        PCOIN pCoin = (PCOIN)hProb;
616
617        return CbcOptimizeProblem(pCoin->pProblem, pCoin->pResult, pCoin->pSolver, Method);
618}
619
620
621
622/************************************************************************/
623/*  Solution status                                                     */
624/************************************************************************/
625
626
627SOLVAPI int SOLVCALL CoinGetSolutionStatus(HPROB hProb)
628{
629        PCOIN pCoin = (PCOIN)hProb;
630
631        return pCoin->pResult->SolutionStatus;
632}
633
634
635 
636
637SOLVAPI const char* SOLVCALL CoinGetSolutionText(HPROB hProb, int SolutionStatus)
638{
639        PCOIN pCoin = (PCOIN)hProb;
640
641        return pCoin->pResult->SolutionText;
642}
643
644
645SOLVAPI int SOLVCALL CoinGetSolutionTextBuf(HPROB hProb, int SolutionStatus, char* SolutionText, int buflen)
646{
647        strncpy(SolutionText, CoinGetSolutionText(hProb, SolutionStatus), buflen-1);
648        SolutionText[buflen-1] = '\0';
649        return (int)strlen(SolutionText);
650}
651
652
653
654SOLVAPI double SOLVCALL CoinGetObjectValue(HPROB hProb)
655{
656        PCOIN pCoin = (PCOIN)hProb;
657
658        return pCoin->pResult->ObjectValue + pCoin->pProblem->ObjectConst;
659}
660
661
662SOLVAPI double SOLVCALL CoinGetMipBestBound(HPROB hProb)
663{
664        PCOIN pCoin = (PCOIN)hProb;
665
666        return pCoin->pResult->MipBestBound;
667}
668
669
670
671SOLVAPI int SOLVCALL CoinGetIterCount(HPROB hProb)
672{
673        PCOIN pCoin = (PCOIN)hProb;
674
675        return pCoin->pResult->IterCount;
676}
677
678
679SOLVAPI int SOLVCALL CoinGetMipNodeCount(HPROB hProb)
680{
681        PCOIN pCoin = (PCOIN)hProb;
682
683        return pCoin->pResult->MipNodeCount;
684}
685
686
687
688/************************************************************************/
689/*  Solution retrieval                                                  */
690/************************************************************************/
691
692
693SOLVAPI int SOLVCALL CoinGetSolutionValues(HPROB hProb, double* Activity, double* ReducedCost, 
694                                                                                         double* SlackValues, double* ShadowPrice)
695{
696        PCOIN pCoin = (PCOIN)hProb;
697        PPROBLEM pProblem = pCoin->pProblem;
698        PRESULT pResult = pCoin->pResult;
699
700        if (Activity && pResult->ColActivity) {
701                memcpy(Activity, pResult->ColActivity, pProblem->ColCount * sizeof(double));
702        }
703        if (ReducedCost && pResult->ReducedCost) {
704                memcpy(ReducedCost, pResult->ReducedCost, pProblem->ColCount * sizeof(double));
705        }
706        if (SlackValues && pResult->SlackValues) {
707                memcpy(SlackValues, pResult->SlackValues, pProblem->RowCount * sizeof(double));
708        }
709        if (ShadowPrice && pResult->ShadowPrice) {
710                memcpy(ShadowPrice, pResult->ShadowPrice, pProblem->RowCount * sizeof(double));
711        }
712        return SOLV_CALL_SUCCESS;
713}
714
715
716
717SOLVAPI int SOLVCALL CoinGetSolutionRanges(HPROB hProb, double* ObjLoRange, double* ObjUpRange,
718                                                                                         double* RhsLoRange, double* RhsUpRange)
719{
720        PCOIN pCoin = (PCOIN)hProb;
721        PPROBLEM pProblem = pCoin->pProblem;
722        PRESULT pResult = pCoin->pResult;
723
724        if (ObjLoRange && pResult->ObjLoRange) {
725                memcpy(ObjLoRange, pResult->ObjLoRange, pProblem->ColCount * sizeof(double));
726        }
727        if (ObjUpRange && pResult->ObjUpRange) {
728                memcpy(ObjUpRange, pResult->ObjUpRange, pProblem->ColCount * sizeof(double));
729        }
730        if (RhsLoRange && pResult->RhsLoRange) {
731                memcpy(RhsLoRange, pResult->RhsLoRange, pProblem->RowCount * sizeof(double));
732        }
733        if (RhsUpRange && pResult->RhsUpRange) {
734                memcpy(RhsUpRange, pResult->RhsUpRange, pProblem->RowCount * sizeof(double));
735        }
736        return SOLV_CALL_SUCCESS;
737}
738
739
740
741SOLVAPI int SOLVCALL CoinGetSolutionBasis(HPROB hProb, int* ColStatus, double* RowStatus)
742{
743        PCOIN pCoin = (PCOIN)hProb;
744        PPROBLEM pProblem = pCoin->pProblem;
745        PRESULT pResult = pCoin->pResult;
746
747        if (ColStatus && pResult->ColStatus) {
748                memcpy(ColStatus, pResult->ColStatus, pProblem->ColCount * sizeof(int));
749        }
750        if (RowStatus && pResult->RowStatus) {
751                memcpy(RowStatus, pResult->RowStatus, pProblem->RowCount * sizeof(int));
752        }
753        return SOLV_CALL_SUCCESS;
754}
755
756
757
758/************************************************************************/
759/*  File Handling                                                       */
760/************************************************************************/
761
762
763SOLVAPI int SOLVCALL CoinReadFile(HPROB hProb, int FileType, const char* ReadFilename)
764{
765   PCOIN pCoin = (PCOIN)hProb;
766
767        switch (FileType) {
768                case SOLV_FILE_MPS:             
769                        return CbcReadMpsFile(pCoin->pProblem, ReadFilename);
770
771                case SOLV_FILE_LP: 
772                case SOLV_FILE_BASIS: 
773                case SOLV_FILE_IIS: 
774
775                default:
776                        return SOLV_CALL_FAILED;
777        }
778        return SOLV_CALL_SUCCESS;
779}
780
781
782
783SOLVAPI int SOLVCALL CoinWriteFile(HPROB hProb, int FileType, const char* WriteFilename)
784{
785        PCOIN pCoin = (PCOIN)hProb;
786
787        switch (FileType) {
788                case SOLV_FILE_MPS:             
789                        return CbcWriteMpsFile(pCoin->pProblem, WriteFilename);   
790
791                case SOLV_FILE_LP: 
792                case SOLV_FILE_BASIS: 
793                case SOLV_FILE_IIS: 
794
795                default:
796                        return SOLV_CALL_FAILED;
797
798        }
799        return SOLV_CALL_SUCCESS;
800}
801
802
803
804SOLVAPI int SOLVCALL CoinOpenLogFile(HPROB hProb, const char* logFilename)
805{
806        PCOIN pCoin = (PCOIN)hProb;
807
808        strcpy(pCoin->pSolver->LogFilename, logFilename);
809        return SOLV_CALL_SUCCESS;
810}
811
812
813SOLVAPI int SOLVCALL CoinCloseLogFile(HPROB hProb)
814{
815        return SOLV_CALL_SUCCESS;
816}
817
818
819/************************************************************************/
820/*  Option Handling                                                     */
821/************************************************************************/
822
823
824SOLVAPI int SOLVCALL CoinGetOptionCount(HPROB hProb)
825{
826        PCOIN pCoin = (PCOIN)hProb;
827
828        return coinGetOptionCount(pCoin->pSolver);
829}
830
831SOLVAPI int SOLVCALL CoinGetOptionID(HPROB hProb, int OptionNr)
832{
833        PCOIN pCoin = (PCOIN)hProb;
834
835        return coinGetOptionID(pCoin->pSolver, OptionNr);
836}
837
838SOLVAPI int    SOLVCALL CoinLocateOptionID(HPROB hProb, int OptionID)
839{
840        PCOIN pCoin = (PCOIN)hProb;
841
842        return coinLocateOptionID(pCoin->pSolver, OptionID);
843}
844
845
846SOLVAPI int SOLVCALL CoinGetOptionInfo(HPROB hProb, int OptionNr, int* OptionID, int* GroupType, int* OptionType)
847{
848        PCOIN pCoin = (PCOIN)hProb;
849        int optionID;
850
851        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
852        if (OptionID)   *OptionID = optionID;
853        if (OptionType) *OptionType = coinGetOptionType(pCoin->pSolver, optionID);
854        if (GroupType)  *GroupType = coinGetOptionGroup(pCoin->pSolver, optionID);
855        return SOLV_CALL_SUCCESS;
856}
857
858
859
860SOLVAPI int SOLVCALL CoinGetOptionType(HPROB hProb, int OptionID)
861{
862        PCOIN pCoin = (PCOIN)hProb;
863
864        return coinGetOptionType(pCoin->pSolver, OptionID);
865}
866
867
868SOLVAPI int SOLVCALL CoinGetOptionGroup(HPROB hProb, int OptionID)
869{
870        PCOIN pCoin = (PCOIN)hProb;
871
872        return coinGetOptionGroup(pCoin->pSolver, OptionID);
873}
874
875
876SOLVAPI int    SOLVCALL CoinLocateOptionName(HPROB hProb, char* OptionName)
877{
878        PCOIN pCoin = (PCOIN)hProb;
879
880        return coinLocateOptionName(pCoin->pSolver, OptionName);
881}
882
883
884SOLVAPI const char* SOLVCALL CoinGetOptionName(HPROB hProb, int OptionNr)
885{
886        PCOIN pCoin = (PCOIN)hProb;
887        int optionID;
888
889        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
890        return coinGetOptionName(pCoin->pSolver, optionID);
891}
892
893
894SOLVAPI int SOLVCALL CoinGetOptionNameBuf(HPROB hProb, int OptionNr, char* OptionName, int buflen)
895{
896        PCOIN pCoin = (PCOIN)hProb;
897        int optionID;
898
899        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
900        return coinGetOptionNameBuf(pCoin->pSolver, optionID, OptionName, buflen);
901}
902
903
904SOLVAPI const char* SOLVCALL CoinGetOptionShortName(HPROB hProb, int OptionNr)
905{
906        PCOIN pCoin = (PCOIN)hProb;
907        int optionID;
908
909        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
910        return coinGetOptionShortName(pCoin->pSolver, optionID);
911}
912
913
914SOLVAPI int SOLVCALL CoinGetOptionShortNameBuf(HPROB hProb, int OptionNr, char* ShortName, int buflen)
915{
916        PCOIN pCoin = (PCOIN)hProb;
917        int optionID;
918
919        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
920        return coinGetOptionShortNameBuf(pCoin->pSolver, optionID, ShortName, buflen);
921}
922
923
924SOLVAPI int SOLVCALL CoinGetIntOptionMinMax(HPROB hProb, int OptionNr, int* MinValue, int* MaxValue)
925{
926        PCOIN pCoin = (PCOIN)hProb;
927        int optionID;
928
929        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
930        if (MinValue)   *MinValue = coinGetIntOptionMinValue(pCoin->pSolver, optionID);
931        if (MaxValue)   *MaxValue = coinGetIntOptionMaxValue(pCoin->pSolver, optionID);
932        return SOLV_CALL_SUCCESS;
933}
934
935
936SOLVAPI int SOLVCALL CoinGetRealOptionMinMax(HPROB hProb, int OptionNr, double* MinValue, double* MaxValue)
937{
938        PCOIN pCoin = (PCOIN)hProb;
939        int optionID;
940
941        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
942        if (MinValue)   *MinValue = coinGetRealOptionMinValue(pCoin->pSolver, optionID);
943        if (MaxValue)   *MaxValue = coinGetRealOptionMaxValue(pCoin->pSolver, optionID);
944        return SOLV_CALL_SUCCESS;
945}
946
947
948SOLVAPI int    SOLVCALL CoinGetIntOptionDefaultValue(HPROB hProb, int OptionID)
949{
950        PCOIN pCoin = (PCOIN)hProb;
951
952        return coinGetIntOptionDefaultValue(pCoin->pSolver, OptionID);
953}
954
955
956SOLVAPI int    SOLVCALL CoinGetIntOptionMinValue(HPROB hProb, int OptionID)
957{
958        PCOIN pCoin = (PCOIN)hProb;
959
960        return coinGetIntOptionMinValue(pCoin->pSolver, OptionID);
961}
962
963
964SOLVAPI int    SOLVCALL CoinGetIntOptionMaxValue(HPROB hProb, int OptionID)
965{
966        PCOIN pCoin = (PCOIN)hProb;
967
968        return coinGetIntOptionMaxValue(pCoin->pSolver, OptionID);
969}
970
971
972
973SOLVAPI double SOLVCALL CoinGetRealOptionDefaultValue(HPROB hProb, int OptionID)
974{
975        PCOIN pCoin = (PCOIN)hProb;
976
977        return coinGetRealOptionDefaultValue(pCoin->pSolver, OptionID);
978}
979
980
981SOLVAPI double SOLVCALL CoinGetRealOptionMinValue(HPROB hProb, int OptionID)
982{
983        PCOIN pCoin = (PCOIN)hProb;
984
985        return coinGetRealOptionMinValue(pCoin->pSolver, OptionID);
986}
987
988
989SOLVAPI double SOLVCALL CoinGetRealOptionMaxValue(HPROB hProb, int OptionID)
990{
991        PCOIN pCoin = (PCOIN)hProb;
992
993        return coinGetRealOptionMaxValue(pCoin->pSolver, OptionID);
994}
995
996
997
998
999SOLVAPI int SOLVCALL CoinGetOptionChanged(HPROB hProb, int OptionID)
1000{
1001        PCOIN pCoin = (PCOIN)hProb;
1002
1003        return coinGetOptionChanged(pCoin->pSolver, OptionID);
1004}
1005
1006
1007SOLVAPI int SOLVCALL CoinGetIntOption(HPROB hProb, int OptionID)
1008{   
1009        PCOIN pCoin = (PCOIN)hProb;
1010
1011//      if (pCoin)
1012                return coinGetIntOption(pCoin->pSolver, OptionID);
1013//      else {
1014//              return CbcGetIntOption(OptionID);
1015//      }
1016}
1017       
1018
1019
1020SOLVAPI int SOLVCALL CoinSetIntOption(HPROB hProb, int OptionID, int IntValue)
1021{
1022        PCOIN pCoin = (PCOIN)hProb;
1023
1024        return coinSetIntOption(pCoin->pSolver, OptionID, IntValue);
1025}
1026
1027
1028
1029SOLVAPI double SOLVCALL CoinGetRealOption(HPROB hProb, int OptionID)
1030{
1031        PCOIN pCoin = (PCOIN)hProb;
1032
1033        return coinGetRealOption(pCoin->pSolver, OptionID);
1034}
1035
1036
1037
1038SOLVAPI int SOLVCALL CoinSetRealOption(HPROB hProb, int OptionID, double RealValue)
1039{
1040        PCOIN pCoin = (PCOIN)hProb;
1041
1042        return coinSetRealOption(pCoin->pSolver, OptionID, RealValue);
1043}
1044
1045
1046SOLVAPI const char* SOLVCALL CoinGetStringOption(HPROB hProb, int OptionID)
1047{
1048   return "";
1049}
1050
1051
1052SOLVAPI int SOLVCALL CoinGetStringOptionBuf(HPROB hProb, int OptionID, char* StringValue, int buflen)
1053{
1054   return SOLV_CALL_FAILED;
1055}
1056
1057
1058SOLVAPI int SOLVCALL CoinSetStringOption(HPROB hProb, int OptionID, const char* StringValue)
1059{
1060   return SOLV_CALL_FAILED;
1061}
1062
1063
1064
1065/************************************************************************/
1066/*  DLL Handling                                                        */
1067/************************************************************************/
1068
1069
1070#if defined(_MSC_VER)
1071#define WIN32_LEAN_AND_MEAN
1072#include <windows.h>
1073
1074
1075static HINSTANCE g_hInstance;
1076
1077
1078BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
1079{
1080   switch (dwReason) {
1081
1082      case DLL_PROCESS_ATTACH:
1083         g_hInstance = hInstance;
1084                   break;
1085
1086      case DLL_PROCESS_DETACH:
1087              break;
1088   }
1089   return 1;
1090}
1091#endif
1092
Note: See TracBrowser for help on using the repository browser.