source: stable/1.4/CoinMP/test/unitTest.cpp @ 329

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

Update unitTest.cpp by removing LoadNamesType?, add optimalValue in printout, and test for sosCount == 0

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 20.7 KB
Line 
1
2/* unitTest.cpp */
3
4// $Id: unitTest.cpp 329 2009-11-11 22:03:22Z bjarni $
5
6#include <stdlib.h>
7#include <stdio.h>
8#include <string.h>
9#include <assert.h>
10#include <math.h>
11
12#include "CoinMP.h"
13
14
15int SOLVCALL MsgLogCallback(char* MessageStr)
16{
17        fprintf(stdout, "%s", MessageStr);
18        return 0;
19}
20
21int SOLVCALL IterCallback(int    IterCount, 
22                        double ObjectValue,
23                        int    IsFeasible, 
24                        double InfeasValue)
25{
26        fprintf(stdout, "ITER: iter=%d, obj=%lg, feas=%d, infeas=%lg\n",
27                IterCount, ObjectValue, IsFeasible, InfeasValue);
28        return 0;
29}
30
31int SOLVCALL MipNodeCallback(int    IterCount, 
32                                int       MipNodeCount,
33                                double BestBound,
34                                double BestInteger,
35                                int    IsMipImproved)
36{
37        fprintf(stdout, "NODE: iter=%d, node=%d, bound=%lg, best=%lg, %s\n",
38                IterCount, MipNodeCount, BestBound, BestInteger, IsMipImproved ? "Improved" : "");
39        return 0;
40}
41
42
43void GetAndCheckSolution(double optimalValue, HPROB hProb)
44{
45        int solutionStatus;
46        const char* solutionText;
47        double objectValue;
48        int i;
49        int colCount;
50        double* xValues;
51        const char* ColName;
52        const char* problemName;
53
54        problemName = CoinGetProblemName(hProb);
55        solutionStatus = CoinGetSolutionStatus(hProb);
56        solutionText = CoinGetSolutionText(hProb,solutionStatus);
57        objectValue =  CoinGetObjectValue(hProb);
58     
59        fprintf(stdout, "\n---------------------------------------\n");
60        fprintf(stdout, "Problem Name:    %s\n", problemName);
61        fprintf(stdout, "Solution Result: %s\n", solutionText );
62        fprintf(stdout, "Solution Status: %d\n", solutionStatus);
63        fprintf(stdout, "Optimal Value:   %lg\n", objectValue);
64        fprintf(stdout, "---------------------------------------\n");
65     
66        colCount = CoinGetColCount(hProb);
67        xValues = (double* )malloc(colCount * sizeof(double));
68        CoinGetSolutionValues(hProb, xValues, NULL, NULL, NULL);
69        for (i = 0; i < colCount; i++) {
70                if (xValues[i] != 0.0) {
71                        ColName = CoinGetColName(hProb, i);
72                        fprintf(stdout, "%s = %lg\n", ColName, xValues[i]);
73                }
74        }
75        fprintf(stdout, "---------------------------------------\n\n");
76        assert(solutionStatus==0);
77        assert(strcmp(solutionText,"Optimal solution found")==0);
78        if (optimalValue != 0.0) {
79                assert( fabs(objectValue-optimalValue) < 0.001 );
80        }
81}
82
83
84
85void RunTestProblem(char* problemName, double optimalValue, int colCount, int rowCount, 
86          int nonZeroCount, int rangeCount, int objectSense, double objectConst, double* objectCoeffs, 
87          double* lowerBounds, double* upperBounds, char* rowType, double* rhsValues, double* rangeValues, 
88          int* matrixBegin, int* matrixCount, int* matrixIndex, double* matrixValues, char** colNames, 
89          char** rowNames, char* objectName, double* initValues, char* columnType)
90{
91        HPROB hProb;
92        int result;
93        char filename[260];
94   
95        fprintf(stdout, "Solve Problem: %s (obj=%lg)\n", problemName, optimalValue);
96        hProb = CoinCreateProblem(problemName); 
97        /*if (LoadNamesType > 0) {
98                result = CoinSetLoadNamesType(hProb, LoadNamesType);
99        }*/
100        result = CoinLoadProblem(hProb, colCount, rowCount, nonZeroCount, rangeCount,
101                                        objectSense, objectConst, objectCoeffs, lowerBounds, upperBounds, 
102                                        rowType, rhsValues, rangeValues, matrixBegin, matrixCount, 
103                                        matrixIndex, matrixValues, colNames, rowNames, objectName);
104        if (columnType) {
105                result = CoinLoadInteger(hProb, columnType);
106        }
107        result = CoinCheckProblem(hProb);
108        if (result != SOLV_CALL_SUCCESS) {
109                fprintf(stdout, "Check Problem failed (result = %d)\n", result);
110        }
111        //result = CoinSetMsgLogCallback(hProb, &MsgLogCallback);
112        if (columnType == NULL)
113                result = CoinSetIterCallback(hProb, &IterCallback);
114        else {
115                result = CoinSetMipNodeCallback(hProb, &MipNodeCallback);
116        }
117        result = CoinOptimizeProblem(hProb, 0);
118        strcpy(filename, problemName);
119        strcat(filename, ".mps");
120        result = CoinWriteFile(hProb, SOLV_FILE_MPS, filename);
121        GetAndCheckSolution(optimalValue, hProb);
122        CoinUnloadProblem(hProb);
123}
124
125
126void RunTestProblemBuf(char* problemName, double optimalValue, int colCount, int rowCount, 
127          int nonZeroCount, int rangeCount, int objectSense, double objectConst, double* objectCoeffs, 
128          double* lowerBounds, double* upperBounds, char* rowType, double* rhsValues, double* rangeValues, 
129          int* matrixBegin, int* matrixCount, int* matrixIndex, double* matrixValues, char* colNamesBuf, 
130          char* rowNamesBuf, char* objectName, double* initValues, char* columnType)
131{
132        HPROB hProb;
133        int result;
134        char filename[260];
135   
136        fprintf(stdout, "Solve Problem: %s (obj=%lg)\n", problemName, optimalValue);
137        hProb = CoinCreateProblem(problemName); 
138        result = CoinLoadProblemBuf(hProb, colCount, rowCount, nonZeroCount, rangeCount,
139                                        objectSense, objectConst, objectCoeffs, lowerBounds, upperBounds, 
140                                        rowType, rhsValues, rangeValues, matrixBegin, matrixCount, 
141                                        matrixIndex, matrixValues, colNamesBuf, rowNamesBuf, objectName);
142        if (columnType) {
143                result = CoinLoadInteger(hProb, columnType);
144        }
145        result = CoinCheckProblem(hProb);
146        if (result != SOLV_CALL_SUCCESS) {
147                fprintf(stdout, "Check Problem failed (result = %d)\n", result);
148        }
149        //result = CoinSetMsgLogCallback(hProb, &MsgLogCallback);
150        if (columnType == NULL)
151                result = CoinSetIterCallback(hProb, &IterCallback);
152        else {
153                result = CoinSetMipNodeCallback(hProb, &MipNodeCallback);
154        }
155        result = CoinOptimizeProblem(hProb, 0);
156        strcpy(filename, problemName);
157        strcat(filename, ".mps");
158        result = CoinWriteFile(hProb, SOLV_FILE_MPS, filename);
159        GetAndCheckSolution(optimalValue, hProb);
160        CoinUnloadProblem(hProb);
161}
162
163
164void RunSosTestProblem(char* problemName, double optimalValue, int colCount, int rowCount, 
165          int nonZeroCount, int rangeCount, int objectSense, double objectConst, double* objectCoeffs, 
166          double* lowerBounds, double* upperBounds, char* rowType, double* rhsValues, double* rangeValues, 
167          int* matrixBegin, int* matrixCount, int* matrixIndex, double* matrixValues, char** colNames, 
168          char** rowNames, char* objectName, double* initValues, char* columnType, int sosCount, 
169          int sosNZCount, int* sosType, int* sosPrior, int* sosBegin, int* sosIndex, double* sosRef)
170{
171        HPROB hProb;
172        int result;
173        char filename[260];
174   
175        fprintf(stdout, "Solve Problem: %s (obj=%lg)\n", problemName, optimalValue);
176        hProb = CoinCreateProblem(problemName);
177        result = CoinLoadProblem(hProb, colCount, rowCount, nonZeroCount, rangeCount,
178                                        objectSense, objectConst, objectCoeffs, lowerBounds, upperBounds, 
179                                        rowType, rhsValues, rangeValues, matrixBegin, matrixCount, 
180                                        matrixIndex, matrixValues, colNames, rowNames, objectName);
181        if (columnType) {
182                result = CoinLoadInteger(hProb, columnType);
183        }
184        result = CoinLoadSos(hProb, sosCount, sosNZCount, sosType, sosPrior, sosBegin, sosIndex, sosRef);
185        result = CoinCheckProblem(hProb);
186        if (result != SOLV_CALL_SUCCESS) {
187                fprintf(stdout, "Check Problem failed (result = %d)\n", result);
188        }
189        //result = CoinSetMsgLogCallback(hProb, &MsgLogCallback);
190        if ((columnType == NULL) && (sosCount == 0))
191                result = CoinSetIterCallback(hProb, &IterCallback);
192        else {
193                result = CoinSetMipNodeCallback(hProb, &MipNodeCallback);
194        }
195        strcpy(filename, problemName);
196        strcat(filename, ".mps");
197        result = CoinWriteFile(hProb, SOLV_FILE_MPS, filename);
198        result = CoinOptimizeProblem(hProb, 0);
199        GetAndCheckSolution(optimalValue, hProb);
200        CoinUnloadProblem(hProb);
201}
202
203
204
205/*************************************************************************
206*   This problem is copied from coinutils\test\CoinPackedMatrixTest
207*
208*    3x1 +  x2         -  2x4 - x5               -    x8
209*          2x2 + 1.1x3
210*                   x3              +  x6               
211*                       2.8x4             -1.2x7
212*  5.6x1                      + x5               + 1.9x8
213*
214*************************************************************************/
215
216void SolveProblemCoinTest(void)
217{
218        char* problemName = "CoinTest";
219        int colCount=8;
220        int rowCount=5;
221        int nonZeroCount=14;
222        int rangeCount = 0;
223
224        char* objectName = "obj";
225        int objectSense = SOLV_OBJSENS_MAX;
226        double objectConst = 0.0;
227        double objectCoeffs[8] = { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 };
228
229        double lowerBounds[8] = { 0., 0., 0., 0., 0., 0., 0.  };
230        double upperBounds[8] = { 1000000., 1000000., 1000000., 1000000., 1000000., 1000000., 1000000., 1000000.   };
231
232        char rowType[5] = { 'L', 'L', 'L', 'L', 'L' };
233        double rhsValues[5] = { 14., 80., 50., 50., 50. };
234
235        int matrixBegin[8+1]={0,2,4,6,8,10,11,12,14};
236        int matrixCount[8]={2,2,2,2,2,1,1,2};
237        int matrixIndex[14]={0,4,0,1,1,2,0,3,0,4,2,3,0,4};
238        double matrixValues[14]={3., 5.6, 1., 2., 1.1, 1., -2., 2.8, -1., 1., 1., -1.2, -1., 1.9};
239   
240        char* colNames[8] = {"c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8"};
241        char* rowNames[5] = {"r1", "r2", "r3", "r4", "r5"};
242
243        //char* colNamesBuf = "c1\0" "c2\0" "c3\0" "c4\0" "c5\0" "c6\0" "c7\0" "c8";
244        //char* rowNamesBuf = "r1\0" "r2\0" "r3\0" "r4\0" "r5";
245   
246        double initValues[8] = { 0., 0., 0., 0., 0., 0., 0., 0.  };
247
248        double optimalValue = 1428729.2857143;
249
250        RunTestProblem(problemName, optimalValue, colCount, rowCount, 
251          nonZeroCount, rangeCount, objectSense, objectConst, objectCoeffs, 
252          lowerBounds, upperBounds, rowType, rhsValues, NULL, 
253          matrixBegin, matrixCount, matrixIndex, matrixValues, 
254          colNames, rowNames, objectName, initValues, NULL);
255}
256
257
258void SolveProblemBakery(void)
259{
260        char* problemName = "Bakery";
261        int colCount = 2;
262        int rowCount = 3;
263        int nonZeroCount = 4 ;
264        int rangeCount = 0;
265
266        char* objectName = "Profit";
267        int objectSense = SOLV_OBJSENS_MAX;
268        double objectConst = - 4000.0 / 30.0;
269        double objectCoeffs[2] = { 0.05 , 0.08 };
270
271        double lowerBounds[2] = { 0, 0  };
272        double upperBounds[2] = { 1000000, 1000000   };
273   
274        char rowType[3] = { 'L', 'L' , 'L' };
275        double rhsValues[3] = { 1400 , 8000 , 5000 };
276
277        int matrixBegin[2+1] = { 0 , 2, 4 };
278        int matrixCount[2] = { 2 , 2 };
279        int matrixIndex[4] = { 0, 1, 0, 2};
280        double matrixValues[4] = { 0.1, 1, 0.2, 1};
281
282        char* colNames[2] = {"Sun", "Moon"};
283        char* rowNames[3] = {"c1", "c2", "c3"};
284
285        //char* colNamesBuf = "Sun\0" "Moon";
286        //char* rowNamesBuf = "c1\0" "c2\0" "c3";
287   
288        double optimalValue = 506.66666667;
289
290        RunTestProblem(problemName, optimalValue, colCount, rowCount, 
291          nonZeroCount, rangeCount, objectSense, objectConst, objectCoeffs, 
292          lowerBounds, upperBounds, rowType, rhsValues, NULL, 
293          matrixBegin, matrixCount, matrixIndex, matrixValues, 
294          colNames, rowNames, objectName, NULL, NULL);
295}
296
297
298void SolveProblemAfiro(void)
299{
300        char* probname = "Afiro";
301        int ncol = 32;
302        int nrow = 27;
303        int nels = 83;
304        int nrng = 0;
305
306        char* objectname = "Cost";
307        int objsens = SOLV_OBJSENS_MIN;
308        double objconst = 0.0;
309
310        double dobj[32]={0, -0.4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0.32, 0, 0, 0, -0.6, 
311                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0.48, 0, 0, 10};
312
313        double dclo[32]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
314                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
315
316        double dcup[32]={1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 
317                1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 
318                1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 
319                1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037};
320
321        char rtyp[27]= {'E', 'E', 'L', 'L', 'E', 'E', 'L', 'L', 'L', 'L', 'E', 'E', 'L', 
322                'L', 'E', 'E', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L'};
323
324        double drhs[27]={0, 0, 80, 0, 0, 0, 80, 0, 0, 0, 0, 0, 500, 0, 0, 44, 500, 0, 
325                0, 0, 0, 0, 0, 0, 0, 310, 300};
326
327        int mbeg[32+1]={0, 4, 6, 8, 10, 14, 18, 22, 26, 28, 30, 32, 34, 36, 38, 40, 
328                44, 46, 48, 50, 52, 56, 60, 64, 68, 70, 72, 74, 76, 78, 80, 82, 83};
329
330        int mcnt[32]={4, 2, 2, 2, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 4, 
331                4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 1};
332
333        int midx[83]={0, 1, 2, 23, 0, 3, 0, 21, 1, 25, 4, 5, 6, 24, 4, 5, 7, 24, 4, 5, 
334                8, 24, 4, 5, 9, 24, 6, 20, 7, 20, 8, 20, 9, 20, 3, 4, 4, 22, 5, 26, 10, 11, 
335                12, 21, 10, 13, 10, 23, 10, 20, 11, 25, 14, 15, 16, 22, 14, 15, 17, 22, 14, 
336                15, 18, 22, 14, 15, 19, 22, 16, 20, 17, 20, 18, 20, 19, 20, 13, 15, 15, 24, 
337                14, 26, 15};
338
339        double mval[83]={-1, -1.06, 1, 0.301, 1, -1, 1, -1, 1, 1, -1, -1.06, 1, 0.301, 
340                -1, -1.06, 1, 0.313, -1, -0.96, 1, 0.313, -1, -0.86, 1, 0.326, -1, 2.364, -1, 
341                2.386, -1, 2.408, -1, 2.429, 1.4, 1, 1, -1, 1, 1, -1, -0.43, 1, 0.109, 1, -1, 
342                1, -1, 1, -1, 1, 1, -0.43, 1, 1, 0.109, -0.43, 1, 1, 0.108, -0.39, 1, 1, 
343                0.108, -0.37, 1, 1, 0.107, -1, 2.191, -1, 2.219, -1, 2.249, -1, 2.279, 1.4, 
344                -1, 1, -1, 1, 1, 1};
345
346        char* colnames[32] = {"x01", "x02", "x03", "x04", "x06", "x07", "x08", "x09", 
347                "x10", "x11", "x12", "x13", "x14", "x15", "x16", "x22", "x23", "x24", "x25", 
348                "x26", "x28", "x29", "x30", "x31", "x32", "x33", "x34", "x35", "x36", "x37", 
349                "x38", "x39"};
350
351        char* rownames[27] = {"r09", "r10", "x05", "x21", "r12", "r13", "x17", "x18", 
352                "x19", "x20", "r19", "r20", "x27", "x44", "r22", "r23", "x40", "x41", "x42", 
353                "x43", "x45", "x46", "x47", "x48", "x49", "x50", "x51"};
354
355        /*char* colnamesBuf = "x01\0" "x02\0" "x03\0" "x04\0" "x06\0" "x07\0" "x08\0" "x09\0"
356                "x10\0" "x11\0" "x12\0" "x13\0" "x14\0" "x15\0" "x16\0" "x22\0" "x23\0" "x24\0" "x25\0"
357                "x26\0" "x28\0" "x29\0" "x30\0" "x31\0" "x32\0" "x33\0" "x34\0" "x35\0" "x36\0" "x37\0"
358                "x38\0" "x39";*/
359
360        /*char* rownamesBuf = "r09\0" "r10\0" "x05\0" "x21\0" "r12\0" "r13\0" "x17\0" "x18\0"
361                "x19\0" "x20\0" "r19\0" "r20\0" "x27\0" "x44\0" "r22\0" "r23\0" "x40\0" "x41\0" "x42\0"
362                "x43\0" "x45\0" "x46\0" "x47\0" "x48\0" "x49\0" "x50\0" "x51";*/
363
364        double optimalValue = -464.753142857;
365
366        RunTestProblem(probname, optimalValue, ncol, nrow, nels, nrng, 
367          objsens, objconst, dobj, dclo, dcup, rtyp, drhs, NULL, mbeg, 
368          mcnt, midx, mval, colnames, rownames, objectname, NULL, NULL);
369}
370
371
372void SolveProblemP0033(void)
373{
374        char* probname = "P0033";
375        int ncol = 33;
376        int nrow = 15;
377        int nels = 98;
378        int nrng = 0;
379
380        char* objectname = "Obj";
381        int objsens = SOLV_OBJSENS_MIN;
382        double objconst = 0.0;
383
384        double dobj[33]={171, 171, 171, 171, 163, 162, 163, 69, 69, 183, 183, 183, 
385                183, 49, 183, 258, 517, 250, 500, 250, 500, 159, 318, 159, 318, 159, 318, 159, 
386                318, 114, 228, 159, 318};
387
388        double dclo[33]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
389                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
390
391        double dcup[33]={1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
392                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
393
394        char rtyp[15]= { 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L' };
395
396        double drhs[15]={1, 1, 1, 1, -5, 2700, -2600, -100, -900, -1656, -335, -1026, 
397                -5, -500, -270};
398
399        int mbeg[33+1]={0, 3, 6, 10, 14, 19, 24, 26, 31, 36, 38, 41, 45, 49, 53, 54, 
400                55, 56, 58, 60, 61, 62, 66, 70, 73, 76, 80, 84, 87, 90, 93, 96, 97, 98};
401
402        int mcnt[33]={3, 3, 4, 4, 5, 5, 2, 5, 5, 2, 3, 4, 4, 4, 1, 1, 1, 2, 2, 1, 1, 
403                4, 4, 3, 3, 4, 4, 3, 3, 3, 3, 1, 1};
404
405        int midx[98]={0, 8, 9, 0, 12, 13, 0, 5, 6, 9, 0, 5, 6, 7, 1, 5, 6, 10, 11, 1, 
406                5, 6, 8, 9, 1, 14, 2, 5, 6, 10, 11, 2, 5, 6, 8, 9, 3, 4, 3, 10, 11, 3, 5, 6,
407                11, 3, 5, 6, 9, 5, 6, 8, 9, 3, 4, 4, 12, 13, 12, 13, 13, 13, 5, 6, 10, 11, 5, 
408                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, 
409                7, 5, 6, 7, 14, 14};
410
411        double mval[98]={1, -300, -300, 1, -300, -300, 1, 300, -300, -300, 1, 300, 
412                -300, -300, 1, 285, -285, -285, -285, 1, 285, -285, -285, -285, 1, -285, 1,
413                265, -265, -265, -265, 1, 265, -265, -265, -265, 1, -230, 1, -230, -230, 1, 
414                230, -230, -230, 1, 230, -230, -230, 190, -190, -190, -190, 1, -200, -400, 
415                -200, -200, -400, -400, -200, -400, 200, -200, -200, -200, 400, -400, -400,
416                -400, 200, -200, -200, 400, -400, -400, 200, -200, -200, -200, 400, -400, 
417                -400, -400, 200, -200, -200, 400, -400, -400, 200, -200, -200, 400, -400, 
418                -400, -200, -400};
419
420        char* colnames[33] = {"c157", "c158", "c159", "c160", "c161", "c162", "c163", 
421                "c164", "c165", "c166", "c167", "c168", "c169", "c170", "c171", "c172", 
422                "c173", "c174", "c175", "c176", "c177", "c178", "c179", "c180", "c181", 
423                "c182", "c183", "c184", "c185", "c186", "c187", "c188", "c189"};
424
425        char* rownames[15] = {"r114", "r115", "r116", "r117", "r118", "r119", "r120", 
426                "r121", "r122", "r123", "r124", "r125", "r126", "r127", "r128"};
427
428        /*char* colnamesBuf = "c157\0" "c158\0" "c159\0" "c160\0" "c161\0" "c162\0" "c163\0"
429                "c164\0" "c165\0" "c166\0" "c167\0" "c168\0" "c169\0" "c170\0" "c171\0" "c172\0"
430                "c173\0" "c174\0" "c175\0" "c176\0" "c177\0" "c178\0" "c179\0" "c180\0" "c181\0"
431                "c182\0" "c183\0" "c184\0" "c185\0" "c186\0" "c187\0" "c188\0" "c189";*/
432
433        /*char* rownamesBuf = "r114\0" "r115\0" "r116\0" "r117\0" "r118\0" "r119\0" "r120\0"
434                "r121\0" "r122\0" "r123\0" "r124\0" "r125\0" "r126\0" "r127\0" "r128";*/
435
436        char ctyp[33] = { 'B', 'B', 'B', 'B', 'B', 'B', 'B',
437                'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 
438                'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 
439                'B', 'B', 'B', 'B', 'B', 'B' };
440
441        double optimalValue = 3089.0;
442
443        RunTestProblem(probname, optimalValue, ncol, nrow, nels, nrng, 
444          objsens, objconst, dobj, dclo, dcup, rtyp, drhs, NULL, mbeg, 
445          mcnt, midx, mval, colnames, rownames, objectname, NULL, ctyp);
446}
447
448
449void SolveProblemExmip1(void)
450{
451        char* probname = "Exmip1";
452        int ncol = 8;
453        int nrow = 5;
454        int nels = 14;
455        int nrng = 2;
456       
457        char* objectname = "z";
458        int objsens = SOLV_OBJSENS_MIN;
459        double objconst = 0.0;
460        double dobj[8]={1, 0, 0, 0, 2, 0, 0, -1};
461
462        double dclo[8]={2.5, 0, 0, 0, 0.5, 0, 0, 0};
463        double dcup[8]={1e+037, 4.1, 1e+037, 1e+037, 4, 1e+037, 1e+037, 4.3};
464
465        char rtyp[5]= {'G', 'L', 'E', 'G', 'L'};
466        double drhs[5]={2.5, 2.1, 4, 1.8, 15};
467        double drng[5]={0, 0, 0, -3.2, 12};
468
469        int mbeg[8+1]={0, 2, 4, 6, 8, 10, 11, 12, 14};
470        int mcnt[8]={2, 2, 2, 2, 2, 1, 1, 2};
471        int midx[14]={0, 4, 0, 1, 1, 2, 0, 3, 0, 4, 2, 3, 0, 4};
472        double mval[14]={3, 5.6, 1, 2, 1.1, 1, -2, 2.8, -1, 1, 1, -1.2, -1, 1.9};
473
474        char* colnames[8] = {"col01", "col02", "col03", "col04", "col05", "col06", 
475                "col07", "col08"};
476        char* rownames[5] = {"row01", "row02", "row03", "row04", "row05"};
477
478        /*char* colnamesBuf = "col01\0" "col02\0" "col03\0" "col04\0" "col05\0" "col06\0"
479                "col07\0" "col08";*/
480        /*char* rownamesBuf = "row01\0" "row02\0" "row03\0" "row04\0" "row05";*/
481
482        char ctyp[8] = { 'C', 'C', 'B', 'B', 'C', 'C', 'C', 'C'};
483
484        double optimalValue = 3.23684210526;
485
486        RunTestProblem(probname, optimalValue, ncol, nrow, nels, nrng, 
487          objsens, objconst, dobj, dclo, dcup, rtyp, drhs, drng, mbeg, 
488          mcnt, midx, mval, colnames, rownames, objectname, NULL, ctyp);
489}
490
491
492
493void SolveProblemGamsSos1a(void)
494{
495        char* probname = "GamsSos1a";
496        int ncol = 3;
497        int nrow = 1;
498        int nels = 3;
499        int nrng = 0;
500       
501        char* objectname = "z";
502        int objsens = SOLV_OBJSENS_MAX;
503        double objconst = 0.0;
504        double dobj[3]={0.9, 1.0, 1.1};
505
506        double dclo[3]={0, 0, 0};
507        double dcup[3]={0.8, 0.6, 0.6};
508
509        char* rtyp = NULL;
510        double drlo[1]={-1e+37};
511        double drup[1]={1.0};
512
513        int mbeg[3+1]={0, 1, 2, 3};
514        int mcnt[3]={1, 1, 1};
515        int midx[3]={0, 0, 0};
516        double mval[3]={1, 1, 1};
517
518        char* colnames[3] = {"x1", "x2", "x3"};
519        char* rownames[1] = {"xsum"};
520
521        //char* colnamesBuf = "x1\0" "x2\0" "x3";
522        //char* rownamesBuf = "xsum";
523
524        int sosCount = 1;
525        int sosNZCount = 3;
526        int sosType[1] = {1};
527        int sosBegin[1+1] = {0, 3};
528        int sosIndex[3] = {0, 1, 2};
529
530        double optimalValue = 0.72;
531
532        RunSosTestProblem(probname, optimalValue, ncol, nrow, nels, nrng, 
533          objsens, objconst, dobj, dclo, dcup, NULL, drlo, drup, mbeg, 
534          mcnt, midx, mval, colnames, rownames, objectname, NULL, NULL,
535          sosCount, sosNZCount, sosType, NULL, sosBegin, sosIndex, NULL);
536}
537
538
539void SolveProblemGamsSos2a(void)
540{
541        char* probname = "GamsSos2a";
542        int ncol = 7;
543        int nrow = 5;
544        int nels = 15;
545        int nrng = 0;
546       
547        char* objectname = "z";
548        int objsens = SOLV_OBJSENS_MIN;
549        double objconst = 0.0;
550        double dobj[7]={0, 0, 0, 0, 0, 1, 1};
551
552        double dclo[7]={0.0, 0, 0, -1e+37, -1e+37, 0, 0};
553        double dcup[7]={1e+37, 1e+37, 1e+37, 1e+37, 1e+37, 1e+37, 1e+37};
554
555        char rtyp[5]= {'E', 'E', 'E', 'G', 'G'};
556        double drhs[5]={1, 0, 0, -1.3, 1.3};
557
558        int mbeg[7+1]={0, 3, 6, 9, 10, 13, 14, 15};
559        int mcnt[7]={3, 3, 3, 1, 3, 1, 1};
560        int midx[15]={0, 1, 2, 0, 1, 2, 0, 1, 2, 1, 2, 3, 4, 3, 4};
561        double mval[15]={1, 1, 1, 1, 2, 2, 1, 3, 3, -1, -1, -1, 1, 1, 1};
562
563        char* colnames[7] = {"w1", "w2", "w3", "x", "fx", "fplus", "fminus"};
564        char* rownames[5] = {"wsum", "xdef", "fxdef", "gapplus", "gapminus"};
565
566        //char* colnamesBuf = "w1\0" "w2\0" "w3\0" "x\0" "fx\0" "fplus\0" "fminus";
567        //char* rownamesBuf = "wsum\0" "xdef\0" "fxdef\0" "gapplus\0" "gapminus";
568
569        int sosCount = 1;
570        int sosNZCount = 3;
571        int sosType[1] = {2};
572        int sosBegin[1+1] = {0, 3};
573        int sosIndex[3] = {0, 1, 2};
574
575        double optimalValue = 0.0;
576
577        RunSosTestProblem(probname, optimalValue, ncol, nrow, nels, nrng, 
578          objsens, objconst, dobj, dclo, dcup, rtyp, drhs, NULL, mbeg, 
579          mcnt, midx, mval, colnames, rownames, objectname, NULL, NULL,
580          sosCount, sosNZCount, sosType, NULL, sosBegin, sosIndex, NULL);
581}
582
583
584
585int main (int argc, char* argv[])
586{
587        const char* SolverName;
588        double CoinVersion;
589
590        CoinInitSolver("");
591        SolverName = CoinGetSolverName();
592        CoinVersion = CoinGetVersion();
593        fprintf(stdout, "UnitTest: %s version %lg\n\n", SolverName, CoinVersion);
594        SolveProblemCoinTest();
595        SolveProblemBakery();
596        SolveProblemAfiro();
597        SolveProblemP0033();
598        SolveProblemExmip1();
599        SolveProblemGamsSos1a();
600        SolveProblemGamsSos2a();
601        fprintf(stdout, "All unit tests completed successfully\n" );
602        CoinFreeSolver();
603        return 0;
604}
Note: See TracBrowser for help on using the repository browser.