source: trunk/CoinMP/test/unitTest.cpp @ 524

Last change on this file since 524 was 451, checked in by bjarni, 8 years ago

Casting userParam argument to remove compiler warnings for unitTest.cpp

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