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

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

Update example.c by removing LoadNamesType?, add optimalValue in printout, and test for sosCount == 0 plus fixing whitespace issues

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