Changeset 113


Ignore:
Timestamp:
Aug 11, 2008 8:35:50 PM (11 years ago)
Author:
bjarni
Message:

Updated with new API interface for CoinMP version 1.2

Location:
trunk
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/CoinMP/MSVisualStudio/v8/CoinMP/CoinMP.rc

    r98 r113  
    5454
    5555VS_VERSION_INFO VERSIONINFO
    56  FILEVERSION 1,1,0,1
    57  PRODUCTVERSION 1,1,0,1
     56 FILEVERSION 1,2,0,1
     57 PRODUCTVERSION 1,2,0,1
    5858 FILEFLAGSMASK 0x17L
    5959#ifdef _DEBUG
     
    7272            VALUE "CompanyName", "Maximal Software, Inc."
    7373            VALUE "FileDescription", "CoinMP Dynamic Link Library"
    74             VALUE "FileVersion", "1, 1, 0, 1"
     74            VALUE "FileVersion", "1, 2, 0, 1"
    7575            VALUE "InternalName", "CoinMP"
    7676            VALUE "LegalCopyright", "Copyright (C) 2002-2008"
    7777            VALUE "OriginalFilename", "CoinMP.dll"
    7878            VALUE "ProductName", "CoinMP Dynamic Link Library"
    79             VALUE "ProductVersion", "1, 1, 0, 1"
     79            VALUE "ProductVersion", "1, 2, 0, 1"
    8080        END
    8181    END
  • trunk/CoinMP/configure.ac

    r101 r113  
    1313AC_PREREQ(2.59)
    1414
    15 AC_INIT([CoinMP],[1.1],[coin-discuss@list.coin-or.org])
     15AC_INIT([CoinMP],[1.2],[coin-discuss@list.coin-or.org])
    1616
    1717AC_COPYRIGHT([
  • trunk/CoinMP/examples/example.c

    r105 r113  
    11
    2 /* unitTest.c */
     2/* example.c */
    33
    44#include <stdlib.h>
     
    1212
    1313
    14 void GetAndCheckSolution(double optimalValue, double objectConst, HPROB hProb)
     14void GetAndCheckSolution(double optimalValue, HPROB hProb)
    1515{
    1616        int solutionStatus;
     
    2020        solutionStatus = CoinGetSolutionStatus(hProb);
    2121        solutionText = CoinGetSolutionText(hProb,solutionStatus);
    22         objectValue =  CoinGetObjectValue(hProb) + objectConst;
     22        objectValue =  CoinGetObjectValue(hProb);
    2323     
    2424        fprintf(stdout, "\n---------------------------------------\n");
     
    3737
    3838
    39 void RunTestProblem(char *problemName, double optimalValue,
    40           int colCount, int rowCount, int nonZeroCount, int rangeCount, int objectSense,
    41       double *objectCoeffs, double objectConst, double *rhsValues, double *rangeValues, char *columnType,
    42           char *rowType, int *matrixBegin, int *matrixCount, int *matrixIndex, double *matrixValues,
    43           double *lowerBounds, double *upperBounds, double *initValues, char **colNames, char **rowNames)
     39void RunTestProblem(char *problemName, double optimalValue, int colCount, int rowCount,
     40          int nonZeroCount, int rangeCount, int objectSense, double *objectCoeffs, double objectConst,
     41      double *rhsValues, double *rangeValues, char *columnType, char *rowType, int *matrixBegin,
     42          int *matrixCount, int *matrixIndex, double *matrixValues, double *lowerBounds, double *upperBounds,
     43          double *initValues, char **colNames, char **rowNames)
    4444{
    4545    HPROB hProb;
     
    4848    hProb = CoinCreateProblem(problemName); 
    4949    CoinLoadProblem(hProb, colCount, rowCount, nonZeroCount, rangeCount,
    50                                         objectSense, objectCoeffs, rhsValues, rangeValues,
     50                                        objectSense, objectCoeffs, objectConst, rhsValues, rangeValues,
    5151                                        rowType, matrixBegin, matrixCount, matrixIndex, matrixValues,
    5252                                        lowerBounds, upperBounds, initValues, colNames, rowNames );
     
    5555        }
    5656        CoinOptimizeProblem(hProb, 0);
    57         GetAndCheckSolution(optimalValue, objectConst, hProb);
     57        GetAndCheckSolution(optimalValue, hProb);
    5858    CoinUnloadProblem(hProb);
    5959}
     
    8080    int rangeCount = 0;
    8181
    82     int objectSense = OBJSENS_MAX;
     82    int objectSense = SOLV_OBJSENS_MAX;
    8383        double objectConst = 0.0;
    8484    double objectCoeffs[8] = { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 };
     
    100100   
    101101        double optimalValue = 1428729.2857143;
    102         RunTestProblem(problemName, optimalValue,
    103           colCount, rowCount, nonZeroCount, rangeCount,
    104       objectSense, objectCoeffs, objectConst, rhsValues, NULL,
    105           NULL, rowType, matrixBegin, matrixCount, matrixIndex,
    106           matrixValues, lowerBounds, upperBounds, initValues,
    107           colNames, rowNames);
     102
     103        RunTestProblem(problemName, optimalValue, colCount, rowCount,
     104          nonZeroCount, rangeCount, objectSense, objectCoeffs, objectConst,
     105      rhsValues, NULL, NULL, rowType, matrixBegin, matrixCount,
     106          matrixIndex, matrixValues, lowerBounds, upperBounds,
     107          initValues, colNames, rowNames);
    108108}
    109109
     
    117117    int rangeCount = 0;
    118118
    119         int objectSense = OBJSENS_MAX;
     119        int objectSense = SOLV_OBJSENS_MAX;
    120120        double objectConst = - 4000.0 / 30.0;
    121121    double objectCoeffs[2] = { 0.05 , 0.08 };
     
    136136        double optimalValue = 506.66666667;
    137137
    138         RunTestProblem(problemName, optimalValue,
    139           colCount, rowCount, nonZeroCount, rangeCount, objectSense,
    140       objectCoeffs, objectConst, rhsValues, NULL, NULL, rowType,
    141       matrixBegin, matrixCount, matrixIndex, matrixValues,
    142           lowerBounds, upperBounds, NULL, colNames, rowNames);
     138        RunTestProblem(problemName, optimalValue, colCount, rowCount,
     139          nonZeroCount, rangeCount, objectSense, objectCoeffs, objectConst,
     140      rhsValues, NULL, NULL, rowType, matrixBegin, matrixCount,
     141      matrixIndex, matrixValues, lowerBounds, upperBounds,
     142          NULL, colNames, rowNames);
    143143}
    144144
     
    152152        int nrng = 0;
    153153
    154         int objsens = OBJSENS_MIN;
     154        int objsens = SOLV_OBJSENS_MIN;
    155155
    156156        double objconst = 0.0;
     
    203203        double optimalValue = -464.753142857;
    204204
    205         RunTestProblem(probname, optimalValue,
    206           ncol, nrow, nels, nrng, objsens, dobj, objconst, drhs, NULL,
    207       NULL, rtyp, mbeg, mcnt, midx, mval, dclo, dcup,
    208           NULL, colname, rowname);
     205        RunTestProblem(probname, optimalValue, ncol, nrow, nels, nrng,
     206          objsens, dobj, objconst, drhs, NULL, NULL, rtyp, mbeg, mcnt,
     207      midx, mval, dclo, dcup, NULL, colname, rowname);
    209208}
    210209
     
    218217        int nrng = 0;
    219218
    220         int objsens = OBJSENS_MIN;
     219        int objsens = SOLV_OBJSENS_MIN;
    221220
    222221        double objconst = 0.0;
     
    273272        double optimalValue = 3089.0;
    274273
    275         RunTestProblem(probname, optimalValue,
    276           ncol, nrow, nels, nrng, objsens, dobj, objconst, drhs, NULL,
    277       ctyp, rtyp, mbeg, mcnt, midx, mval, dclo, dcup,
    278           NULL, colname, rowname);
     274        RunTestProblem(probname, optimalValue, ncol, nrow, nels, nrng,
     275          objsens, dobj, objconst, drhs, NULL, ctyp, rtyp, mbeg, mcnt,
     276      midx, mval, dclo, dcup, NULL, colname, rowname);
    279277}
    280278
     
    288286        int nrng = 2;
    289287       
    290         int objsens = OBJSENS_MIN;
     288        int objsens = SOLV_OBJSENS_MIN;
    291289        double objconst = 0.0;
    292290        double dobj[8]={1, 0, 0, 0, 2, 0, 0, -1};
     
    312310        double optimalValue = 3.23684210526;
    313311
    314         RunTestProblem(probname, optimalValue,
    315           ncol, nrow, nels, nrng, objsens, dobj, objconst, drhs, drng,
    316       ctyp, rtyp, mbeg, mcnt, midx, mval, dclo, dcup,
    317           NULL, colname, rowname);
     312        RunTestProblem(probname, optimalValue, ncol, nrow, nels, nrng,
     313          objsens, dobj, objconst, drhs, drng, ctyp, rtyp, mbeg, mcnt,
     314      midx, mval, dclo, dcup, NULL, colname, rowname);
    318315}
    319316
     
    328325        SolveProblemP0033();
    329326        SolveProblemExmip1();
    330         fprintf(stdout, "All tests completed successfully\n" );
     327        fprintf(stdout, "All unit tests completed successfully\n" );
    331328    CoinFreeSolver();
    332329        return 0;
  • trunk/CoinMP/src/CoinMP.cpp

    r103 r113  
    55/*  File         :  'coinmp.cpp'                                        */
    66/*                                                                      */
    7 /*  Version      :  1.1                                                 */
     7/*  Version      :  1.2                                                 */
    88/*                                                                      */
    99/*  Author       :  Bjarni Kristjansson, Maximal Software               */
     
    5353
    5454#define SOLVER_EXPORT
    55 #define SOLVER_LIB
     55#define SOLV_LINK_LIB
    5656#include "CoinMP.h"
    5757
     
    6767SOLVAPI int CoinInitSolver(char *LicenseStr)
    6868{
    69         return SOLV_SUCCESS;
     69        return SOLV_CALL_SUCCESS;
    7070}
    7171
     
    7373SOLVAPI int CoinFreeSolver(void)
    7474{
    75         return SOLV_SUCCESS;
     75        return SOLV_CALL_SUCCESS;
    7676}
    7777
     
    8989SOLVAPI char*  CoinGetVersionStr(void)
    9090{
    91         return "1.1";
     91        return "1.2";
    9292}
    9393
     
    9595SOLVAPI double CoinGetVersion(void)
    9696{
    97         return 1.1;
    98 }
    99 
    100 
    101 SOLVAPI int    CoinGetFeatures(void)
    102 {
    103         return 0;
    104 }
    105 
    106 
    107 
    108 SOLVAPI double CoinGetRealMax(void)
     97        return 1.2;
     98}
     99
     100
     101SOLVAPI int CoinGetFeatures(void)
     102{
     103        return SOLV_FEATURE_LP |
     104                        SOLV_FEATURE_MIP;
     105}
     106
     107
     108SOLVAPI int CoinGetMethods(void)
     109{
     110        return SOLV_METHOD_PRIMAL |
     111                        SOLV_METHOD_DUAL |
     112                        SOLV_METHOD_BARRIER;
     113}
     114
     115
     116
     117SOLVAPI double CoinGetInfinity(void)
    109118{
    110119        return COIN_DBL_MAX;
     
    245254
    246255public:
    247    void setCallback(NODECALLBACK mipCodeCallback);
     256   void setCallback(MIPNODECALLBACK mipNodeCallback);
    248257
    249258        virtual CbcAction event(CbcEvent whichEvent);
     
    267276
    268277private:
    269         NODECALLBACK mipNodeCallback_;
     278        MIPNODECALLBACK mipNodeCallback_;
    270279        int lastSolCount_;
    271280};
    272281
    273282
    274 void CBNodeHandler::setCallback(NODECALLBACK mipNodeCallback)
     283void CBNodeHandler::setCallback(MIPNODECALLBACK mipNodeCallback)
    275284{
    276285  mipNodeCallback_ = mipNodeCallback;
     
    365374                                CglSimpleRounding *rounding;
    366375
     376                                double ObjectConst;
    367377                                int SolutionStatus;
    368378                                int RowCount, ColCount;
     
    374384                                MSGLOGCALLBACK  MessageLogCallback;
    375385                                ITERCALLBACK    IterationCallback;
    376                                 NODECALLBACK    MipNodeCallback;
     386                                MIPNODECALLBACK MipNodeCallback;
    377387                                } COININFO, *PCOIN;
    378388 
     
    401411        pCoin->iterhandler = NULL;
    402412        pCoin->nodehandler = NULL;
     413        pCoin->ObjectConst = 0.0;
     414        pCoin->SolutionStatus = 0;
    403415        pCoin->ColCount = 0;
    404416        pCoin->RowCount = 0;
     
    413425
    414426SOLVAPI int CoinLoadProblem(HPROB hProb,
    415                                                         int ColCount, int RowCount, int NonZeroCount,
    416                                                         int RangeCount, int ObjectSense, double* ObjectCoeffs,
     427                                                        int ColCount, int RowCount, int NonZeroCount, int RangeCount,
     428                                                        int ObjectSense, double* ObjectCoeffs, double ObjectConst,
    417429                                                        double* RHSValues, double* RangeValues, char* RowType,
    418430                                                        int* MatrixBegin, int* MatrixCount, int* MatrixIndex,
     
    425437        pCoin->ColCount = ColCount;
    426438        pCoin->RowCount = RowCount;
     439        pCoin->ObjectConst = ObjectConst;
    427440
    428441        pCoin->clp->setOptimizationDirection(ObjectSense);
     
    431444        pCoin->RowUpper = (double *)malloc(RowCount*sizeof(double));
    432445        if (!pCoin->RowLower && !pCoin->RowUpper) {
    433                 return SOLV_FAILED;
     446                return SOLV_CALL_FAILED;
    434447        }
    435448   for( i = 0; i < RowCount; i++ ){
     
    477490        pCoin->clp->copyNames(rowNameList, colNameList);
    478491
    479    return SOLV_SUCCESS;
     492   return SOLV_CALL_SUCCESS;
    480493}
    481494
     
    488501        pCoin->IsInt = (char *)malloc(pCoin->ColCount*sizeof(char));
    489502        if (!pCoin->IsInt) {
    490                 return SOLV_FAILED;
     503                return SOLV_CALL_FAILED;
    491504        }
    492505        for (i = 0; i < pCoin->ColCount; i++ ) {
     
    513526#endif
    514527        }
    515         return SOLV_SUCCESS;
     528        return SOLV_CALL_SUCCESS;
    516529}
    517530
     
    521534                                                                          int *PriorValues, int *BranchDir)
    522535{
    523         return SOLV_FAILED;
     536        return SOLV_CALL_FAILED;
    524537}
    525538
     
    529542                                                                int *SosIndex, double *SosRef)
    530543{
    531         return SOLV_FAILED;
     544        return SOLV_CALL_FAILED;
    532545}
    533546
     
    536549                                                                                int *QuadIndex, double *QuadValues)
    537550{
    538         return SOLV_FAILED;
     551        return SOLV_CALL_FAILED;
    539552}
    540553
     
    545558                                                                                double *NlpValue1, double *NlpValue2)
    546559{
    547         return SOLV_FAILED;
     560        return SOLV_CALL_FAILED;
    548561}
    549562
     
    562575        free(pCoin);
    563576        pCoin = NULL;
    564         return SOLV_SUCCESS;
     577        return SOLV_CALL_SUCCESS;
    565578}
    566579
     
    580593        vsprintf(strbuf,FormatStr,pVa);
    581594        global_pCoin->MessageLogCallback(strbuf);
    582         return SOLV_SUCCESS;
     595        return SOLV_CALL_SUCCESS;
    583596}
    584597
     
    597610        }
    598611        global_pCoin->IterationCallback(IterCount, ObjectValue, IsFeasible, InfeasValue);
    599         return SOLV_SUCCESS;
     612        return SOLV_CALL_SUCCESS;
    600613}
    601614
     
    608621        }
    609622        global_pCoin->MipNodeCallback(IterCount, NodeCount, BestBound, BestObject, IsMipImproved);
    610         return SOLV_SUCCESS;
     623        return SOLV_CALL_SUCCESS;
    611624}
    612625
     
    626639        if (pCoin->cbc) pCoin->cbc->passInMessageHandler(pCoin->msghandler);
    627640        if (pCoin->osi) pCoin->osi->passInMessageHandler(pCoin->msghandler);
    628         return SOLV_SUCCESS;
     641        return SOLV_CALL_SUCCESS;
    629642}
    630643
     
    640653        pCoin->iterhandler->setIterCallback(IterCallback);
    641654        if (pCoin->clp) pCoin->clp->passInEventHandler(pCoin->iterhandler);
    642         return SOLV_SUCCESS;
    643 }
    644 
    645 
    646 SOLVAPI int CoinSetMipNodeCallback(HPROB hProb, NODECALLBACK NodeCallback)
     655        return SOLV_CALL_SUCCESS;
     656}
     657
     658
     659SOLVAPI int CoinSetMipNodeCallback(HPROB hProb, MIPNODECALLBACK MipNodeCallback)
    647660{
    648661        PCOIN pCoin = (PCOIN)hProb;
    649662
    650         pCoin->MipNodeCallback = NodeCallback;
     663        pCoin->MipNodeCallback = MipNodeCallback;
    651664        delete pCoin->nodehandler;
    652665
     
    654667        pCoin->nodehandler = new CBNodeHandler(pCoin->cbc);
    655668
    656         pCoin->nodehandler->setCallback(NodeCallback);
     669        pCoin->nodehandler->setCallback(MipNodeCallback);
    657670#ifdef NEW_STYLE_CBCMAIN
    658671        if (CoinGetIntOption(hProb, COIN_INT_MIPUSECBCMAIN)) {
     
    665678                if (pCoin->cbc) pCoin->cbc->passInEventHandler(pCoin->nodehandler);
    666679        }
    667         return SOLV_SUCCESS;
     680        return SOLV_CALL_SUCCESS;
    668681}
    669682
     
    855868                        coinSetCbcOptions(hProb);
    856869                        //coinSetCglOptions(hProb);  BK: CbcMain1 should call the Cgl's automatically
    857                         CbcOrClpRead_mode = 1;  // BK: Missing in CbcMain1 (CpcSolver.cpp, stable 2.2), was included in stable 2.1
     870                        CbcOrClpRead_mode = 1;  // BK: Fix bug in CbcMain1, CbcOrClpRead_mode not initialized  (CpcSolver.cpp, stable 2.2)
    858871                        const int argc = 3;
    859872                        const char *argv[] = {"CoinMP", "-solve", "-quit"};
     
    914927
    915928        if (!pCoin->SolveAsMIP)
    916                 return pCoin->clp->objectiveValue();
     929                return pCoin->clp->objectiveValue() + pCoin->ObjectConst;
    917930        else {
    918                 return pCoin->cbc->getObjValue();
     931                return pCoin->cbc->getObjValue() + pCoin->ObjectConst;
    919932        }
    920933}
     
    945958
    946959
    947 SOLVAPI int CoinGetNodeCount(HPROB hProb)
     960SOLVAPI int CoinGetMipNodeCount(HPROB hProb)
    948961{
    949962   PCOIN pCoin = (PCOIN)hProb;
     
    979992                                Activity[i] = columnPrimal[i];
    980993                        }
    981                         return SOLV_SUCCESS;
    982                 }
    983                 return SOLV_FAILED;
     994                        return SOLV_CALL_SUCCESS;
     995                }
     996                return SOLV_CALL_FAILED;
    984997        }
    985998
     
    10081021                }
    10091022        }
    1010         return SOLV_SUCCESS;
     1023        return SOLV_CALL_SUCCESS;
    10111024}
    10121025
     
    10161029                                                                                         double *RhsLoRange, double *RhsUpRange)
    10171030{
    1018         return SOLV_FAILED;
     1031        return SOLV_CALL_FAILED;
    10191032}
    10201033
     
    10231036SOLVAPI int CoinGetSolutionBasis(HPROB hProb, int *ColStatus, double *RowStatus)
    10241037{
    1025         return SOLV_FAILED;
     1038        return SOLV_CALL_FAILED;
    10261039}
    10271040
     
    10451058
    10461059                default:
    1047                         return SOLV_FAILED;
    1048         }
    1049         return SOLV_SUCCESS;
     1060                        return SOLV_CALL_FAILED;
     1061        }
     1062        return SOLV_CALL_SUCCESS;
    10501063}
    10511064
     
    10641077
    10651078                default:
    1066                         return SOLV_FAILED;
    1067 
    1068         }
    1069         return SOLV_SUCCESS;
     1079                        return SOLV_CALL_FAILED;
     1080
     1081        }
     1082        return SOLV_CALL_SUCCESS;
    10701083}
    10711084
     
    10761089        PCOIN pCoin = (PCOIN)hProb;
    10771090
    1078         return SOLV_SUCCESS;
     1091        return SOLV_CALL_SUCCESS;
    10791092}
    10801093
     
    10841097        PCOIN pCoin = (PCOIN)hProb;
    10851098
    1086         return SOLV_SUCCESS;
     1099        return SOLV_CALL_SUCCESS;
    10871100}
    10881101
     
    12631276{
    12641277        if ((OptionNr < 0) && (OptionNr >= OPTIONCOUNT)) {
    1265                 return SOLV_FAILED;
     1278                return SOLV_CALL_FAILED;
    12661279        }
    12671280        if (OptionID)   *OptionID = OptionTable[OptionNr].OptionID;
     
    12691282        if (OptionName) strcpy(OptionName, OptionTable[OptionNr].OptionName);
    12701283        if (ShortName)  strcpy(ShortName, OptionTable[OptionNr].ShortName);
    1271         return SOLV_SUCCESS;
     1284        return SOLV_CALL_SUCCESS;
    12721285}
    12731286
     
    12761289{
    12771290        if ((OptionNr < 0) && (OptionNr >= OPTIONCOUNT)) {
    1278                 return SOLV_FAILED;
     1291                return SOLV_CALL_FAILED;
    12791292        }
    12801293        if (MinValue)   *MinValue = ROUND(OptionTable[OptionNr].MinValue);
    12811294        if (MaxValue)   *MaxValue = ROUND(OptionTable[OptionNr].MaxValue);
    1282         return SOLV_SUCCESS;
     1295        return SOLV_CALL_SUCCESS;
    12831296}
    12841297
     
    12871300{
    12881301        if ((OptionNr < 0) && (OptionNr >= OPTIONCOUNT)) {
    1289                 return SOLV_FAILED;
     1302                return SOLV_CALL_FAILED;
    12901303        }
    12911304        if (MinValue)   *MinValue = OptionTable[OptionNr].MinValue;
    12921305        if (MaxValue)   *MaxValue = OptionTable[OptionNr].MaxValue;
    1293         return SOLV_SUCCESS;
     1306        return SOLV_CALL_SUCCESS;
    12941307}
    12951308
     
    13461359        OptionNr = coinLocateOptionID(OptionID);
    13471360        if (OptionNr < 0) {
    1348                 return SOLV_FAILED;
     1361                return SOLV_CALL_FAILED;
    13491362        }
    13501363        if (OptionTable[OptionNr].OptionType != OPT_REAL) {
     
    13521365                OptionTable[OptionNr].CurrentValue = IntValue;
    13531366                OptionTable[OptionNr].changed = 1;
    1354            return SOLV_SUCCESS;
    1355         }
    1356         return SOLV_FAILED;
     1367           return SOLV_CALL_SUCCESS;
     1368        }
     1369        return SOLV_CALL_FAILED;
    13571370}
    13581371
     
    13831396        OptionNr = coinLocateOptionID(OptionID);
    13841397        if (OptionNr < 0) {
    1385                 return SOLV_FAILED;
     1398                return SOLV_CALL_FAILED;
    13861399        }
    13871400        if (OptionTable[OptionNr].OptionType == OPT_REAL) {
     
    13891402                OptionTable[OptionNr].CurrentValue = RealValue;
    13901403                OptionTable[OptionNr].changed = 1;
    1391            return SOLV_SUCCESS;
    1392         }
    1393         return SOLV_FAILED;
     1404           return SOLV_CALL_SUCCESS;
     1405        }
     1406        return SOLV_CALL_FAILED;
    13941407}
    13951408
     
    14071420   PCOIN pCoin = (PCOIN)hProb;
    14081421
    1409    return SOLV_FAILED;
     1422   return SOLV_CALL_FAILED;
    14101423}
    14111424
  • trunk/CoinMP/src/CoinMP.h

    r95 r113  
    55/*  File         :  'coinmp.h'                                          */
    66/*                                                                      */
    7 /*  Version      :  1.1                                                 */
     7/*  Version      :  1.2                                                 */
    88/*                                                                      */
    99/*  Author       :  Bjarni Kristjansson, Maximal Software               */
     
    3232
    3333
    34 #ifndef SOLVER_LIB
    35 #ifndef SOLVER_DLL
    36 #define SOLVER_LIB
    37 #endif
    38 #endif
    39 
    40 
    41 
    42 #define SOLV_SUCCESS   1
    43 #define SOLV_FAILED    0
    44 
    45 #define OBJSENS_MAX   -1
    46 #define OBJSENS_MIN    1
     34#ifndef SOLV_LINK_LIB
     35#ifndef SOLV_LINK_DLL
     36#define SOLV_LINK_LIB
     37#endif
     38#endif
     39
     40
     41
     42#define SOLV_CALL_SUCCESS   1
     43#define SOLV_CALL_FAILED    0
     44
     45#define SOLV_METHOD_DEFAULT       0x00000000L
     46
     47#define SOLV_METHOD_PRIMAL        0x00000001L
     48#define SOLV_METHOD_DUAL          0x00000002L
     49#define SOLV_METHOD_NETWORK       0x00000004L
     50#define SOLV_METHOD_BARRIER       0x00000008L
     51
     52#define SOLV_METHOD_BENDERS       0x00000100L
     53#define SOLV_METHOD_DEQ           0x00000200L
     54#define SOLV_METHOD_EV            0x00000400L
     55
     56
     57#define SOLV_FEATURE_LP            0x00000001L
     58#define SOLV_FEATURE_QP            0x00000002L
     59#define SOLV_FEATURE_QCP           0x00000004L
     60#define SOLV_FEATURE_NLP           0x00000008L
     61
     62#define SOLV_FEATURE_MIP           0x00000010L
     63#define SOLV_FEATURE_MIQP          0x00000020L
     64#define SOLV_FEATURE_MIQCP         0x00000040L
     65#define SOLV_FEATURE_MINLP         0x00000080L
     66
     67#define SOLV_FEATURE_SP            0x00010000L
     68
     69
     70#define SOLV_OBJSENS_MAX   -1
     71#define SOLV_OBJSENS_MIN    1
     72
     73
     74#define SOLV_FILE_LOG      0
     75#define SOLV_FILE_BASIS    1
     76#define SOLV_FILE_MIPSTART 2
     77#define SOLV_FILE_MPS      3
     78#define SOLV_FILE_LP       4
     79#define SOLV_FILE_BINARY   5
     80#define SOLV_FILE_OUTPUT   6
     81#define SOLV_FILE_BINOUT   7
     82#define SOLV_FILE_IIS      8
    4783
    4884
     
    5692typedef int (*MSGLOGCALLBACK)(char *MessageStr);
    5793
    58 typedef int (*ITERCALLBACK)(int    IterNum,
     94typedef int (*ITERCALLBACK)(int    IterCount,
    5995                                                        double ObjectValue,
    6096                                                        int    IsFeasible,
    6197                                                        double InfeasValue);
    6298
    63 typedef int (*NODECALLBACK)(int    IterNum,
    64                                                         int        MipNodeCount,
    65                                                         double BestBound,
    66                                                         double BestInteger,
    67                                                         int    IsMipImproved);
    68 
    69 
    70 
    71 #ifdef SOLVER_LIB
     99typedef int (*MIPNODECALLBACK)(int    IterCount,
     100                                                           int    MipNodeCount,
     101                                                           double BestBound,
     102                                                           double BestInteger,
     103                                                           int    IsMipImproved);
     104
     105
     106
     107#ifdef SOLV_LINK_LIB
    72108
    73109SOLVAPI int    CoinInitSolver(char *LicenseStr);
     
    78114SOLVAPI double CoinGetVersion(void);
    79115SOLVAPI int    CoinGetFeatures(void);
    80 SOLVAPI double CoinGetRealMax(void);
     116SOLVAPI int    CoinGetMethods(void);
     117SOLVAPI double CoinGetInfinity(void);
    81118
    82119SOLVAPI HPROB  CoinCreateProblem(char *ProblemName);
    83120
    84 SOLVAPI int    CoinLoadProblem(HPROB hProb, int ColCount, int RowCount,
    85                                                         int NonZeroCount,    int RangeCount,
    86                                                         int ObjectSense, double* ObjectCoeffs,
    87                                                         double* RHSValues,  double* RangeValues,
    88                                                         char* RowType, int* MatrixBegin,
    89                                                         int* MatrixCount,   int* MatrixIndex,   
    90                                                         double* MatrixValues, double* LowerBounds, 
    91                                                         double* UpperBounds, double* InitValues,
    92                                                         char** ColNames, char** RowNames);
     121SOLVAPI int    CoinLoadProblem(HPROB hProb,
     122                                                           int ColCount, int RowCount, int NonZeroCount, int RangeCount,
     123                                                           int ObjectSense, double* ObjectCoeffs, double ObjectConst,
     124                                                           double* RHSValues,  double* RangeValues, char* RowType,
     125                                                           int* MatrixBegin, int* MatrixCount,   int* MatrixIndex,   
     126                                                           double* MatrixValues, double* LowerBounds, double* UpperBounds,
     127                                                           double* InitValues, char** ColNames, char** RowNames);
    93128
    94129SOLVAPI int    CoinLoadInteger(HPROB hProb, char* ColumnType);
     
    114149SOLVAPI int    CoinSetMsgLogCallback(HPROB hProb, MSGLOGCALLBACK MsgLogCallback);
    115150SOLVAPI int    CoinSetIterCallback(HPROB hProb, ITERCALLBACK IterCallback);
    116 SOLVAPI int    CoinSetMipNodeCallback(HPROB hProb, NODECALLBACK MipNodeCallback);
     151SOLVAPI int    CoinSetMipNodeCallback(HPROB hProb, MIPNODECALLBACK MipNodeCallback);
    117152
    118153SOLVAPI int    CoinOptimizeProblem(HPROB hProb, int Method);
     
    124159
    125160SOLVAPI int    CoinGetIterCount(HPROB hProb);
    126 SOLVAPI int    CoinGetNodeCount(HPROB hProb);
     161SOLVAPI int    CoinGetMipNodeCount(HPROB hProb);
    127162
    128163SOLVAPI int    CoinGetSolutionValues(HPROB hProb, double* Activity, double* ReducedCost,
     
    160195
    161196
    162 #ifdef SOLVER_DLL
     197#ifdef SOLV_LINK_DLL
    163198
    164199int    (SOLVFUNC *CoinInitSolver)(char *LicenseStr);
     
    169204double (SOLVFUNC *CoinGetVersion)(void);
    170205int    (SOLVFUNC *CoinGetFeatures)(void);
    171 double (SOLVFUNC *CoinGetRealMax)(void);
     206int    (SOLVFUNC *CoinGetMethods)(void);
     207double (SOLVFUNC *CoinGetInfinity)(void);
    172208
    173209HPROB  (SOLVFUNC *CoinCreateProblem)(char *ProblemName);
    174210
    175 int    (SOLVFUNC *CoinLoadProblem)(HPROB hProb, int ColCount, int RowCount,
    176                                                                                           int NonZeroCount, int RangeCount,
    177                                                                                           int ObjectSense, double* ObjectCoeffs,
    178                                                                                           double* RHSValues, double* RangeValues,
    179                                                                                           char* RowType, int* MatrixBegin,
    180                                                                                           int* MatrixCount, int* MatrixIndex,   
    181                                                                                           double* MatrixValues, double* LowerBounds, 
    182                                                                                           double* UpperBounds, double* InitValues,
    183                                                                                           char** ColNames, char** RowNames);
     211int    (SOLVFUNC *CoinLoadProblem)(HPROB hProb,
     212                                                                   int ColCount, int RowCount, int NonZeroCount, int RangeCount,
     213                                                                   int ObjectSense, double* ObjectCoeffs, double ObjectConst,
     214                                                                   double* RHSValues, double* RangeValues, char* RowType,
     215                                                                   int* MatrixBegin, int* MatrixCount, int* MatrixIndex,   
     216                                                                   double* MatrixValues, double* LowerBounds, double* UpperBounds,
     217                                                                   double* InitValues, char** ColNames, char** RowNames);
    184218
    185219int    (SOLVFUNC *CoinLoadInteger)(HPROB hProb, char* ColumnType);
     
    214248
    215249int    (SOLVFUNC *CoinGetIterCount)(HPROB hProb);
    216 int    (SOLVFUNC *CoinGetNodeCount)(HPROB hProb);
     250int    (SOLVFUNC *CoinGetMipNodeCount)(HPROB hProb);
    217251
    218252int    (SOLVFUNC *CoinGetSolutionValues)(HPROB hProb, double* Activity, double* ReducedCost,
     
    252286#endif
    253287
    254 
    255 
    256 
    257 #define SOLV_FILE_MPS    1
    258 #define SOLV_FILE_LP     2
    259 #define SOLV_FILE_BASIS  3
    260 #define SOLV_FILE_IIS    4
    261288
    262289
     
    343370
    344371
    345 #endif
     372#endif  /* _COINMP_H_ */
  • trunk/CoinMP/test/unitTest.cpp

    r96 r113  
    1212
    1313
    14 void GetAndCheckSolution(double optimalValue, double objectConst, HPROB hProb)
     14void GetAndCheckSolution(double optimalValue, HPROB hProb)
    1515{
    1616        int solutionStatus;
     
    2020        solutionStatus = CoinGetSolutionStatus(hProb);
    2121        solutionText = CoinGetSolutionText(hProb,solutionStatus);
    22         objectValue =  CoinGetObjectValue(hProb) + objectConst;
     22        objectValue =  CoinGetObjectValue(hProb);
    2323     
    2424        fprintf(stdout, "\n---------------------------------------\n");
     
    3737
    3838
    39 void RunTestProblem(char *problemName, double optimalValue,
    40           int colCount, int rowCount, int nonZeroCount, int rangeCount, int objectSense,
    41       double *objectCoeffs, double objectConst, double *rhsValues, double *rangeValues, char *columnType,
    42           char *rowType, int *matrixBegin, int *matrixCount, int *matrixIndex, double *matrixValues,
    43           double *lowerBounds, double *upperBounds, double *initValues, char **colNames, char **rowNames)
     39void RunTestProblem(char *problemName, double optimalValue, int colCount, int rowCount,
     40          int nonZeroCount, int rangeCount, int objectSense, double *objectCoeffs, double objectConst,
     41      double *rhsValues, double *rangeValues, char *columnType, char *rowType, int *matrixBegin,
     42          int *matrixCount, int *matrixIndex, double *matrixValues, double *lowerBounds, double *upperBounds,
     43          double *initValues, char **colNames, char **rowNames)
    4444{
    4545    HPROB hProb;
     
    4848    hProb = CoinCreateProblem(problemName); 
    4949    CoinLoadProblem(hProb, colCount, rowCount, nonZeroCount, rangeCount,
    50                                         objectSense, objectCoeffs, rhsValues, rangeValues,
     50                                        objectSense, objectCoeffs, objectConst, rhsValues, rangeValues,
    5151                                        rowType, matrixBegin, matrixCount, matrixIndex, matrixValues,
    5252                                        lowerBounds, upperBounds, initValues, colNames, rowNames );
     
    5555        }
    5656        CoinOptimizeProblem(hProb, 0);
    57         GetAndCheckSolution(optimalValue, objectConst, hProb);
     57        GetAndCheckSolution(optimalValue, hProb);
    5858    CoinUnloadProblem(hProb);
    5959}
     
    8080    int rangeCount = 0;
    8181
    82     int objectSense = OBJSENS_MAX;
     82    int objectSense = SOLV_OBJSENS_MAX;
    8383        double objectConst = 0.0;
    8484    double objectCoeffs[8] = { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 };
     
    101101        double optimalValue = 1428729.2857143;
    102102
    103         RunTestProblem(problemName, optimalValue,
    104           colCount, rowCount, nonZeroCount, rangeCount,
    105       objectSense, objectCoeffs, objectConst, rhsValues, NULL,
    106           NULL, rowType, matrixBegin, matrixCount, matrixIndex,
    107           matrixValues, lowerBounds, upperBounds, initValues,
    108           colNames, rowNames);
     103        RunTestProblem(problemName, optimalValue, colCount, rowCount,
     104          nonZeroCount, rangeCount, objectSense, objectCoeffs, objectConst,
     105      rhsValues, NULL, NULL, rowType, matrixBegin, matrixCount,
     106          matrixIndex, matrixValues, lowerBounds, upperBounds,
     107          initValues, colNames, rowNames);
    109108}
    110109
     
    118117    int rangeCount = 0;
    119118
    120         int objectSense = OBJSENS_MAX;
     119        int objectSense = SOLV_OBJSENS_MAX;
    121120        double objectConst = - 4000.0 / 30.0;
    122121    double objectCoeffs[2] = { 0.05 , 0.08 };
     
    137136        double optimalValue = 506.66666667;
    138137
    139         RunTestProblem(problemName, optimalValue,
    140           colCount, rowCount, nonZeroCount, rangeCount, objectSense,
    141       objectCoeffs, objectConst, rhsValues, NULL, NULL, rowType,
    142       matrixBegin, matrixCount, matrixIndex, matrixValues,
    143           lowerBounds, upperBounds, NULL, colNames, rowNames);
     138        RunTestProblem(problemName, optimalValue, colCount, rowCount,
     139          nonZeroCount, rangeCount, objectSense, objectCoeffs, objectConst,
     140      rhsValues, NULL, NULL, rowType, matrixBegin, matrixCount,
     141      matrixIndex, matrixValues, lowerBounds, upperBounds,
     142          NULL, colNames, rowNames);
    144143}
    145144
     
    153152        int nrng = 0;
    154153
    155         int objsens = OBJSENS_MIN;
     154        int objsens = SOLV_OBJSENS_MIN;
    156155
    157156        double objconst = 0.0;
     
    204203        double optimalValue = -464.753142857;
    205204
    206         RunTestProblem(probname, optimalValue,
    207           ncol, nrow, nels, nrng, objsens, dobj, objconst, drhs, NULL,
    208       NULL, rtyp, mbeg, mcnt, midx, mval, dclo, dcup,
    209           NULL, colname, rowname);
     205        RunTestProblem(probname, optimalValue, ncol, nrow, nels, nrng,
     206          objsens, dobj, objconst, drhs, NULL, NULL, rtyp, mbeg, mcnt,
     207      midx, mval, dclo, dcup, NULL, colname, rowname);
    210208}
    211209
     
    219217        int nrng = 0;
    220218
    221         int objsens = OBJSENS_MIN;
     219        int objsens = SOLV_OBJSENS_MIN;
    222220
    223221        double objconst = 0.0;
     
    274272        double optimalValue = 3089.0;
    275273
    276         RunTestProblem(probname, optimalValue,
    277           ncol, nrow, nels, nrng, objsens, dobj, objconst, drhs, NULL,
    278       ctyp, rtyp, mbeg, mcnt, midx, mval, dclo, dcup,
    279           NULL, colname, rowname);
     274        RunTestProblem(probname, optimalValue, ncol, nrow, nels, nrng,
     275          objsens, dobj, objconst, drhs, NULL, ctyp, rtyp, mbeg, mcnt,
     276      midx, mval, dclo, dcup, NULL, colname, rowname);
    280277}
    281278
     
    289286        int nrng = 2;
    290287       
    291         int objsens = OBJSENS_MIN;
     288        int objsens = SOLV_OBJSENS_MIN;
    292289        double objconst = 0.0;
    293290        double dobj[8]={1, 0, 0, 0, 2, 0, 0, -1};
     
    313310        double optimalValue = 3.23684210526;
    314311
    315         RunTestProblem(probname, optimalValue,
    316           ncol, nrow, nels, nrng, objsens, dobj, objconst, drhs, drng,
    317       ctyp, rtyp, mbeg, mcnt, midx, mval, dclo, dcup,
    318           NULL, colname, rowname);
     312        RunTestProblem(probname, optimalValue, ncol, nrow, nels, nrng,
     313          objsens, dobj, objconst, drhs, drng, ctyp, rtyp, mbeg, mcnt,
     314      midx, mval, dclo, dcup, NULL, colname, rowname);
    319315}
    320316
     
    329325        SolveProblemP0033();
    330326        SolveProblemExmip1();
    331         fprintf(stdout, "All tests completed successfully\n" );
     327        fprintf(stdout, "All unit tests completed successfully\n" );
    332328    CoinFreeSolver();
    333329        return 0;
  • trunk/configure.ac

    r101 r113  
    1313AC_PREREQ(2.59)
    1414
    15 AC_INIT([CoinMP],[1.1],[coin-discuss@list.coin-or.org])
     15AC_INIT([CoinMP],[1.2],[coin-discuss@list.coin-or.org])
    1616
    1717AC_COPYRIGHT([
Note: See TracChangeset for help on using the changeset viewer.