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

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

Extract pOption/CoinOption.cpp out of pSolver/CoinSolver.cpp and update option calls in CoinCbc?

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