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

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

Add new GetOption? routines for OptionID and fix some older ones

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