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

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

Add LoadMatrix?, LoadNames?, and LoadNamesBuf? to CoinMP, and update CoinMP.def and unitTest.cpp.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 25.0 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 363 2009-11-16 16:00:50Z 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}
198
199
200SOLVAPI int SOLVCALL CoinLoadNames(HPROB hProb, char** ColNamesList, char** RowNamesList, char* ObjectName)
201{
202        PCOIN pCoin = (PCOIN)hProb;
203
204        if (!coinStoreNamesList(pCoin->pProblem, ColNamesList, RowNamesList, ObjectName)) {
205                return SOLV_CALL_FAILED;
206        }
207        return SOLV_CALL_SUCCESS;
208}
209
210
211
212SOLVAPI int SOLVCALL CoinLoadNamesBuf(HPROB hProb, char* ColNamesBuf, char* RowNamesBuf, char* ObjectName)
213{
214        PCOIN pCoin = (PCOIN)hProb;
215
216        if (!coinStoreNamesBuf(pCoin->pProblem, ColNamesBuf, RowNamesBuf, ObjectName)) {
217                return SOLV_CALL_FAILED;
218        }
219        return SOLV_CALL_SUCCESS;
220}
221
222
223
224SOLVAPI int SOLVCALL CoinLoadProblem(HPROB hProb, 
225                                int ColCount, int RowCount, int NZCount, int RangeCount, 
226                                int ObjectSense, double ObjectConst, double* ObjectCoeffs, 
227                                double* LowerBounds, double* UpperBounds, char* RowType, 
228                                double* RHSValues, double* RangeValues, int* MatrixBegin, 
229                                int* MatrixCount, int* MatrixIndex, double* MatrixValues, 
230                                char** ColNamesList, char** RowNamesList, char* ObjectName)
231{
232        PCOIN pCoin = (PCOIN)hProb;
233        PPROBLEM pProblem = pCoin->pProblem;
234
235        if (!coinStoreMatrix(pProblem, ColCount, RowCount, NZCount, RangeCount, ObjectSense,
236                                                 ObjectConst, ObjectCoeffs, LowerBounds, UpperBounds, RowType,
237                                                 RHSValues, RangeValues, MatrixBegin, MatrixCount, MatrixIndex,
238                                                 MatrixValues)) {
239                return SOLV_CALL_FAILED;
240        }
241        if (!coinStoreNamesList(pProblem, ColNamesList, RowNamesList, ObjectName)) {
242                return SOLV_CALL_FAILED;
243        }
244        return SOLV_CALL_SUCCESS;
245}
246
247// CoinLoadProblemBuf accepts ColNamesBuf/RowNamesBuf as character buffer with \0 after each name
248
249SOLVAPI int SOLVCALL CoinLoadProblemBuf(HPROB hProb, 
250                                int ColCount, int RowCount, int NZCount, int RangeCount, 
251                                int ObjectSense, double ObjectConst, double* ObjectCoeffs, 
252                                double* LowerBounds, double* UpperBounds, char* RowType, 
253                                double* RHSValues, double* RangeValues, int* MatrixBegin, 
254                                int* MatrixCount, int* MatrixIndex, double* MatrixValues, 
255                                char* ColNamesBuf, char* RowNamesBuf, char* ObjectName)
256{
257        PCOIN pCoin = (PCOIN)hProb;
258        PPROBLEM pProblem = pCoin->pProblem;
259
260        if (!coinStoreMatrix(pProblem, ColCount, RowCount, NZCount, RangeCount, ObjectSense,
261                                                 ObjectConst, ObjectCoeffs, LowerBounds, UpperBounds, RowType,
262                                                 RHSValues, RangeValues, MatrixBegin, MatrixCount, MatrixIndex,
263                                                 MatrixValues)) {
264                return SOLV_CALL_FAILED;
265        }
266        if (!coinStoreNamesBuf(pProblem, ColNamesBuf, RowNamesBuf, ObjectName)) {
267                return SOLV_CALL_FAILED;
268        }
269        return SOLV_CALL_SUCCESS;
270}
271
272
273
274
275SOLVAPI int SOLVCALL CoinLoadInitValues(HPROB hProb, double* InitValues)
276{
277        PCOIN pCoin = (PCOIN)hProb;
278
279        if (!coinStoreInitValues(pCoin->pProblem, InitValues)) {
280                return SOLV_CALL_FAILED;
281        }
282        return SOLV_CALL_SUCCESS;
283}
284
285
286SOLVAPI int SOLVCALL CoinLoadInteger(HPROB hProb, char* ColType)
287{   
288        PCOIN pCoin = (PCOIN)hProb;
289        PPROBLEM pProblem = pCoin->pProblem;
290
291        if (!coinStoreInteger(pProblem, ColType)) {
292                return SOLV_CALL_FAILED;
293        }
294        return SOLV_CALL_SUCCESS;
295}
296
297
298
299SOLVAPI int SOLVCALL CoinLoadPriority(HPROB hProb, int PriorCount, int* PriorIndex, 
300                                                                          int* PriorValues, int* PriorBranch)
301{
302        PCOIN pCoin = (PCOIN)hProb;
303
304        if (!coinStorePriority(pCoin->pProblem, PriorCount, PriorIndex, PriorValues, PriorBranch)) {
305                return SOLV_CALL_FAILED;
306        }
307        return SOLV_CALL_SUCCESS;
308}
309
310
311SOLVAPI int SOLVCALL CoinLoadSos(HPROB hProb, int SosCount, int SosNZCount, 
312                                                                int* SosType, int* SosPrior, int* SosBegin, 
313                                                                int* SosIndex, double* SosRef)
314{
315        PCOIN pCoin = (PCOIN)hProb;
316
317        if (!coinStoreSos(pCoin->pProblem, SosCount, SosNZCount, SosType, SosPrior, 
318                SosBegin, SosIndex, SosRef)) {
319                        return SOLV_CALL_FAILED;
320        }
321        return SOLV_CALL_SUCCESS;
322}
323
324
325
326SOLVAPI int SOLVCALL CoinLoadSemiCont(HPROB hProb, int SemiCount, int* SemiIndex)
327{
328        PCOIN pCoin = (PCOIN)hProb;
329        PPROBLEM pProblem = pCoin->pProblem;
330
331        if (!coinStoreSemiCont(pCoin->pProblem, SemiCount, SemiIndex)) {
332                return SOLV_CALL_FAILED;
333        }
334        return SOLV_CALL_SUCCESS;
335}
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 CoinGetOptionID(HPROB hProb, int OptionNr)
775{
776        PCOIN pCoin = (PCOIN)hProb;
777
778        return coinGetOptionID(pCoin->pSolver, OptionNr);
779}
780
781SOLVAPI int    SOLVCALL CoinLocateOptionID(HPROB hProb, int OptionID)
782{
783        PCOIN pCoin = (PCOIN)hProb;
784
785        return coinLocateOptionID(pCoin->pSolver, OptionID);
786}
787
788
789SOLVAPI int SOLVCALL CoinGetOptionInfo(HPROB hProb, int OptionNr, int* OptionID, int* GroupType, int* OptionType)
790{
791        PCOIN pCoin = (PCOIN)hProb;
792        int optionID;
793
794        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
795        if (OptionID)   *OptionID = optionID;
796        if (OptionType) *OptionType = coinGetOptionType(pCoin->pSolver, optionID);
797        if (GroupType)  *GroupType = coinGetOptionGroup(pCoin->pSolver, optionID);
798        return SOLV_CALL_SUCCESS;
799}
800
801
802
803SOLVAPI int SOLVCALL CoinGetOptionType(HPROB hProb, int OptionID)
804{
805        PCOIN pCoin = (PCOIN)hProb;
806
807        return coinGetOptionType(pCoin->pSolver, OptionID);
808}
809
810
811SOLVAPI int SOLVCALL CoinGetOptionGroup(HPROB hProb, int OptionID)
812{
813        PCOIN pCoin = (PCOIN)hProb;
814
815        return coinGetOptionGroup(pCoin->pSolver, OptionID);
816}
817
818
819SOLVAPI int    SOLVCALL CoinLocateOptionName(HPROB hProb, char* OptionName)
820{
821        PCOIN pCoin = (PCOIN)hProb;
822
823        return coinLocateOptionName(pCoin->pSolver, OptionName);
824}
825
826
827SOLVAPI const char* SOLVCALL CoinGetOptionName(HPROB hProb, int OptionNr)
828{
829        PCOIN pCoin = (PCOIN)hProb;
830        int optionID;
831
832        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
833        return coinGetOptionName(pCoin->pSolver, optionID);
834}
835
836
837SOLVAPI int SOLVCALL CoinGetOptionNameBuf(HPROB hProb, int OptionNr, char* OptionName, int buflen)
838{
839        PCOIN pCoin = (PCOIN)hProb;
840        int optionID;
841
842        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
843        return coinGetOptionNameBuf(pCoin->pSolver, optionID, OptionName, buflen);
844}
845
846
847SOLVAPI const char* SOLVCALL CoinGetOptionShortName(HPROB hProb, int OptionNr)
848{
849        PCOIN pCoin = (PCOIN)hProb;
850        int optionID;
851
852        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
853        return coinGetOptionShortName(pCoin->pSolver, optionID);
854}
855
856
857SOLVAPI int SOLVCALL CoinGetOptionShortNameBuf(HPROB hProb, int OptionNr, char* ShortName, int buflen)
858{
859        PCOIN pCoin = (PCOIN)hProb;
860        int optionID;
861
862        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
863        return coinGetOptionShortNameBuf(pCoin->pSolver, optionID, ShortName, buflen);
864}
865
866
867SOLVAPI int SOLVCALL CoinGetIntOptionMinMax(HPROB hProb, int OptionNr, int* MinValue, int* MaxValue)
868{
869        PCOIN pCoin = (PCOIN)hProb;
870        int optionID;
871
872        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
873        if (MinValue)   *MinValue = coinGetIntOptionMinValue(pCoin->pSolver, optionID);
874        if (MaxValue)   *MaxValue = coinGetIntOptionMaxValue(pCoin->pSolver, optionID);
875        return SOLV_CALL_SUCCESS;
876}
877
878
879SOLVAPI int SOLVCALL CoinGetRealOptionMinMax(HPROB hProb, int OptionNr, double* MinValue, double* MaxValue)
880{
881        PCOIN pCoin = (PCOIN)hProb;
882        int optionID;
883
884        optionID = coinGetOptionID(pCoin->pSolver, OptionNr);
885        if (MinValue)   *MinValue = coinGetRealOptionMinValue(pCoin->pSolver, optionID);
886        if (MaxValue)   *MaxValue = coinGetRealOptionMaxValue(pCoin->pSolver, optionID);
887        return SOLV_CALL_SUCCESS;
888}
889
890
891SOLVAPI int    SOLVCALL CoinGetIntOptionDefaultValue(HPROB hProb, int OptionID)
892{
893        PCOIN pCoin = (PCOIN)hProb;
894
895        return coinGetIntOptionDefaultValue(pCoin->pSolver, OptionID);
896}
897
898
899SOLVAPI int    SOLVCALL CoinGetIntOptionMinValue(HPROB hProb, int OptionID)
900{
901        PCOIN pCoin = (PCOIN)hProb;
902
903        return coinGetIntOptionMinValue(pCoin->pSolver, OptionID);
904}
905
906
907SOLVAPI int    SOLVCALL CoinGetIntOptionMaxValue(HPROB hProb, int OptionID)
908{
909        PCOIN pCoin = (PCOIN)hProb;
910
911        return coinGetIntOptionMaxValue(pCoin->pSolver, OptionID);
912}
913
914
915
916SOLVAPI double SOLVCALL CoinGetRealOptionDefaultValue(HPROB hProb, int OptionID)
917{
918        PCOIN pCoin = (PCOIN)hProb;
919
920        return coinGetRealOptionDefaultValue(pCoin->pSolver, OptionID);
921}
922
923
924SOLVAPI double SOLVCALL CoinGetRealOptionMinValue(HPROB hProb, int OptionID)
925{
926        PCOIN pCoin = (PCOIN)hProb;
927
928        return coinGetRealOptionMinValue(pCoin->pSolver, OptionID);
929}
930
931
932SOLVAPI double SOLVCALL CoinGetRealOptionMaxValue(HPROB hProb, int OptionID)
933{
934        PCOIN pCoin = (PCOIN)hProb;
935
936        return coinGetRealOptionMaxValue(pCoin->pSolver, OptionID);
937}
938
939
940
941
942SOLVAPI int SOLVCALL CoinGetOptionChanged(HPROB hProb, int OptionID)
943{
944        PCOIN pCoin = (PCOIN)hProb;
945
946        return coinGetOptionChanged(pCoin->pSolver, OptionID);
947}
948
949
950SOLVAPI int SOLVCALL CoinGetIntOption(HPROB hProb, int OptionID)
951{   
952        PCOIN pCoin = (PCOIN)hProb;
953
954//      if (pCoin)
955                return coinGetIntOption(pCoin->pSolver, OptionID);
956//      else {
957//              return CbcGetIntOption(OptionID);
958//      }
959}
960       
961
962
963SOLVAPI int SOLVCALL CoinSetIntOption(HPROB hProb, int OptionID, int IntValue)
964{
965        PCOIN pCoin = (PCOIN)hProb;
966
967        return coinSetIntOption(pCoin->pSolver, OptionID, IntValue);
968}
969
970
971
972SOLVAPI double SOLVCALL CoinGetRealOption(HPROB hProb, int OptionID)
973{
974        PCOIN pCoin = (PCOIN)hProb;
975
976        return coinGetRealOption(pCoin->pSolver, OptionID);
977}
978
979
980
981SOLVAPI int SOLVCALL CoinSetRealOption(HPROB hProb, int OptionID, double RealValue)
982{
983        PCOIN pCoin = (PCOIN)hProb;
984
985        return coinSetRealOption(pCoin->pSolver, OptionID, RealValue);
986}
987
988
989SOLVAPI const char* SOLVCALL CoinGetStringOption(HPROB hProb, int OptionID)
990{
991   return "";
992}
993
994
995SOLVAPI int SOLVCALL CoinGetStringOptionBuf(HPROB hProb, int OptionID, char* StringValue, int buflen)
996{
997   return SOLV_CALL_FAILED;
998}
999
1000
1001SOLVAPI int SOLVCALL CoinSetStringOption(HPROB hProb, int OptionID, const char* StringValue)
1002{
1003   return SOLV_CALL_FAILED;
1004}
1005
1006
1007
1008/************************************************************************/
1009/*  DLL Handling                                                        */
1010/************************************************************************/
1011
1012
1013#if defined(_MSC_VER)
1014#define WIN32_LEAN_AND_MEAN
1015#include <windows.h>
1016
1017
1018static HINSTANCE g_hInstance;
1019
1020
1021BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
1022{
1023   switch (dwReason) {
1024
1025      case DLL_PROCESS_ATTACH:
1026         g_hInstance = hInstance;
1027                   break;
1028
1029      case DLL_PROCESS_DETACH:
1030              break;
1031   }
1032   return 1;
1033}
1034#endif
1035
Note: See TracBrowser for help on using the repository browser.