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

Last change on this file since 524 was 515, checked in by bjarni, 6 years ago

Changing the version number in CoinMP source files to 1.7.1 for trunk 1.7

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