source: stable/1.13/Clp/examples/addRows.cpp @ 1898

Last change on this file since 1898 was 1559, checked in by stefan, 10 years ago

merge split branch into trunk

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