source: stable/1.15/Clp/examples/addRows.cpp @ 1941

Last change on this file since 1941 was 1941, checked in by stefan, 6 years ago

sync with trunk rev 1940

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 11.7 KB
Line 
1/* $Id: addRows.cpp 1941 2013-04-10 16:52:27Z stefan $ */
2// Copyright (C) 2004, International Business Machines
3// Corporation and others.  All Rights Reserved.
4// This code is licensed under the terms of the Eclipse Public License (EPL).
5
6
7// This is a simple example to create a model by row
8#include "ClpSimplex.hpp"
9#include "CoinHelperFunctions.hpp"
10#include "CoinTime.hpp"
11#include "CoinBuild.hpp"
12#include "CoinModel.hpp"
13#include <iomanip>
14#include <cassert>
15
16int main(int argc, const char *argv[])
17{
18     try {
19          // Empty model
20          ClpSimplex  model;
21
22          // Objective - just nonzeros
23          int objIndex[] = {0, 2};
24          double objValue[] = {1.0, 4.0};
25          // Upper bounds - as dense vector
26          double upper[] = {2.0, COIN_DBL_MAX, 4.0};
27
28          // Create space for 3 columns
29          model.resize(0, 3);
30          // Fill in
31          int i;
32          // Virtuous way
33          // First objective
34          for (i = 0; i < 2; i++)
35               model.setObjectiveCoefficient(objIndex[i], objValue[i]);
36          // Now bounds (lower will be zero by default but do again)
37          for (i = 0; i < 3; i++) {
38               model.setColumnLower(i, 0.0);
39               model.setColumnUpper(i, upper[i]);
40          }
41          /*
42            We could also have done in non-virtuous way e.g.
43            double * objective = model.objective();
44            and then set directly
45          */
46          // Faster to add rows all at once - but this is easier to show
47          // Now add row 1 as >= 2.0
48          int row1Index[] = {0, 2};
49          double row1Value[] = {1.0, 1.0};
50          model.addRow(2, row1Index, row1Value,
51                       2.0, COIN_DBL_MAX);
52          // Now add row 2 as == 1.0
53          int row2Index[] = {0, 1, 2};
54          double row2Value[] = {1.0, -5.0, 1.0};
55          model.addRow(3, row2Index, row2Value,
56                       1.0, 1.0);
57          // solve
58          model.dual();
59
60          /*
61            Adding one row at a time has a significant overhead so let's
62            try a more complicated but faster way
63
64            First time adding in 10000 rows one by one
65          */
66          model.allSlackBasis();
67          ClpSimplex modelSave = model;
68          double time1 = CoinCpuTime();
69          int k;
70          for (k = 0; k < 10000; k++) {
71               int row2Index[] = {0, 1, 2};
72               double row2Value[] = {1.0, -5.0, 1.0};
73               model.addRow(3, row2Index, row2Value,
74                            1.0, 1.0);
75          }
76          printf("Time for 10000 addRow is %g\n", CoinCpuTime() - time1);
77          model.dual();
78          model = modelSave;
79          // Now use build
80          CoinBuild buildObject;
81          time1 = CoinCpuTime();
82          for (k = 0; k < 10000; k++) {
83               int row2Index[] = {0, 1, 2};
84               double row2Value[] = {1.0, -5.0, 1.0};
85               buildObject.addRow(3, row2Index, row2Value,
86                                  1.0, 1.0);
87          }
88          model.addRows(buildObject);
89          printf("Time for 10000 addRow using CoinBuild is %g\n", CoinCpuTime() - time1);
90          model.dual();
91          model = modelSave;
92          int del[] = {0, 1, 2};
93          model.deleteRows(2, del);
94          // Now use build +-1
95          CoinBuild buildObject2;
96          time1 = CoinCpuTime();
97          for (k = 0; k < 10000; k++) {
98               int row2Index[] = {0, 1, 2};
99               double row2Value[] = {1.0, -1.0, 1.0};
100               buildObject2.addRow(3, row2Index, row2Value,
101                                   1.0, 1.0);
102          }
103          model.addRows(buildObject2, true);
104          printf("Time for 10000 addRow using CoinBuild+-1 is %g\n", CoinCpuTime() - time1);
105          model.dual();
106          model = modelSave;
107          model.deleteRows(2, del);
108          // Now use build +-1
109          CoinModel modelObject2;
110          time1 = CoinCpuTime();
111          for (k = 0; k < 10000; k++) {
112               int row2Index[] = {0, 1, 2};
113               double row2Value[] = {1.0, -1.0, 1.0};
114               modelObject2.addRow(3, row2Index, row2Value,
115                                   1.0, 1.0);
116          }
117          model.addRows(modelObject2, true);
118          printf("Time for 10000 addRow using CoinModel+-1 is %g\n", CoinCpuTime() - time1);
119          model.dual();
120          model = ClpSimplex();
121          // Now use build +-1
122          CoinModel modelObject3;
123          time1 = CoinCpuTime();
124          for (k = 0; k < 10000; k++) {
125               int row2Index[] = {0, 1, 2};
126               double row2Value[] = {1.0, -1.0, 1.0};
127               modelObject3.addRow(3, row2Index, row2Value,
128                                   1.0, 1.0);
129          }
130          model.loadProblem(modelObject3, true);
131          printf("Time for 10000 addRow using CoinModel load +-1 is %g\n", CoinCpuTime() - time1);
132          model.writeMps("xx.mps");
133          model.dual();
134          model = modelSave;
135          // Now use model
136          CoinModel modelObject;
137          time1 = CoinCpuTime();
138          for (k = 0; k < 10000; k++) {
139               int row2Index[] = {0, 1, 2};
140               double row2Value[] = {1.0, -5.0, 1.0};
141               modelObject.addRow(3, row2Index, row2Value,
142                                  1.0, 1.0);
143          }
144          model.addRows(modelObject);
145          printf("Time for 10000 addRow using CoinModel is %g\n", CoinCpuTime() - time1);
146          model.dual();
147          model.writeMps("b.mps");
148          // Method using least memory - but most complicated
149          time1 = CoinCpuTime();
150          // Assumes we know exact size of model and matrix
151          // Empty model
152          ClpSimplex  model2;
153          {
154               // Create space for 3 columns and 10000 rows
155               int numberRows = 10000;
156               int numberColumns = 3;
157               // This is fully dense - but would not normally be so
158               int numberElements = numberRows * numberColumns;
159               // Arrays will be set to default values
160               model2.resize(numberRows, numberColumns);
161               double * elements = new double [numberElements];
162               CoinBigIndex * starts = new CoinBigIndex [numberColumns+1];
163               int * rows = new int [numberElements];;
164               int * lengths = new int[numberColumns];
165               // Now fill in - totally unsafe but ....
166               // no need as defaults to 0.0 double * columnLower = model2.columnLower();
167               double * columnUpper = model2.columnUpper();
168               double * objective = model2.objective();
169               double * rowLower = model2.rowLower();
170               double * rowUpper = model2.rowUpper();
171               // Columns - objective was packed
172               for (k = 0; k < 2; k++) {
173                    int iColumn = objIndex[k];
174                    objective[iColumn] = objValue[k];
175               }
176               for (k = 0; k < numberColumns; k++)
177                    columnUpper[k] = upper[k];
178               // Rows
179               for (k = 0; k < numberRows; k++) {
180                    rowLower[k] = 1.0;
181                    rowUpper[k] = 1.0;
182               }
183               // Now elements
184               double row2Value[] = {1.0, -5.0, 1.0};
185               CoinBigIndex put = 0;
186               for (k = 0; k < numberColumns; k++) {
187                    starts[k] = put;
188                    lengths[k] = numberRows;
189                    double value = row2Value[k];
190                    for (int i = 0; i < numberRows; i++) {
191                         rows[put] = i;
192                         elements[put] = value;
193                         put++;
194                    }
195               }
196               starts[numberColumns] = put;
197               // assign to matrix
198               CoinPackedMatrix * matrix = new CoinPackedMatrix(true, 0.0, 0.0);
199               matrix->assignMatrix(true, numberRows, numberColumns, numberElements,
200                                    elements, rows, starts, lengths);
201               ClpPackedMatrix * clpMatrix = new ClpPackedMatrix(matrix);
202               model2.replaceMatrix(clpMatrix, true);
203               printf("Time for 10000 addRow using hand written code is %g\n", CoinCpuTime() - time1);
204               // If matrix is really big could switch off creation of row copy
205               // model2.setSpecialOptions(256);
206          }
207          model2.dual();
208          model2.writeMps("a.mps");
209          // Print column solution
210          int numberColumns = model.numberColumns();
211
212          // Alternatively getColSolution()
213          double * columnPrimal = model.primalColumnSolution();
214          // Alternatively getReducedCost()
215          double * columnDual = model.dualColumnSolution();
216          // Alternatively getColLower()
217          double * columnLower = model.columnLower();
218          // Alternatively getColUpper()
219          double * columnUpper = model.columnUpper();
220          // Alternatively getObjCoefficients()
221          double * columnObjective = model.objective();
222
223          int iColumn;
224
225          std::cout << "               Primal          Dual         Lower         Upper          Cost"
226                    << std::endl;
227
228          for (iColumn = 0; iColumn < numberColumns; iColumn++) {
229               double value;
230               std::cout << std::setw(6) << iColumn << " ";
231               value = columnPrimal[iColumn];
232               if (fabs(value) < 1.0e5)
233                    std::cout << setiosflags(std::ios::fixed | std::ios::showpoint) << std::setw(14) << value;
234               else
235                    std::cout << setiosflags(std::ios::scientific) << std::setw(14) << value;
236               value = columnDual[iColumn];
237               if (fabs(value) < 1.0e5)
238                    std::cout << setiosflags(std::ios::fixed | std::ios::showpoint) << std::setw(14) << value;
239               else
240                    std::cout << setiosflags(std::ios::scientific) << std::setw(14) << value;
241               value = columnLower[iColumn];
242               if (fabs(value) < 1.0e5)
243                    std::cout << setiosflags(std::ios::fixed | std::ios::showpoint) << std::setw(14) << value;
244               else
245                    std::cout << setiosflags(std::ios::scientific) << std::setw(14) << value;
246               value = columnUpper[iColumn];
247               if (fabs(value) < 1.0e5)
248                    std::cout << setiosflags(std::ios::fixed | std::ios::showpoint) << std::setw(14) << value;
249               else
250                    std::cout << setiosflags(std::ios::scientific) << std::setw(14) << value;
251               value = columnObjective[iColumn];
252               if (fabs(value) < 1.0e5)
253                    std::cout << setiosflags(std::ios::fixed | std::ios::showpoint) << std::setw(14) << value;
254               else
255                    std::cout << setiosflags(std::ios::scientific) << std::setw(14) << value;
256
257               std::cout << std::endl;
258          }
259          std::cout << "--------------------------------------" << std::endl;
260          // Test CoinAssert
261          std::cout << "If Clp compiled without NDEBUG below should give assert, if with NDEBUG or COIN_ASSERT CoinError" << std::endl;
262          model = modelSave;
263          model.deleteRows(2, del);
264          // Deliberate error
265          model.deleteColumns(1, del + 2);
266          // Now use build +-1
267          CoinBuild buildObject3;
268          time1 = CoinCpuTime();
269          for (k = 0; k < 10000; k++) {
270               int row2Index[] = {0, 1, 2};
271               double row2Value[] = {1.0, -1.0, 1.0};
272               buildObject3.addRow(3, row2Index, row2Value,
273                                   1.0, 1.0);
274          }
275          model.addRows(buildObject3, true);
276     } catch (CoinError e) {
277          e.print();
278          if (e.lineNumber() >= 0)
279               std::cout << "This was from a CoinAssert" << std::endl;
280     }
281     return 0;
282}
Note: See TracBrowser for help on using the repository browser.