Changeset 171 for trunk/CoinMP/test


Ignore:
Timestamp:
Sep 30, 2008 3:28:54 PM (11 years ago)
Author:
bjarni
Message:

Updated to test new CoinMP API interface plus 2 new Sos tests

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/CoinMP/test/unitTest.cpp

    r161 r171  
    1111
    1212
     13int SOLVCALL MsgLogCallback(char *MessageStr)
     14{
     15        fprintf(stdout, "%s", MessageStr);
     16        return 0;
     17}
     18
     19int SOLVCALL IterCallback(int    IterCount,
     20                        double ObjectValue,
     21                        int    IsFeasible,
     22                        double InfeasValue)
     23{
     24        fprintf(stdout, "ITER: iter=%d, obj=%lg, feas=%d, infeas=%lg\n",
     25                IterCount, ObjectValue, IsFeasible, InfeasValue);
     26        return 0;
     27}
     28
     29int SOLVCALL MipNodeCallback(int    IterCount,
     30                                int       MipNodeCount,
     31                                double BestBound,
     32                                double BestInteger,
     33                                int    IsMipImproved)
     34{
     35        fprintf(stdout, "NODE: iter=%d, node=%d, bound=%lg, best=%lg, improved=%int\n",
     36                IterCount, MipNodeCount, BestBound, BestInteger, IsMipImproved);
     37        return 0;
     38}
     39
    1340
    1441void GetAndCheckSolution(double optimalValue, HPROB hProb)
     
    1744        char solutionText[200];
    1845        double objectValue;
    19 
     46        int i;
     47        int colCount;
     48        double *xVal;
     49        char ColName[100];
     50        char problemName[200];
     51
     52        CoinGetProblemName(hProb, problemName);
    2053        solutionStatus = CoinGetSolutionStatus(hProb);
    2154        CoinGetSolutionText(hProb,solutionStatus, solutionText);
     
    2356     
    2457        fprintf(stdout, "\n---------------------------------------\n");
     58        fprintf(stdout, "Problem Name:    %s\n", problemName);
    2559        fprintf(stdout, "Solution Result: %s\n", solutionText );
    2660        fprintf(stdout, "Solution Status: %d\n", solutionStatus);
    27         fprintf(stdout, "Solution Value: %lg\n", objectValue);
    28      
     61        fprintf(stdout, "Optimal Value:   %lg\n", objectValue);
     62        fprintf(stdout, "---------------------------------------\n");
     63     
    2964        assert(solutionStatus==0);
    3065        assert(strcmp(solutionText,"Optimal solution found")==0);
     
    3267                assert( fabs(objectValue-optimalValue) < 0.001 );
    3368        }
     69        colCount = CoinGetColCount(hProb);
     70        xVal = (double *)malloc(colCount * sizeof(double));
     71        CoinGetSolutionValues(hProb, xVal, NULL, NULL, NULL);
     72        for (i = 0; i < colCount; i++) {
     73                if (xVal[i] != 0.0) {
     74                        CoinGetColName(hProb, i, ColName);
     75                        fprintf(stdout, "%s = %lg\n", ColName, xVal[i]);
     76                }
     77        }
    3478        fprintf(stdout, "---------------------------------------\n\n");
    3579}
     
    3882
    3983void 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, char *objectName)
     84          int nonZeroCount, int rangeCount, int objectSense, double objectConst, double *objectCoeffs,
     85          double *lowerBounds, double *upperBounds, char *rowType, double *rhsValues, double *rangeValues,
     86          int *matrixBegin, int *matrixCount, int *matrixIndex, double *matrixValues,
     87          char *colNames, char *rowNames, char *objectName, double *initValues, char *columnType)
    4488{
    4589        HPROB hProb;
     90        int result;
     91        char filename[260];
    4692   
    4793        fprintf(stdout, "Solve Problem: %s\n", problemName);
    4894        hProb = CoinCreateProblem(problemName); 
    49         CoinLoadProblem(hProb, colCount, rowCount, nonZeroCount, rangeCount,
    50                                         objectSense, objectCoeffs, objectConst, rhsValues, rangeValues,
    51                                         rowType, matrixBegin, matrixCount, matrixIndex, matrixValues,
    52                                         lowerBounds, upperBounds, initValues, colNames, rowNames, objectName);
     95        result = CoinLoadProblem(hProb, colCount, rowCount, nonZeroCount, rangeCount,
     96                                        objectSense, objectConst, objectCoeffs, lowerBounds, upperBounds,
     97                                        rowType, rhsValues, rangeValues, matrixBegin, matrixCount,
     98                                        matrixIndex, matrixValues, colNames, rowNames, objectName);
    5399        if (columnType) {
    54                 CoinLoadInteger(hProb, columnType);
    55         }
    56         CoinOptimizeProblem(hProb, 0);
     100                result = CoinLoadInteger(hProb, columnType);
     101        }
     102        result = CoinCheckProblem(hProb);
     103        if (result != SOLV_CALL_SUCCESS) {
     104                fprintf(stdout, "Check Problem failed (result = %d)\n", result);
     105        }
     106        //result = CoinSetMsgLogCallback(hProb, &MsgLogCallback);
     107        if (!columnType)
     108                result = CoinSetIterCallback(hProb, &IterCallback);
     109        else {
     110                result = CoinSetMipNodeCallback(hProb, &MipNodeCallback);
     111        }
     112        result = CoinOptimizeProblem(hProb, 0);
     113        sprintf(filename, "%s.mps", problemName);
     114        result = CoinWriteFile(hProb, SOLV_FILE_MPS, filename);
     115        GetAndCheckSolution(optimalValue, hProb);
     116        CoinUnloadProblem(hProb);
     117}
     118
     119
     120void RunSosTestProblem(char *problemName, double optimalValue, int colCount, int rowCount,
     121          int nonZeroCount, int rangeCount, int objectSense, double objectConst, double *objectCoeffs,
     122          double *lowerBounds, double *upperBounds, char *rowType, double *rhsValues, double *rangeValues,
     123          int *matrixBegin, int *matrixCount, int *matrixIndex, double *matrixValues,
     124          char *colNames, char *rowNames, char *objectName, double *initValues, char *columnType,
     125          int sosCount, int sosNZCount, int *sosType, int *sosPrior, int *sosBegin, int *sosIndex, double *sosRef)
     126{
     127        HPROB hProb;
     128        int result;
     129        char filename[260];
     130   
     131        fprintf(stdout, "Solve Problem: %s\n", problemName);
     132        hProb = CoinCreateProblem(problemName); 
     133        result = CoinLoadProblem(hProb, colCount, rowCount, nonZeroCount, rangeCount,
     134                                        objectSense, objectConst, objectCoeffs, lowerBounds, upperBounds,
     135                                        rowType, rhsValues, rangeValues, matrixBegin, matrixCount,
     136                                        matrixIndex, matrixValues, colNames, rowNames, objectName);
     137        if (columnType) {
     138                result = CoinLoadInteger(hProb, columnType);
     139        }
     140        result = CoinLoadSos(hProb, sosCount, sosNZCount, sosType, sosPrior, sosBegin, sosIndex, sosRef);
     141        result = CoinCheckProblem(hProb);
     142        if (result != SOLV_CALL_SUCCESS) {
     143                fprintf(stdout, "Check Problem failed (result = %d)\n", result);
     144        }
     145        //result = CoinSetMsgLogCallback(hProb, &MsgLogCallback);
     146        if (!columnType)
     147                result = CoinSetIterCallback(hProb, &IterCallback);
     148        else {
     149                result = CoinSetMipNodeCallback(hProb, &MipNodeCallback);
     150        }
     151        sprintf(filename, "e:\\vb\\CoinMP\\unitTest\\%s.mps", problemName);
     152        result = CoinWriteFile(hProb, SOLV_FILE_MPS, filename);
     153        result = CoinOptimizeProblem(hProb, 0);
    57154        GetAndCheckSolution(optimalValue, hProb);
    58155        CoinUnloadProblem(hProb);
     
    85182        double objectCoeffs[8] = { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 };
    86183
     184        double lowerBounds[8] = { 0., 0., 0., 0., 0., 0., 0.  };
     185        double upperBounds[8] = { 1000000., 1000000., 1000000., 1000000., 1000000., 1000000., 1000000., 1000000.   };
     186
     187        char rowType[5] = { 'L', 'L', 'L', 'L', 'L' };
    87188        double rhsValues[5] = { 14., 80., 50., 50., 50. };
    88         char rowType[5] = { 'L', 'L', 'L', 'L', 'L' };
    89189
    90190        int matrixBegin[8+1]={0,2,4,6,8,10,11,12,14};
     
    93193        double matrixValues[14]={3., 5.6, 1., 2., 1.1, 1., -2., 2.8, -1., 1., 1., -1.2, -1., 1.9};
    94194   
    95         double lowerBounds[8] = { 0., 0., 0., 0., 0., 0., 0.  };
    96         double upperBounds[8] = { 1000000., 1000000., 1000000., 1000000., 1000000., 1000000., 1000000.   };
    97 
    98         double initValues[8] = { 0., 0., 0., 0., 0., 0., 0., 0.  };
    99 
     195        //char *colNames[8] = {"c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8"};
    100196        char *colNames = "c1\0" "c2\0" "c3\0" "c4\0" "c5\0" "c6\0" "c7\0" "c8";
    101197        char *rowNames = "r1\0" "r2\0" "r3\0" "r4\0" "r5";
    102198   
     199        double initValues[8] = { 0., 0., 0., 0., 0., 0., 0., 0.  };
     200
    103201        double optimalValue = 1428729.2857143;
    104202
    105203        RunTestProblem(problemName, optimalValue, colCount, rowCount,
    106           nonZeroCount, rangeCount, objectSense, objectCoeffs, objectConst,
    107           rhsValues, NULL, NULL, rowType, matrixBegin, matrixCount,
    108           matrixIndex, matrixValues, lowerBounds, upperBounds,
    109           initValues, colNames, rowNames, objectName);
     204          nonZeroCount, rangeCount, objectSense, objectConst, objectCoeffs,
     205          lowerBounds, upperBounds, rowType, rhsValues, NULL,
     206          matrixBegin, matrixCount, matrixIndex, matrixValues,
     207          colNames, rowNames, objectName, initValues, NULL);
    110208}
    111209
     
    124222        double objectCoeffs[2] = { 0.05 , 0.08 };
    125223
     224        double lowerBounds[2] = { 0, 0  };
     225        double upperBounds[2] = { 1000000, 1000000   };
     226   
     227        char rowType[3] = { 'L', 'L' , 'L' };
    126228        double rhsValues[3] = { 1400 , 8000 , 5000 };
    127         char rowType[3] = { 'L', 'L' , 'L' };
    128229
    129230        int matrixBegin[2+1] = { 0 , 2, 4 };
     
    132233        double matrixValues[4] = { 0.1, 1, 0.2, 1};
    133234
    134         double lowerBounds[2] = { 0, 0  };
    135         double upperBounds[2] = { 1000000, 1000000   };
    136    
     235        //char *colNames[2] = {"Sun", "Moon"};
    137236        char *colNames = "Sun\0" "Moon";
    138237        char *rowNames = "c1\0" "c2\0" "c3";
     
    141240
    142241        RunTestProblem(problemName, optimalValue, colCount, rowCount,
    143           nonZeroCount, rangeCount, objectSense, objectCoeffs, objectConst,
    144           rhsValues, NULL, NULL, rowType, matrixBegin, matrixCount,
    145           matrixIndex, matrixValues, lowerBounds, upperBounds,
    146           NULL, colNames, rowNames, objectName);
     242          nonZeroCount, rangeCount, objectSense, objectConst, objectCoeffs,
     243          lowerBounds, upperBounds, rowType, rhsValues, NULL,
     244          matrixBegin, matrixCount, matrixIndex, matrixValues,
     245          colNames, rowNames, objectName, NULL, NULL);
    147246}
    148247
     
    156255        int nrng = 0;
    157256
    158         char *objectname = "COST";
     257        char *objectname = "Cost";
    159258        int objsens = SOLV_OBJSENS_MIN;
    160259        double objconst = 0.0;
     
    163262                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0.48, 0, 0, 10};
    164263
     264        double dclo[32]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     265                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     266
     267        double dcup[32]={1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037,
     268                1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037,
     269                1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037,
     270                1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037};
     271
     272        char rtyp[27]= {'E', 'E', 'L', 'L', 'E', 'E', 'L', 'L', 'L', 'L', 'E', 'E', 'L',
     273                'L', 'E', 'E', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L'};
     274
    165275        double drhs[27]={0, 0, 80, 0, 0, 0, 80, 0, 0, 0, 0, 0, 500, 0, 0, 44, 500, 0,
    166276                0, 0, 0, 0, 0, 0, 0, 310, 300};
    167 
    168         char rtyp[27]= {'E', 'E', 'L', 'L', 'E', 'E', 'L', 'L', 'L', 'L', 'E', 'E', 'L',
    169                 'L', 'E', 'E', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L'};
    170277
    171278        int mbeg[32+1]={0, 4, 6, 8, 10, 14, 18, 22, 26, 28, 30, 32, 34, 36, 38, 40,
     
    188295                -1, 1, -1, 1, 1, 1};
    189296
    190         double dclo[32]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    191                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    192 
    193         double dcup[32]={1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037,
    194                 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037,
    195                 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037,
    196                 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037};
    197 
    198         char *colnames = "X01\0" "X02\0" "X03\0" "X04\0" "X06\0" "X07\0" "X08\0" "X09\0"
    199                 "X10\0" "X11\0" "X12\0" "X13\0" "X14\0" "X15\0" "X16\0" "X22\0" "X23\0" "X24\0" "X25\0"
    200                 "X26\0" "X28\0" "X29\0" "X30\0" "X31\0" "X32\0" "X33\0" "X34\0" "X35\0" "X36\0" "X37\0"
    201                 "X38\0" "X39";
    202 
    203         char *rownames = "R09\0" "R10\0" "X05\0" "X21\0" "R12\0" "R13\0" "X17\0" "X18\0"
    204                 "X19\0" "X20\0" "R19\0" "R20\0" "X27\0" "X44\0" "R22\0" "R23\0" "X40\0" "X41\0" "X42\0"
    205                 "X43\0" "X45\0" "X46\0" "X47\0" "X48\0" "X49\0" "X50\0" "X51";
     297        /*char *colnames[32] = {"x01", "x02", "x03", "x04", "x06", "x07", "x08", "x09",
     298                "x10", "x11", "x12", "x13", "x14", "x15", "x16", "x22", "x23", "x24", "x25",
     299                "x26", "x28", "x29", "x30", "x31", "x32", "x33", "x34", "x35", "x36", "x37",
     300                "x38", "x39"};*/
     301
     302        char *colnames = "x01\0" "x02\0" "x03\0" "x04\0" "x06\0" "x07\0" "x08\0" "x09\0"
     303                "x10\0" "x11\0" "x12\0" "x13\0" "x14\0" "x15\0" "x16\0" "x22\0" "x23\0" "x24\0" "x25\0"
     304                "x26\0" "x28\0" "x29\0" "x30\0" "x31\0" "x32\0" "x33\0" "x34\0" "x35\0" "x36\0" "x37\0"
     305                "x38\0" "x39";
     306
     307        char *rownames = "r09\0" "r10\0" "x05\0" "x21\0" "r12\0" "r13\0" "x17\0" "x18\0"
     308                "x19\0" "x20\0" "r19\0" "r20\0" "x27\0" "x44\0" "r22\0" "r23\0" "x40\0" "x41\0" "x42\0"
     309                "x43\0" "x45\0" "x46\0" "x47\0" "x48\0" "x49\0" "x50\0" "x51";
    206310
    207311        double optimalValue = -464.753142857;
    208312
    209313        RunTestProblem(probname, optimalValue, ncol, nrow, nels, nrng,
    210           objsens, dobj, objconst, drhs, NULL, NULL, rtyp, mbeg, mcnt,
    211           midx, mval, dclo, dcup, NULL, colnames, rownames, objectname);
     314          objsens, objconst, dobj, dclo, dcup, rtyp, drhs, NULL, mbeg,
     315          mcnt, midx, mval, colnames, rownames, objectname, NULL, NULL);
    212316}
    213317
     
    221325        int nrng = 0;
    222326
    223         char *objectname = "OBJ";
     327        char *objectname = "Obj";
    224328        int objsens = SOLV_OBJSENS_MIN;
    225329        double objconst = 0.0;
     
    229333                318, 114, 228, 159, 318};
    230334
     335        double dclo[33]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     336                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
     337
     338        double dcup[33]={1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
     339                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
     340
     341        char rtyp[15]= { 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L' };
     342
    231343        double drhs[15]={1, 1, 1, 1, -5, 2700, -2600, -100, -900, -1656, -335, -1026,
    232344                -5, -500, -270};
    233345
    234         char rtyp[15]= { 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L' };
    235 
    236346        int mbeg[33+1]={0, 3, 6, 10, 14, 19, 24, 26, 31, 36, 38, 41, 45, 49, 53, 54,
    237347                55, 56, 58, 60, 61, 62, 66, 70, 73, 76, 80, 84, 87, 90, 93, 96, 97, 98};
     
    241351
    242352        int midx[98]={0, 8, 9, 0, 12, 13, 0, 5, 6, 9, 0, 5, 6, 7, 1, 5, 6, 10, 11, 1,
    243                 5, 6, 8, 9, 1, 14, 2, 5, 6, 10, 11, 2, 5, 6, 8, 9, 3, 4, 3, 10, 11, 3, 5, 6, 
     353                5, 6, 8, 9, 1, 14, 2, 5, 6, 10, 11, 2, 5, 6, 8, 9, 3, 4, 3, 10, 11, 3, 5, 6,
    244354                11, 3, 5, 6, 9, 5, 6, 8, 9, 3, 4, 4, 12, 13, 12, 13, 13, 13, 5, 6, 10, 11, 5,
    245355                6, 10, 11, 5, 6, 11, 5, 6, 11, 5, 6, 8, 9, 5, 6, 8, 9, 5, 6, 9, 5, 6, 9, 5, 6,
     
    247357
    248358        double mval[98]={1, -300, -300, 1, -300, -300, 1, 300, -300, -300, 1, 300,
    249                 -300, -300, 1, 285, -285, -285, -285, 1, 285, -285, -285, -285, 1, -285, 1, 
     359                -300, -300, 1, 285, -285, -285, -285, 1, 285, -285, -285, -285, 1, -285, 1,
    250360                265, -265, -265, -265, 1, 265, -265, -265, -265, 1, -230, 1, -230, -230, 1,
    251361                230, -230, -230, 1, 230, -230, -230, 190, -190, -190, -190, 1, -200, -400,
    252                 -200, -200, -400, -400, -200, -400, 200, -200, -200, -200, 400, -400, -400, 
     362                -200, -200, -400, -400, -200, -400, 200, -200, -200, -200, 400, -400, -400,
    253363                -400, 200, -200, -200, 400, -400, -400, 200, -200, -200, -200, 400, -400,
    254364                -400, -400, 200, -200, -200, 400, -400, -400, 200, -200, -200, 400, -400,
    255365                -400, -200, -400};
    256366
    257         double dclo[33]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    258                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    259 
    260         double dcup[33]={1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    261                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
    262 
    263         char *colnames = "C157\0" "C158\0" "C159\0" "C160\0" "C161\0" "C162\0" "C163\0"
    264                 "C164\0" "C165\0" "C166\0" "C167\0" "C168\0" "C169\0" "C170\0" "C171\0" "C172\0"
    265                 "C173\0" "C174\0" "C175\0" "C176\0" "C177\0" "C178\0" "C179\0" "C180\0" "C181\0"
    266                 "C182\0" "C183\0" "C184\0" "C185\0" "C186\0" "C187\0" "C188\0" "C189";
    267 
    268         char *rownames = "R114\0" "R115\0" "R116\0" "R117\0" "R118\0" "R119\0" "R120\0"
    269                 "R121\0" "R122\0" "R123\0" "R124\0" "R125\0" "R126\0" "R127\0" "R128";
     367        /*char *colnames[33] = {"c157", "c158", "c159", "c160", "c161", "c162", "c163",
     368                "c164", "c165", "c166", "c167", "c168", "c169", "c170", "c171", "c172",
     369                "c173", "c174", "c175", "c176", "c177", "c178", "c179", "c180", "c181",
     370                "c182", "c183", "c184", "c185", "c186", "c187", "c188", "c189"};*/
     371
     372        char *colnames = "c157\0" "c158\0" "c159\0" "c160\0" "c161\0" "c162\0" "c163\0"
     373                "c164\0" "c165\0" "c166\0" "c167\0" "c168\0" "c169\0" "c170\0" "c171\0" "c172\0"
     374                "c173\0" "c174\0" "c175\0" "c176\0" "c177\0" "c178\0" "c179\0" "c180\0" "c181\0"
     375                "c182\0" "c183\0" "c184\0" "c185\0" "c186\0" "c187\0" "c188\0" "c189";
     376
     377        char *rownames = "r114\0" "r115\0" "r116\0" "r117\0" "r118\0" "r119\0" "r120\0"
     378                "r121\0" "r122\0" "r123\0" "r124\0" "r125\0" "r126\0" "r127\0" "r128";
    270379
    271380        char ctyp[33] = { 'B', 'B', 'B', 'B', 'B', 'B', 'B',
     
    277386
    278387        RunTestProblem(probname, optimalValue, ncol, nrow, nels, nrng,
    279           objsens, dobj, objconst, drhs, NULL, ctyp, rtyp, mbeg, mcnt,
    280           midx, mval, dclo, dcup, NULL, colnames, rownames, objectname);
     388          objsens, objconst, dobj, dclo, dcup, rtyp, drhs, NULL, mbeg,
     389          mcnt, midx, mval, colnames, rownames, objectname, NULL, ctyp);
    281390}
    282391
     
    295404        double dobj[8]={1, 0, 0, 0, 2, 0, 0, -1};
    296405
     406        double dclo[8]={2.5, 0, 0, 0, 0.5, 0, 0, 0};
     407        double dcup[8]={1e+037, 4.1, 1e+037, 1e+037, 4, 1e+037, 1e+037, 4.3};
     408
     409        char rtyp[5]= {'G', 'L', 'E', 'G', 'L'};
    297410        double drhs[5]={2.5, 2.1, 4, 1.8, 15};
    298411        double drng[5]={0, 0, 0, -3.2, 12};
    299         char rtyp[5]= {'G', 'L', 'E', 'G', 'L'};
    300412
    301413        int mbeg[8+1]={0, 2, 4, 6, 8, 10, 11, 12, 14};
     
    304416        double mval[14]={3, 5.6, 1, 2, 1.1, 1, -2, 2.8, -1, 1, 1, -1.2, -1, 1.9};
    305417
    306         double dclo[8]={2.5, 0, 0, 0, 0.5, 0, 0, 0};
    307         double dcup[8]={1e+037, 4.1, 1e+037, 1e+037, 4, 1e+037, 1e+037, 4.3};
    308 
    309         char *colnames = "COL01\0" "COL02\0" "COL03\0" "COL04\0" "COL05\0" "COL06\0"
    310                 "COL07\0" "COL08";
    311         char *rownames = "ROW01\0" "ROW02\0" "ROW03\0" "ROW04\0" "ROW05";
     418        /*char *colnames[8] = {"col01", "col02", "col03", "col04", "col05", "col06",
     419                "col07", "col08"};*/
     420        char *colnames = "col01\0" "col02\0" "col03\0" "col04\0" "col05\0" "col06\0"
     421                "col07\0" "col08";
     422        char *rownames = "row01\0" "row02\0" "row03\0" "row04\0" "row05";
    312423
    313424        char ctyp[8] = { 'C', 'C', 'B', 'B', 'C', 'C', 'C', 'C'};
     
    316427
    317428        RunTestProblem(probname, optimalValue, ncol, nrow, nels, nrng,
    318           objsens, dobj, objconst, drhs, drng, ctyp, rtyp, mbeg, mcnt,
    319           midx, mval, dclo, dcup, NULL, colnames, rownames, objectname);
     429          objsens, objconst, dobj, dclo, dcup, rtyp, drhs, drng, mbeg,
     430          mcnt, midx, mval, colnames, rownames, objectname, NULL, ctyp);
     431}
     432
     433/*
     434
     435void SolveProblemLPSos1(void)
     436{
     437        char *probname = "LPSolveSos1";
     438        int ncol = 5;
     439        int nrow = 5;
     440        int nels = 11;
     441        int nrng = 0;
     442       
     443        char *objectname = "z";
     444        int objsens = SOLV_OBJSENS_MAX;
     445        double objconst = 0.0;
     446        double dobj[5]={1, 1, 3, 2, 2};
     447
     448        double dclo[5]={0, 0, 0, 0, 0};
     449        double dcup[5]={1e+037, 1e+037,  1e+037, 1e+037, 1e+037};
     450
     451        char rtyp[5]= {'L', 'L', 'L', 'L', 'L'};
     452        double drhs[5]={30, 30, 40, 1, 1};
     453
     454        int mbeg[5+1]={0, 3, 5, 7, 9, 10};
     455        int mcnt[5]={3, 2, 2, 2, 1};
     456        int midx[11]={    0,1,2,  0,3,  0,1,  0,1,  4, 0};
     457        double mval[11]={-1,1,1, -1,1, 1,1,  1,-3, 1, 1};
     458
     459        //char *colnames[5] = {"x1", "x2", "x3", "x4", "x5"};
     460        char *colnames = "x1\0" "x2\0" "x3\0" "x4\0" "x5";
     461        char *rownames = "c1\0" "c2\0" "c3\0" "c4\0" "c5";
     462
     463        int sosCount = 1;
     464        int sosNZCount = 5;
     465        int sosType[1] = {1};
     466        int sosBegin[1+1] = {0, 5};
     467        int sosIndex[5] = {0, 1, 2, 3, 4};
     468
     469        double optimalValue = 90.0;
     470
     471        RunSosTestProblem(probname, optimalValue, ncol, nrow, nels, nrng,
     472          objsens, objconst, dobj, dclo, dcup, rtyp, drhs, NULL, mbeg,
     473          mcnt, midx, mval, colnames, rownames, objectname, NULL, NULL,
     474          sosCount, sosNZCount, sosType, NULL, sosBegin, sosIndex, NULL);
     475}
     476*/
     477/*
     478        char *objectname = "z";
     479        int objsens = SOLV_OBJSENS_MAX;
     480        double objconst = 0.0;
     481        double dobj[5]={1, 1, 3, 2, 2};
     482
     483        double dclo[5]={0, 0, 0, 0, 0};
     484        double dcup[5]={40, 1, 1e+037, 1e+037, 1};
     485
     486        char rtyp[2]= {'L', 'L'};
     487        double drhs[2]={30, 30};
     488
     489        int mbeg[5+1]={0, 2, 3, 5, 7, 7};
     490        int mcnt[8]={2, 1, 2, 2, 0};
     491        int midx[14]={0, 1, 0, 0, 1, 0, 1};
     492        double mval[14]={-1, 1, -1, 1, 1, 1, -3};
     493
     494        char *colnames = "x1\0" "x2\0" "x3\0" "x4\0" "x5";
     495        char *rownames = "c1\0" "c2";
     496
     497        int sosCount = 1;
     498        int sosNZCount = 5;
     499        int sosType[1] = {1};
     500        int sosBegin[1+1] = {0, 5};
     501        int sosIndex[5] = {0, 1, 2, 3, 4};
     502
     503*/
     504
     505void SolveProblemGamsSos1a(void)
     506{
     507        char *probname = "GamsSos1a";
     508        int ncol = 3;
     509        int nrow = 1;
     510        int nels = 3;
     511        int nrng = 0;
     512       
     513        char *objectname = "z";
     514        int objsens = SOLV_OBJSENS_MAX;
     515        double objconst = 0.0;
     516        double dobj[3]={0.9, 1.0, 1.1};
     517
     518        double dclo[3]={0, 0, 0};
     519        double dcup[3]={0.8, 0.6, 0.6};
     520
     521        char rtyp[1]= {'R'};
     522        double drhs[1]={1.0};
     523        double drange[1]={1e+37};
     524
     525        int mbeg[3+1]={0, 1, 2, 3};
     526        int mcnt[3]={1, 1, 1};
     527        int midx[3]={0, 0, 0};
     528        double mval[3]={1, 1, 1};
     529
     530        //char *colnames[3] = {"x1", "x2", "x3"};
     531        char *colnames = "x1\0" "x2\0" "x3";
     532        char *rownames = "xsum";
     533
     534        int sosCount = 1;
     535        int sosNZCount = 3;
     536        int sosType[1] = {1};
     537        int sosBegin[1+1] = {0, 3};
     538        int sosIndex[3] = {0, 1, 2};
     539
     540        double optimalValue = 0.72;
     541
     542        RunSosTestProblem(probname, optimalValue, ncol, nrow, nels, nrng,
     543          objsens, objconst, dobj, dclo, dcup, rtyp, drhs, drange, mbeg,
     544          mcnt, midx, mval, colnames, rownames, objectname, NULL, NULL,
     545          sosCount, sosNZCount, sosType, NULL, sosBegin, sosIndex, NULL);
     546}
     547
     548
     549void SolveProblemGamsSos2a(void)
     550{
     551        char *probname = "GamsSos2a";
     552        int ncol = 7;
     553        int nrow = 5;
     554        int nels = 15;
     555        int nrng = 0;
     556       
     557        char *objectname = "z";
     558        int objsens = SOLV_OBJSENS_MIN;
     559        double objconst = 0.0;
     560        double dobj[7]={0, 0, 0, 0, 0, 1, 1};
     561
     562        double dclo[7]={0.0, 0, 0, -1e+37, -1e+37, 0, 0};
     563        double dcup[7]={1e+37, 1e+37, 1e+37, 1e+37, 1e+37, 1e+37, 1e+37};
     564
     565        char rtyp[5]= {'E', 'E', 'E', 'G', 'G'};
     566        double drhs[5]={1, 0, 0, -1.3, 1.3};
     567
     568        int mbeg[7+1]={0, 3, 6, 9, 10, 13, 14, 15};
     569        int mcnt[7]={3, 3, 3, 1, 3, 1, 1};
     570        int midx[15]={0, 1, 2, 0, 1, 2, 0, 1, 2, 1, 2, 3, 4, 3, 4};
     571        double mval[15]={1, 1, 1, 1, 2, 2, 1, 3, 3, -1, -1, -1, 1, 1, 1};
     572
     573        //char *colnames[7] = {"w1", "w2", "w3", "x", "fx", "fplus", "fminus"};
     574        char *colnames = "w1\0" "w2\0" "w3\0" "x\0" "fx\0" "fplus\0" "fminus";
     575        char *rownames = "wsum\0" "xdef\0" "fxdef\0" "gapplus\0" "gapminus";
     576
     577        int sosCount = 1;
     578        int sosNZCount = 3;
     579        int sosType[1] = {2};
     580        int sosBegin[1+1] = {0, 3};
     581        int sosIndex[3] = {0, 1, 2};
     582
     583        double optimalValue = 0.0;
     584
     585        RunSosTestProblem(probname, optimalValue, ncol, nrow, nels, nrng,
     586          objsens, objconst, dobj, dclo, dcup, rtyp, drhs, NULL, mbeg,
     587          mcnt, midx, mval, colnames, rownames, objectname, NULL, NULL,
     588          sosCount, sosNZCount, sosType, NULL, sosBegin, sosIndex, NULL);
    320589}
    321590
     
    336605        SolveProblemP0033();
    337606        SolveProblemExmip1();
     607        SolveProblemGamsSos1a();
     608        SolveProblemGamsSos2a();
     609        //SolveProblemLPSos1();
    338610        fprintf(stdout, "All unit tests completed successfully\n" );
    339611        CoinFreeSolver();
Note: See TracChangeset for help on using the changeset viewer.