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

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

Move all malloc and memcpy code in LoadXXX into CoinProblem?.c routines

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 23.8 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 362 2009-11-16 15:46:31Z 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** ColNamesList, char** RowNamesList, char* ObjectName)
188{
189        PCOIN pCoin = (PCOIN)hProb;
190        PPROBLEM pProblem = pCoin->pProblem;
191
192        if (!coinStoreMatrix(pProblem, ColCount, RowCount, NZCount, RangeCount, ObjectSense,
193                                                 ObjectConst, ObjectCoeffs, LowerBounds, UpperBounds, RowType,
194                                                 RHSValues, RangeValues, MatrixBegin, MatrixCount, MatrixIndex,
195                                                 MatrixValues)) {
196                return SOLV_CALL_FAILED;
197        }
198        if (!coinStoreNamesList(pProblem, ColNamesList, RowNamesList, ObjectName)) {
199                return SOLV_CALL_FAILED;
200        }
201        return SOLV_CALL_SUCCESS;
202}
203
204// CoinLoadProblemBuf accepts ColNamesBuf/RowNamesBuf as character buffer with \0 after each name
205
206SOLVAPI int SOLVCALL CoinLoadProblemBuf(HPROB hProb, 
207                                int ColCount, int RowCount, int NZCount, int RangeCount, 
208                                int ObjectSense, double ObjectConst, double* ObjectCoeffs, 
209                                double* LowerBounds, double* UpperBounds, char* RowType, 
210                                double* RHSValues, double* RangeValues, int* MatrixBegin, 
211                                int* MatrixCount, int* MatrixIndex, double* MatrixValues, 
212                                char* ColNamesBuf, char* RowNamesBuf, char* ObjectName)
213{
214        PCOIN pCoin = (PCOIN)hProb;
215        PPROBLEM pProblem = pCoin->pProblem;
216
217        if (!coinStoreMatrix(pProblem, ColCount, RowCount, NZCount, RangeCount, ObjectSense,
218                                                 ObjectConst, ObjectCoeffs, LowerBounds, UpperBounds, RowType,
219                                                 RHSValues, RangeValues, MatrixBegin, MatrixCount, MatrixIndex,
220                                                 MatrixValues)) {
221                return SOLV_CALL_FAILED;
222        }
223        if (!coinStoreNamesBuf(pProblem, ColNamesBuf, RowNamesBuf, ObjectName)) {
224                return SOLV_CALL_FAILED;
225        }
226        return SOLV_CALL_SUCCESS;
227}
228
229
230
231
232SOLVAPI int SOLVCALL CoinLoadInitValues(HPROB hProb, double* InitValues)
233{
234        PCOIN pCoin = (PCOIN)hProb;
235
236        if (!coinStoreInitValues(pCoin->pProblem, InitValues)) {
237                return SOLV_CALL_FAILED;
238        }
239        return SOLV_CALL_SUCCESS;
240}
241
242
243SOLVAPI int SOLVCALL CoinLoadInteger(HPROB hProb, char* ColType)
244{   
245        PCOIN pCoin = (PCOIN)hProb;
246        PPROBLEM pProblem = pCoin->pProblem;
247
248        if (!coinStoreInteger(pProblem, ColType)) {
249                return SOLV_CALL_FAILED;
250        }
251        return SOLV_CALL_SUCCESS;
252}
253
254
255
256SOLVAPI int SOLVCALL CoinLoadPriority(HPROB hProb, int PriorCount, int* PriorIndex, 
257                                                                          int* PriorValues, int* PriorBranch)
258{
259        PCOIN pCoin = (PCOIN)hProb;
260
261        if (!coinStorePriority(pCoin->pProblem, PriorCount, PriorIndex, PriorValues, PriorBranch)) {
262                return SOLV_CALL_FAILED;
263        }
264        return SOLV_CALL_SUCCESS;
265}
266
267
268SOLVAPI int SOLVCALL CoinLoadSos(HPROB hProb, int SosCount, int SosNZCount, 
269                                                                int* SosType, int* SosPrior, int* SosBegin, 
270                                                                int* SosIndex, double* SosRef)
271{
272        PCOIN pCoin = (PCOIN)hProb;
273
274        if (!coinStoreSos(pCoin->pProblem, SosCount, SosNZCount, SosType, SosPrior, 
275                SosBegin, SosIndex, SosRef)) {
276                        return SOLV_CALL_FAILED;
277        }
278        return SOLV_CALL_SUCCESS;
279}
280
281
282
283SOLVAPI int SOLVCALL CoinLoadSemiCont(HPROB hProb, int SemiCount, int* SemiIndex)
284{
285        PCOIN pCoin = (PCOIN)hProb;
286        PPROBLEM pProblem = pCoin->pProblem;
287
288        if (!coinStoreSemiCont(pCoin->pProblem, SemiCount, SemiIndex)) {
289                return SOLV_CALL_FAILED;
290        }
291        return SOLV_CALL_SUCCESS;
292}
293
294
295
296SOLVAPI int SOLVCALL CoinLoadQuadratic(HPROB hProb, int* QuadBegin, int* QuadCount, 
297                                                                                int* QuadIndex, double* QuadValues)
298{
299        return SOLV_CALL_FAILED;
300}
301
302
303SOLVAPI int SOLVCALL CoinLoadNonlinear(HPROB hProb, int NlpTreeCount, int NlpLineCount, 
304                                                                                int* NlpBegin, int* NlpOper, int* NlpArg1, 
305                                                                                int* NlpArg2, int* NlpIndex1, int* NlpIndex2, 
306                                                                                double* NlpValue1, double* NlpValue2)
307{
308        return SOLV_CALL_FAILED;
309}
310
311
312
313
314#define CHECK_MAXNAMELEN   100
315
316
317SOLVAPI int SOLVCALL CoinCheckProblem(HPROB hProb)
318{
319        PCOIN pCoin = (PCOIN)hProb;
320        PPROBLEM pProblem = pCoin->pProblem;
321        int i;
322
323        if (pProblem->ColCount == 0) {
324                return SOLV_CHECK_COLCOUNT;
325        }
326        if ((pProblem->RowCount < 0) ||
327                (pProblem->NZCount < 0) ||
328                (pProblem->RangeCount < 0)) {
329                return SOLV_CHECK_ROWCOUNT;
330        }
331        if ((pProblem->RangeCount > pProblem->RowCount)) {
332                return SOLV_CHECK_RANGECOUNT;
333        }
334        if ((pProblem->ObjectSense < -1) || 
335                (pProblem->ObjectSense > 1)) {
336                return SOLV_CHECK_OBJSENSE;
337        }
338        if (pProblem->RowType && (pProblem->RowCount > 0)) {
339                for (i = 0; i < pProblem->RowCount; i++) {
340                        if ((pProblem->RowType[i] != 'L') &&
341                                (pProblem->RowType[i] != 'E') &&
342                                (pProblem->RowType[i] != 'G') &&
343                                (pProblem->RowType[i] != 'R') &&
344                                (pProblem->RowType[i] != 'N')) {
345                                return SOLV_CHECK_ROWTYPE;
346                        }
347                }
348        }
349        if (pProblem->NZCount > 0) {
350                for (i = 0; i < pProblem->ColCount; i++) {
351                        if (pProblem->MatrixBegin[i] < 0) {
352                                return SOLV_CHECK_MATBEGIN;
353                        }
354                        if (pProblem->MatrixCount[i] < 0) {
355                                return SOLV_CHECK_MATCOUNT;
356                        }
357                        if (pProblem->MatrixBegin[i+1] - pProblem->MatrixBegin[i] != pProblem->MatrixCount[i]) {
358                                return SOLV_CHECK_MATBEGCNT;
359                        }
360                }
361                if (pProblem->MatrixBegin[pProblem->ColCount] != pProblem->NZCount) {
362                        return 100 + pProblem->MatrixBegin[pProblem->ColCount];
363                }
364                for (i = 0; i < pProblem->NZCount; i++) {
365                        if (pProblem->MatrixIndex[i] < 0) {
366                                return SOLV_CHECK_MATINDEX;
367                        }
368                        if (pProblem->MatrixIndex[i] >= pProblem->RowCount) {
369                                return SOLV_CHECK_MATINDEXROW;
370                        }
371                }
372        }
373        if (pProblem->LowerBounds && pProblem->UpperBounds) {
374                for (i = 0; i < pProblem->ColCount; i++) {
375                        if (pProblem->LowerBounds[i] > pProblem->UpperBounds[i]) {
376                                return SOLV_CHECK_BOUNDS;
377                        }
378                }
379        }
380        if (pProblem->ColType) {
381                for (i = 0; i < pProblem->ColCount; i++) {
382                        if ((pProblem->ColType[i] != 'C') &&
383                                (pProblem->ColType[i] != 'B') &&
384                                (pProblem->ColType[i] != 'I')) {
385                                return SOLV_CHECK_COLTYPE;
386                        }
387                }
388        }
389        if (pProblem->ColNamesBuf) {
390                if (pProblem->lenColNamesBuf <= 0) {
391                        return SOLV_CHECK_COLNAMES;
392                }
393                if (pProblem->lenColNamesBuf > pProblem->ColCount * CHECK_MAXNAMELEN) {
394                        return SOLV_CHECK_COLNAMESLEN;
395                }
396        }
397        if (pProblem->RowNamesBuf) {
398                if (pProblem->lenRowNamesBuf <= 0) {
399                        return SOLV_CHECK_ROWNAMES;
400                }
401                if (pProblem->lenRowNamesBuf > pProblem->RowCount * CHECK_MAXNAMELEN) {
402                        return SOLV_CHECK_ROWNAMSLEN;
403                }
404        }
405        return SOLV_CALL_SUCCESS;
406}
407
408
409
410/************************************************************************/
411/*  Problem Queries                                                     */
412/************************************************************************/
413
414
415SOLVAPI const char* SOLVCALL CoinGetProblemName(HPROB hProb)
416{
417        PCOIN pCoin = (PCOIN)hProb;
418
419        return pCoin->pProblem->ProblemName;
420}
421
422
423SOLVAPI int SOLVCALL CoinGetProblemNameBuf(HPROB hProb, char* ProbName, int buflen)
424{
425        strncpy(ProbName, CoinGetProblemName(hProb), buflen-1);
426        ProbName[buflen-1] = '\0';
427        return (int)strlen(ProbName);
428}
429
430
431
432SOLVAPI int SOLVCALL CoinGetColCount(HPROB hProb)
433{
434        PCOIN pCoin = (PCOIN)hProb;
435
436        return pCoin->pProblem->ColCount;
437}
438
439
440SOLVAPI int SOLVCALL CoinGetRowCount(HPROB hProb)
441{
442        PCOIN pCoin = (PCOIN)hProb;
443
444        return pCoin->pProblem->RowCount;
445}
446
447
448
449SOLVAPI const char* SOLVCALL CoinGetColName(HPROB hProb, int col)
450{
451        PCOIN pCoin = (PCOIN)hProb;
452
453        return pCoin->pProblem->ColNamesList[col];
454}
455
456
457SOLVAPI int SOLVCALL CoinGetColNameBuf(HPROB hProb, int col, char* ColName, int buflen)
458{
459        strncpy(ColName, CoinGetColName(hProb, col), buflen-1);
460        ColName[buflen-1] = '\0';
461        return (int)strlen(ColName);
462}
463
464
465SOLVAPI const char* SOLVCALL CoinGetRowName(HPROB hProb, int row)
466{
467        PCOIN pCoin = (PCOIN)hProb;
468
469        return pCoin->pProblem->RowNamesList[row];
470}
471
472
473SOLVAPI int SOLVCALL CoinGetRowNameBuf(HPROB hProb, int row, char* RowName, int buflen)
474{
475        strncpy(RowName, CoinGetRowName(hProb, row), buflen-1);
476        RowName[buflen-1] = '\0';
477        return (int)strlen(RowName);
478}
479
480
481
482SOLVAPI int SOLVCALL CoinSetMsgLogCallback(HPROB hProb, MSGLOGCALLBACK MsgLogCallback)
483{
484        PCOIN pCoin = (PCOIN)hProb;
485
486        pCoin->pSolver->MsgLogCallback = MsgLogCallback;
487        return SOLV_CALL_SUCCESS;
488}
489
490SOLVAPI int SOLVCALL CoinSetIterCallback(HPROB hProb, ITERCALLBACK IterCallback)
491{
492        PCOIN pCoin = (PCOIN)hProb;
493
494        pCoin->pSolver->IterCallback = IterCallback;
495        return SOLV_CALL_SUCCESS;
496}
497
498SOLVAPI int SOLVCALL CoinSetMipNodeCallback(HPROB hProb, MIPNODECALLBACK MipNodeCallback)
499{
500        PCOIN pCoin = (PCOIN)hProb;
501
502        pCoin->pSolver->MipNodeCallback = MipNodeCallback;
503        return SOLV_CALL_SUCCESS;
504}
505
506
507
508/************************************************************************/
509/*  Optimization                                                        */
510/************************************************************************/
511
512
513SOLVAPI int SOLVCALL CoinOptimizeProblem(HPROB hProb, int Method)
514{               
515        PCOIN pCoin = (PCOIN)hProb;
516
517        return CbcOptimizeProblem(pCoin->pProblem, pCoin->pResult, pCoin->pSolver, Method);
518}
519
520
521
522/************************************************************************/
523/*  Solution status                                                     */
524/************************************************************************/
525
526
527SOLVAPI int SOLVCALL CoinGetSolutionStatus(HPROB hProb)
528{
529        PCOIN pCoin = (PCOIN)hProb;
530
531        return pCoin->pResult->SolutionStatus;
532}
533
534
535 
536
537SOLVAPI const char* SOLVCALL CoinGetSolutionText(HPROB hProb, int SolutionStatus)
538{
539        PCOIN pCoin = (PCOIN)hProb;
540
541        return pCoin->pResult->SolutionText;
542}
543
544
545SOLVAPI int SOLVCALL CoinGetSolutionTextBuf(HPROB hProb, int SolutionStatus, char* SolutionText, int buflen)
546{
547        strncpy(SolutionText, CoinGetSolutionText(hProb, SolutionStatus), buflen-1);
548        SolutionText[buflen-1] = '\0';
549        return (int)strlen(SolutionText);
550}
551
552
553
554SOLVAPI double SOLVCALL CoinGetObjectValue(HPROB hProb)
555{
556        PCOIN pCoin = (PCOIN)hProb;
557
558        return pCoin->pResult->ObjectValue + pCoin->pProblem->ObjectConst;
559}
560
561
562SOLVAPI double SOLVCALL CoinGetMipBestBound(HPROB hProb)
563{
564        PCOIN pCoin = (PCOIN)hProb;
565
566        return pCoin->pResult->MipBestBound;
567}
568
569
570
571SOLVAPI int SOLVCALL CoinGetIterCount(HPROB hProb)
572{
573        PCOIN pCoin = (PCOIN)hProb;
574
575        return pCoin->pResult->IterCount;
576}
577
578
579SOLVAPI int SOLVCALL CoinGetMipNodeCount(HPROB hProb)
580{
581        PCOIN pCoin = (PCOIN)hProb;
582
583        return pCoin->pResult->MipNodeCount;
584}
585
586
587
588/************************************************************************/
589/*  Solution retrieval                                                  */
590/************************************************************************/
591
592
593SOLVAPI int SOLVCALL CoinGetSolutionValues(HPROB hProb, double* Activity, double* ReducedCost, 
594                                                                                         double* SlackValues, double* ShadowPrice)
595{
596        PCOIN pCoin = (PCOIN)hProb;
597        PPROBLEM pProblem = pCoin->pProblem;
598        PRESULT pResult = pCoin->pResult;
599
600        if (Activity && pResult->ColActivity) {
601                memcpy(Activity, pResult->ColActivity, pProblem->ColCount * sizeof(double));
602        }
603        if (ReducedCost && pResult->ReducedCost) {
604                memcpy(ReducedCost, pResult->ReducedCost, pProblem->ColCount * sizeof(double));
605        }
606        if (SlackValues && pResult->SlackValues) {
607                memcpy(SlackValues, pResult->SlackValues, pProblem->RowCount * sizeof(double));
608        }
609        if (ShadowPrice && pResult->ShadowPrice) {
610                memcpy(ShadowPrice, pResult->ShadowPrice, pProblem->RowCount * sizeof(double));
611        }
612        return SOLV_CALL_SUCCESS;
613}
614
615
616
617SOLVAPI int SOLVCALL CoinGetSolutionRanges(HPROB hProb, double* ObjLoRange, double* ObjUpRange,
618                                                                                         double* RhsLoRange, double* RhsUpRange)
619{
620        PCOIN pCoin = (PCOIN)hProb;
621        PPROBLEM pProblem = pCoin->pProblem;
622        PRESULT pResult = pCoin->pResult;
623
624        if (ObjLoRange && pResult->ObjLoRange) {
625                memcpy(ObjLoRange, pResult->ObjLoRange, pProblem->ColCount * sizeof(double));
626        }
627        if (ObjUpRange && pResult->ObjUpRange) {
628                memcpy(ObjUpRange, pResult->ObjUpRange, pProblem->ColCount * sizeof(double));
629        }
630        if (RhsLoRange && pResult->RhsLoRange) {
631                memcpy(RhsLoRange, pResult->RhsLoRange, pProblem->RowCount * sizeof(double));
632        }
633        if (RhsUpRange && pResult->RhsUpRange) {
634                memcpy(RhsUpRange, pResult->RhsUpRange, pProblem->RowCount * sizeof(double));
635        }
636        return SOLV_CALL_SUCCESS;
637}
638
639
640
641SOLVAPI int SOLVCALL CoinGetSolutionBasis(HPROB hProb, int* ColStatus, double* RowStatus)
642{
643        PCOIN pCoin = (PCOIN)hProb;
644        PPROBLEM pProblem = pCoin->pProblem;
645        PRESULT pResult = pCoin->pResult;
646
647        if (ColStatus && pResult->ColStatus) {
648                memcpy(ColStatus, pResult->ColStatus, pProblem->ColCount * sizeof(int));
649        }
650        if (RowStatus && pResult->RowStatus) {
651                memcpy(RowStatus, pResult->RowStatus, pProblem->RowCount * sizeof(int));
652        }
653        return SOLV_CALL_SUCCESS;
654}
655
656
657
658/************************************************************************/
659/*  File Handling                                                       */
660/************************************************************************/
661
662
663SOLVAPI int SOLVCALL CoinReadFile(HPROB hProb, int FileType, const char* ReadFilename)
664{
665   PCOIN pCoin = (PCOIN)hProb;
666
667        switch (FileType) {
668                case SOLV_FILE_MPS:             
669                        return CbcReadMpsFile(pCoin->pProblem, ReadFilename);
670
671                case SOLV_FILE_LP: 
672                case SOLV_FILE_BASIS: 
673                case SOLV_FILE_IIS: 
674
675                default:
676                        return SOLV_CALL_FAILED;
677        }
678        return SOLV_CALL_SUCCESS;
679}
680
681
682
683SOLVAPI int SOLVCALL CoinWriteFile(HPROB hProb, int FileType, const char* WriteFilename)
684{
685        PCOIN pCoin = (PCOIN)hProb;
686
687        switch (FileType) {
688                case SOLV_FILE_MPS:             
689                        return CbcWriteMpsFile(pCoin->pProblem, WriteFilename);   
690
691                case SOLV_FILE_LP: 
692                case SOLV_FILE_BASIS: 
693                case SOLV_FILE_IIS: 
694
695                default:
696                        return SOLV_CALL_FAILED;
697
698        }
699        return SOLV_CALL_SUCCESS;
700}
701
702
703
704SOLVAPI int SOLVCALL CoinOpenLogFile(HPROB hProb, const char* logFilename)
705{
706        PCOIN pCoin = (PCOIN)hProb;
707
708        strcpy(pCoin->pSolver->LogFilename, logFilename);
709        return SOLV_CALL_SUCCESS;
710}
711
712
713SOLVAPI int SOLVCALL CoinCloseLogFile(HPROB hProb)
714{
715        return SOLV_CALL_SUCCESS;
716}
717
718
719/************************************************************************/
720/*  Option Handling                                                     */
721/************************************************************************/
722
723
724SOLVAPI int SOLVCALL CoinGetOptionCount(HPROB hProb)
725{
726        PCOIN pCoin = (PCOIN)hProb;
727
728        return coinGetOptionCount(pCoin->pSolver);
729}
730
731SOLVAPI int SOLVCALL CoinGetOptionID(HPROB hProb, int OptionNr)
732{
733        PCOIN pCoin = (PCOIN)hProb;
734
735        return coinGetOptionID(pCoin->pSolver, OptionNr);
736}
737
738SOLVAPI int    SOLVCALL CoinLocateOptionID(HPROB hProb, int OptionID)
739{
740        PCOIN pCoin = (PCOIN)hProb;
741
742        return coinLocateOptionID(pCoin->pSolver, OptionID);
743}
744
745
746SOLVAPI int SOLVCALL CoinGetOptionInfo(HPROB hProb, int OptionNr, int* OptionID, int* GroupType, int* OptionType)
747{
748        PCOIN pCoin = (PCOIN)hProb;
749        int optionID;
750
751        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
752        if (OptionID)   *OptionID = optionID;
753        if (OptionType) *OptionType = coinGetOptionType(pCoin->pSolver, optionID);
754        if (GroupType)  *GroupType = coinGetOptionGroup(pCoin->pSolver, optionID);
755        return SOLV_CALL_SUCCESS;
756}
757
758
759
760SOLVAPI int SOLVCALL CoinGetOptionType(HPROB hProb, int OptionID)
761{
762        PCOIN pCoin = (PCOIN)hProb;
763
764        return coinGetOptionType(pCoin->pSolver, OptionID);
765}
766
767
768SOLVAPI int SOLVCALL CoinGetOptionGroup(HPROB hProb, int OptionID)
769{
770        PCOIN pCoin = (PCOIN)hProb;
771
772        return coinGetOptionGroup(pCoin->pSolver, OptionID);
773}
774
775
776SOLVAPI int    SOLVCALL CoinLocateOptionName(HPROB hProb, char* OptionName)
777{
778        PCOIN pCoin = (PCOIN)hProb;
779
780        return coinLocateOptionName(pCoin->pSolver, OptionName);
781}
782
783
784SOLVAPI const char* SOLVCALL CoinGetOptionName(HPROB hProb, int OptionNr)
785{
786        PCOIN pCoin = (PCOIN)hProb;
787        int optionID;
788
789        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
790        return coinGetOptionName(pCoin->pSolver, optionID);
791}
792
793
794SOLVAPI int SOLVCALL CoinGetOptionNameBuf(HPROB hProb, int OptionNr, char* OptionName, int buflen)
795{
796        PCOIN pCoin = (PCOIN)hProb;
797        int optionID;
798
799        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
800        return coinGetOptionNameBuf(pCoin->pSolver, optionID, OptionName, buflen);
801}
802
803
804SOLVAPI const char* SOLVCALL CoinGetOptionShortName(HPROB hProb, int OptionNr)
805{
806        PCOIN pCoin = (PCOIN)hProb;
807        int optionID;
808
809        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
810        return coinGetOptionShortName(pCoin->pSolver, optionID);
811}
812
813
814SOLVAPI int SOLVCALL CoinGetOptionShortNameBuf(HPROB hProb, int OptionNr, char* ShortName, int buflen)
815{
816        PCOIN pCoin = (PCOIN)hProb;
817        int optionID;
818
819        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
820        return coinGetOptionShortNameBuf(pCoin->pSolver, optionID, ShortName, buflen);
821}
822
823
824SOLVAPI int SOLVCALL CoinGetIntOptionMinMax(HPROB hProb, int OptionNr, int* MinValue, int* MaxValue)
825{
826        PCOIN pCoin = (PCOIN)hProb;
827        int optionID;
828
829        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
830        if (MinValue)   *MinValue = coinGetIntOptionMinValue(pCoin->pSolver, optionID);
831        if (MaxValue)   *MaxValue = coinGetIntOptionMaxValue(pCoin->pSolver, optionID);
832        return SOLV_CALL_SUCCESS;
833}
834
835
836SOLVAPI int SOLVCALL CoinGetRealOptionMinMax(HPROB hProb, int OptionNr, double* MinValue, double* MaxValue)
837{
838        PCOIN pCoin = (PCOIN)hProb;
839        int optionID;
840
841        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
842        if (MinValue)   *MinValue = coinGetRealOptionMinValue(pCoin->pSolver, optionID);
843        if (MaxValue)   *MaxValue = coinGetRealOptionMaxValue(pCoin->pSolver, optionID);
844        return SOLV_CALL_SUCCESS;
845}
846
847
848SOLVAPI int    SOLVCALL CoinGetIntOptionDefaultValue(HPROB hProb, int OptionID)
849{
850        PCOIN pCoin = (PCOIN)hProb;
851
852        return coinGetIntOptionDefaultValue(pCoin->pSolver, OptionID);
853}
854
855
856SOLVAPI int    SOLVCALL CoinGetIntOptionMinValue(HPROB hProb, int OptionID)
857{
858        PCOIN pCoin = (PCOIN)hProb;
859
860        return coinGetIntOptionMinValue(pCoin->pSolver, OptionID);
861}
862
863
864SOLVAPI int    SOLVCALL CoinGetIntOptionMaxValue(HPROB hProb, int OptionID)
865{
866        PCOIN pCoin = (PCOIN)hProb;
867
868        return coinGetIntOptionMaxValue(pCoin->pSolver, OptionID);
869}
870
871
872
873SOLVAPI double SOLVCALL CoinGetRealOptionDefaultValue(HPROB hProb, int OptionID)
874{
875        PCOIN pCoin = (PCOIN)hProb;
876
877        return coinGetRealOptionDefaultValue(pCoin->pSolver, OptionID);
878}
879
880
881SOLVAPI double SOLVCALL CoinGetRealOptionMinValue(HPROB hProb, int OptionID)
882{
883        PCOIN pCoin = (PCOIN)hProb;
884
885        return coinGetRealOptionMinValue(pCoin->pSolver, OptionID);
886}
887
888
889SOLVAPI double SOLVCALL CoinGetRealOptionMaxValue(HPROB hProb, int OptionID)
890{
891        PCOIN pCoin = (PCOIN)hProb;
892
893        return coinGetRealOptionMaxValue(pCoin->pSolver, OptionID);
894}
895
896
897
898
899SOLVAPI int SOLVCALL CoinGetOptionChanged(HPROB hProb, int OptionID)
900{
901        PCOIN pCoin = (PCOIN)hProb;
902
903        return coinGetOptionChanged(pCoin->pSolver, OptionID);
904}
905
906
907SOLVAPI int SOLVCALL CoinGetIntOption(HPROB hProb, int OptionID)
908{   
909        PCOIN pCoin = (PCOIN)hProb;
910
911//      if (pCoin)
912                return coinGetIntOption(pCoin->pSolver, OptionID);
913//      else {
914//              return CbcGetIntOption(OptionID);
915//      }
916}
917       
918
919
920SOLVAPI int SOLVCALL CoinSetIntOption(HPROB hProb, int OptionID, int IntValue)
921{
922        PCOIN pCoin = (PCOIN)hProb;
923
924        return coinSetIntOption(pCoin->pSolver, OptionID, IntValue);
925}
926
927
928
929SOLVAPI double SOLVCALL CoinGetRealOption(HPROB hProb, int OptionID)
930{
931        PCOIN pCoin = (PCOIN)hProb;
932
933        return coinGetRealOption(pCoin->pSolver, OptionID);
934}
935
936
937
938SOLVAPI int SOLVCALL CoinSetRealOption(HPROB hProb, int OptionID, double RealValue)
939{
940        PCOIN pCoin = (PCOIN)hProb;
941
942        return coinSetRealOption(pCoin->pSolver, OptionID, RealValue);
943}
944
945
946SOLVAPI const char* SOLVCALL CoinGetStringOption(HPROB hProb, int OptionID)
947{
948   return "";
949}
950
951
952SOLVAPI int SOLVCALL CoinGetStringOptionBuf(HPROB hProb, int OptionID, char* StringValue, int buflen)
953{
954   return SOLV_CALL_FAILED;
955}
956
957
958SOLVAPI int SOLVCALL CoinSetStringOption(HPROB hProb, int OptionID, const char* StringValue)
959{
960   return SOLV_CALL_FAILED;
961}
962
963
964
965/************************************************************************/
966/*  DLL Handling                                                        */
967/************************************************************************/
968
969
970#if defined(_MSC_VER)
971#define WIN32_LEAN_AND_MEAN
972#include <windows.h>
973
974
975static HINSTANCE g_hInstance;
976
977
978BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
979{
980   switch (dwReason) {
981
982      case DLL_PROCESS_ATTACH:
983         g_hInstance = hInstance;
984                   break;
985
986      case DLL_PROCESS_DETACH:
987              break;
988   }
989   return 1;
990}
991#endif
992
Note: See TracBrowser for help on using the repository browser.