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

Last change on this file since 113 was 113, checked in by bjarni, 11 years ago

Updated with new API interface for CoinMP version 1.2

  • Property svn:eol-style set to native
File size: 11.5 KB
Line 
1
2/* unitTest.c */
3
4#include <stdlib.h>
5#include <stdio.h>
6#include <string.h>
7#include <assert.h>
8#include <math.h>
9
10#include "CoinMP.h"
11
12
13
14void GetAndCheckSolution(double optimalValue, HPROB hProb)
15{
16        int solutionStatus;
17        char *solutionText;
18        double objectValue;
19
20        solutionStatus = CoinGetSolutionStatus(hProb);
21        solutionText = CoinGetSolutionText(hProb,solutionStatus);
22        objectValue =  CoinGetObjectValue(hProb);
23     
24        fprintf(stdout, "\n---------------------------------------\n");
25        fprintf(stdout, "Solution Result: %s\n", solutionText );
26        fprintf(stdout, "Solution Status: %d\n", solutionStatus);
27        fprintf(stdout, "Solution Value: %lg\n", objectValue);
28     
29        assert(solutionStatus==0);
30        assert(strcmp(solutionText,"Optimal solution found")==0);
31        if (optimalValue != 0.0) {
32                assert( fabs(objectValue-optimalValue) < 0.001 );
33        }
34        fprintf(stdout, "---------------------------------------\n\n");
35}
36
37
38
39void RunTestProblem(char *problemName, double optimalValue, int colCount, int rowCount, 
40          int nonZeroCount, int rangeCount, int objectSense, double *objectCoeffs, double objectConst, 
41      double *rhsValues, double *rangeValues, char *columnType, char *rowType, int *matrixBegin, 
42          int *matrixCount, int *matrixIndex, double *matrixValues, double *lowerBounds, double *upperBounds, 
43          double *initValues, char **colNames, char **rowNames)
44{
45    HPROB hProb;
46   
47        fprintf(stdout, "Solve Problem: %s\n", problemName);
48    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 );
53        if (columnType) {
54                CoinLoadInteger(hProb, columnType);
55        }
56        CoinOptimizeProblem(hProb, 0);
57        GetAndCheckSolution(optimalValue, hProb);
58    CoinUnloadProblem(hProb);
59}
60
61
62
63/*************************************************************************
64*   This problem is copied from coinutils\test\CoinPackedMatrixTest
65*
66*    3x1 +  x2         -  2x4 - x5               -    x8
67*          2x2 + 1.1x3
68*                   x3              +  x6               
69*                       2.8x4             -1.2x7
70*  5.6x1                      + x5               + 1.9x8
71*
72*************************************************************************/
73
74void SolveProblemCoinTest(void)
75{
76        char *problemName = "CoinTest";
77    int colCount=8;
78    int rowCount=5;
79    int nonZeroCount=14;
80    int rangeCount = 0;
81
82    int objectSense = SOLV_OBJSENS_MAX;
83        double objectConst = 0.0;
84    double objectCoeffs[8] = { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 };
85
86        double rhsValues[5] = { 14., 80., 50., 50., 50. };
87    char rowType[5] = { 'L', 'L', 'L', 'L', 'L' };
88
89    int matrixBegin[8+1]={0,2,4,6,8,10,11,12,14};
90    int matrixCount[8]={2,2,2,2,2,1,1,2};
91    int matrixIndex[14]={0,4,0,1,1,2,0,3,0,4,2,3,0,4};
92        double matrixValues[14]={3., 5.6, 1., 2., 1.1, 1., -2., 2.8, -1., 1., 1., -1.2, -1., 1.9};
93   
94    double lowerBounds[8] = { 0., 0., 0., 0., 0., 0., 0.  };
95    double upperBounds[8] = { 1000000., 1000000., 1000000., 1000000., 1000000., 1000000., 1000000.   };
96
97        double initValues[8] = { 0., 0., 0., 0., 0., 0., 0., 0.  };
98    char * colNames[8] = { "c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8" };
99    char * rowNames[5] = { "r1", "r2", "r3", "r4", "r5" } ;
100   
101        double optimalValue = 1428729.2857143;
102
103        RunTestProblem(problemName, optimalValue, colCount, rowCount, 
104          nonZeroCount, rangeCount, objectSense, objectCoeffs, objectConst, 
105      rhsValues, NULL, NULL, rowType, matrixBegin, matrixCount, 
106          matrixIndex, matrixValues, lowerBounds, upperBounds, 
107          initValues, colNames, rowNames);
108}
109
110
111void SolveProblemBakery(void)
112{
113        char *problemName = "Bakery";
114    int colCount = 2;
115    int rowCount = 3;
116    int nonZeroCount = 4 ;
117    int rangeCount = 0;
118
119        int objectSense = SOLV_OBJSENS_MAX;
120        double objectConst = - 4000.0 / 30.0;
121    double objectCoeffs[2] = { 0.05 , 0.08 };
122
123        double rhsValues[3] = { 1400 , 8000 , 5000 };
124    char rowType[3] = { 'L', 'L' , 'L' };
125
126    int matrixBegin[2+1] = { 0 , 2, 4 };
127    int matrixCount[2] = { 2 , 2 };
128    int matrixIndex[4] = { 0, 1, 0, 2};
129    double matrixValues[4] = { 0.1, 1, 0.2, 1};
130
131    double lowerBounds[2] = { 0, 0  };
132    double upperBounds[2] = { 1000000, 1000000   };
133    char * colNames[2] = { "Sun", "Moon" };
134    char * rowNames[3] = { "c1", "c2", "c3" } ;
135   
136        double optimalValue = 506.66666667;
137
138        RunTestProblem(problemName, optimalValue, colCount, rowCount, 
139          nonZeroCount, rangeCount, objectSense, objectCoeffs, objectConst, 
140      rhsValues, NULL, NULL, rowType, matrixBegin, matrixCount, 
141      matrixIndex, matrixValues, lowerBounds, upperBounds, 
142          NULL, colNames, rowNames);
143}
144
145
146void SolveProblemAfiro(void)
147{
148        char *probname = "Afiro";
149        int ncol = 32;
150        int nrow = 27;
151        int nels = 83;
152        int nrng = 0;
153
154        int objsens = SOLV_OBJSENS_MIN;
155
156        double objconst = 0.0;
157
158        double dobj[32]={0, -0.4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0.32, 0, 0, 0, -0.6, 
159                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0.48, 0, 0, 10};
160
161        double drhs[27]={0, 0, 80, 0, 0, 0, 80, 0, 0, 0, 0, 0, 500, 0, 0, 44, 500, 0, 
162                0, 0, 0, 0, 0, 0, 0, 310, 300};
163
164        char rtyp[27]= {'E', 'E', 'L', 'L', 'E', 'E', 'L', 'L', 'L', 'L', 'E', 'E', 'L', 
165                'L', 'E', 'E', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L'};
166
167        int mbeg[32+1]={0, 4, 6, 8, 10, 14, 18, 22, 26, 28, 30, 32, 34, 36, 38, 40, 
168                44, 46, 48, 50, 52, 56, 60, 64, 68, 70, 72, 74, 76, 78, 80, 82, 83};
169
170        int mcnt[32]={4, 2, 2, 2, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 4, 
171                4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 1};
172
173        int midx[83]={0, 1, 2, 23, 0, 3, 0, 21, 1, 25, 4, 5, 6, 24, 4, 5, 7, 24, 4, 5, 
174                8, 24, 4, 5, 9, 24, 6, 20, 7, 20, 8, 20, 9, 20, 3, 4, 4, 22, 5, 26, 10, 11, 
175                12, 21, 10, 13, 10, 23, 10, 20, 11, 25, 14, 15, 16, 22, 14, 15, 17, 22, 14, 
176                15, 18, 22, 14, 15, 19, 22, 16, 20, 17, 20, 18, 20, 19, 20, 13, 15, 15, 24, 
177                14, 26, 15};
178
179        double mval[83]={-1, -1.06, 1, 0.301, 1, -1, 1, -1, 1, 1, -1, -1.06, 1, 0.301, 
180                -1, -1.06, 1, 0.313, -1, -0.96, 1, 0.313, -1, -0.86, 1, 0.326, -1, 2.364, -1, 
181                2.386, -1, 2.408, -1, 2.429, 1.4, 1, 1, -1, 1, 1, -1, -0.43, 1, 0.109, 1, -1, 
182                1, -1, 1, -1, 1, 1, -0.43, 1, 1, 0.109, -0.43, 1, 1, 0.108, -0.39, 1, 1, 
183                0.108, -0.37, 1, 1, 0.107, -1, 2.191, -1, 2.219, -1, 2.249, -1, 2.279, 1.4, 
184                -1, 1, -1, 1, 1, 1};
185
186        double dclo[32]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
187                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
188
189        double dcup[32]={1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 
190                1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 
191                1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 
192                1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037, 1e+037};
193
194        char *colname[32]={"X01", "X02", "X03", "X04", "X06", "X07", "X08", "X09", 
195                "X10", "X11", "X12", "X13", "X14", "X15", "X16", "X22", "X23", "X24", "X25", 
196                "X26", "X28", "X29", "X30", "X31", "X32", "X33", "X34", "X35", "X36", "X37", 
197                "X38", "X39"};
198
199        char *rowname[27]={"R09", "R10", "X05", "X21", "R12", "R13", "X17", "X18", 
200                "X19", "X20", "R19", "R20", "X27", "X44", "R22", "R23", "X40", "X41", "X42", 
201                "X43", "X45", "X46", "X47", "X48", "X49", "X50", "X51"};
202
203        double optimalValue = -464.753142857;
204
205        RunTestProblem(probname, optimalValue, ncol, nrow, nels, nrng, 
206          objsens, dobj, objconst, drhs, NULL, NULL, rtyp, mbeg, mcnt, 
207      midx, mval, dclo, dcup, NULL, colname, rowname);
208}
209
210
211void SolveProblemP0033(void)
212{
213        char *probname = "P0033";
214        int ncol = 33;
215        int nrow = 15;
216        int nels = 98;
217        int nrng = 0;
218
219        int objsens = SOLV_OBJSENS_MIN;
220
221        double objconst = 0.0;
222
223        double dobj[33]={171, 171, 171, 171, 163, 162, 163, 69, 69, 183, 183, 183, 
224                183, 49, 183, 258, 517, 250, 500, 250, 500, 159, 318, 159, 318, 159, 318, 159, 
225                318, 114, 228, 159, 318};
226
227        double drhs[15]={1, 1, 1, 1, -5, 2700, -2600, -100, -900, -1656, -335, -1026, 
228                -5, -500, -270};
229
230        char rtyp[15]= { 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L' };
231
232        int mbeg[33+1]={0, 3, 6, 10, 14, 19, 24, 26, 31, 36, 38, 41, 45, 49, 53, 54, 
233                55, 56, 58, 60, 61, 62, 66, 70, 73, 76, 80, 84, 87, 90, 93, 96, 97, 98};
234
235        int mcnt[33]={3, 3, 4, 4, 5, 5, 2, 5, 5, 2, 3, 4, 4, 4, 1, 1, 1, 2, 2, 1, 1, 
236                4, 4, 3, 3, 4, 4, 3, 3, 3, 3, 1, 1};
237
238        int midx[98]={0, 8, 9, 0, 12, 13, 0, 5, 6, 9, 0, 5, 6, 7, 1, 5, 6, 10, 11, 1, 
239                5, 6, 8, 9, 1, 14, 2, 5, 6, 10, 11, 2, 5, 6, 8, 9, 3, 4, 3, 10, 11, 3, 5, 6, 
240                11, 3, 5, 6, 9, 5, 6, 8, 9, 3, 4, 4, 12, 13, 12, 13, 13, 13, 5, 6, 10, 11, 5, 
241                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, 
242                7, 5, 6, 7, 14, 14};
243
244        double mval[98]={1, -300, -300, 1, -300, -300, 1, 300, -300, -300, 1, 300, 
245                -300, -300, 1, 285, -285, -285, -285, 1, 285, -285, -285, -285, 1, -285, 1, 
246                265, -265, -265, -265, 1, 265, -265, -265, -265, 1, -230, 1, -230, -230, 1, 
247                230, -230, -230, 1, 230, -230, -230, 190, -190, -190, -190, 1, -200, -400, 
248                -200, -200, -400, -400, -200, -400, 200, -200, -200, -200, 400, -400, -400, 
249                -400, 200, -200, -200, 400, -400, -400, 200, -200, -200, -200, 400, -400, 
250                -400, -400, 200, -200, -200, 400, -400, -400, 200, -200, -200, 400, -400, 
251                -400, -200, -400};
252
253        double dclo[33]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
254                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
255
256        double dcup[33]={1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
257                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
258
259        char *colname[33]={"C157", "C158", "C159", "C160", "C161", "C162", "C163", 
260                "C164", "C165", "C166", "C167", "C168", "C169", "C170", "C171", "C172", 
261                "C173", "C174", "C175", "C176", "C177", "C178", "C179", "C180", "C181", 
262                "C182", "C183", "C184", "C185", "C186", "C187", "C188", "C189"};
263
264        char *rowname[15]={"R114", "R115", "R116", "R117", "R118", "R119", "R120", 
265                "R121", "R122", "R123", "R124", "R125", "R126", "R127", "R128"};
266
267        char ctyp[33] = { 'B', 'B', 'B', 'B', 'B', 'B', 'B',
268                'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 
269                'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 
270                'B', 'B', 'B', 'B', 'B', 'B' };
271
272        double optimalValue = 3089.0;
273
274        RunTestProblem(probname, optimalValue, ncol, nrow, nels, nrng, 
275          objsens, dobj, objconst, drhs, NULL, ctyp, rtyp, mbeg, mcnt, 
276      midx, mval, dclo, dcup, NULL, colname, rowname);
277}
278
279
280void SolveProblemExmip1(void)
281{
282        char *probname = "Exmip1";
283        int ncol = 8;
284        int nrow = 5;
285        int nels = 14;
286        int nrng = 2;
287       
288        int objsens = SOLV_OBJSENS_MIN;
289        double objconst = 0.0;
290        double dobj[8]={1, 0, 0, 0, 2, 0, 0, -1};
291
292        double drhs[5]={2.5, 2.1, 4, 1.8, 15};
293        double drng[5]={0, 0, 0, -3.2, 12};
294        char rtyp[5]= {'G', 'L', 'E', 'G', 'L'};
295
296        int mbeg[8+1]={0, 2, 4, 6, 8, 10, 11, 12, 14};
297        int mcnt[8]={2, 2, 2, 2, 2, 1, 1, 2};
298        int midx[14]={0, 4, 0, 1, 1, 2, 0, 3, 0, 4, 2, 3, 0, 4};
299        double mval[14]={3, 5.6, 1, 2, 1.1, 1, -2, 2.8, -1, 1, 1, -1.2, -1, 1.9};
300
301        double dclo[8]={2.5, 0, 0, 0, 0.5, 0, 0, 0};
302        double dcup[8]={1e+037, 4.1, 1e+037, 1e+037, 4, 1e+037, 1e+037, 4.3};
303
304        char *colname[8]={"COL01", "COL02", "COL03", "COL04", "COL05", "COL06", 
305                "COL07", "COL08"};
306        char *rowname[5]={"ROW01", "ROW02", "ROW03", "ROW04", "ROW05"};
307
308        char ctyp[8] = { 'C', 'C', 'B', 'B', 'C', 'C', 'C', 'C'};
309
310        double optimalValue = 3.23684210526;
311
312        RunTestProblem(probname, optimalValue, ncol, nrow, nels, nrng, 
313          objsens, dobj, objconst, drhs, drng, ctyp, rtyp, mbeg, mcnt, 
314      midx, mval, dclo, dcup, NULL, colname, rowname);
315}
316
317
318
319int main (int argc, char *argv[])
320{
321    CoinInitSolver("");
322        SolveProblemCoinTest();
323        SolveProblemBakery();
324        SolveProblemAfiro();
325        SolveProblemP0033();
326        SolveProblemExmip1();
327        fprintf(stdout, "All unit tests completed successfully\n" );
328    CoinFreeSolver();
329        return 0;
330}
Note: See TracBrowser for help on using the repository browser.