source: trunk/Clp/examples/makeDual.cpp

Last change on this file was 1662, checked in by lou, 8 years ago

Add EPL license notice in examples.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 7.1 KB
Line 
1/* $Id: makeDual.cpp 1662 2011-01-04 17:52:40Z unxusr $ */
2// Copyright (C) 2005, 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#include "ClpSimplex.hpp"
7#include "CoinHelperFunctions.hpp"
8#include "CoinBuild.hpp"
9int main(int argc, const char *argv[])
10{
11     ClpSimplex  model;
12     int status;
13     if (argc < 2) {
14#if defined(SAMPLEDIR)
15          status = model.readMps(SAMPLEDIR "/p0033.mps", true);
16#else
17          fprintf(stderr, "Do not know where to find sample MPS files.\n");
18          exit(1);
19#endif
20     } else
21          status = model.readMps(argv[1]);
22     if (status) {
23          printf("errors on input\n");
24          exit(77);
25     }
26     {
27          // check if we need to change bounds to rows
28          int numberColumns = model.numberColumns();
29          const double * columnLower = model.columnLower();
30          const double * columnUpper = model.columnUpper();
31          int iColumn;
32          CoinBuild build;
33          double one = 1.0;
34          for (iColumn = 0; iColumn < numberColumns; iColumn++) {
35               if (columnUpper[iColumn] < 1.0e20 &&
36                         columnLower[iColumn] > -1.0e20) {
37                    if (fabs(columnLower[iColumn]) < fabs(columnUpper[iColumn])) {
38                         double value = columnUpper[iColumn];
39                         model.setColumnUpper(iColumn, COIN_DBL_MAX);
40                         build.addRow(1, &iColumn, &one, -COIN_DBL_MAX, value);
41                    } else {
42                         double value = columnLower[iColumn];
43                         model.setColumnLower(iColumn, -COIN_DBL_MAX);
44                         build.addRow(1, &iColumn, &one, value, COIN_DBL_MAX);
45                    }
46               }
47          }
48          if (build.numberRows())
49               model.addRows(build);
50     }
51     int numberColumns = model.numberColumns();
52     const double * columnLower = model.columnLower();
53     const double * columnUpper = model.columnUpper();
54     int numberRows = model.numberRows();
55     double * rowLower = CoinCopyOfArray(model.rowLower(), numberRows);
56     double * rowUpper = CoinCopyOfArray(model.rowUpper(), numberRows);
57
58     const double * objective = model.objective();
59     CoinPackedMatrix * matrix = model.matrix();
60     // get transpose
61     CoinPackedMatrix rowCopy = *matrix;
62     int iRow, iColumn;
63     int numberExtraRows = 0;
64     for (iRow = 0; iRow < numberRows; iRow++) {
65          if (rowLower[iRow] <= -1.0e20) {
66          } else if (rowUpper[iRow] >= 1.0e20) {
67          } else {
68               if (rowUpper[iRow] != rowLower[iRow])
69                    numberExtraRows++;
70          }
71     }
72     const int * row = matrix->getIndices();
73     const int * columnLength = matrix->getVectorLengths();
74     const CoinBigIndex * columnStart = matrix->getVectorStarts();
75     const double * elementByColumn = matrix->getElements();
76     double objOffset = 0.0;
77     for (iColumn = 0; iColumn < numberColumns; iColumn++) {
78          double offset = 0.0;
79          if (columnUpper[iColumn] >= 1.0e20) {
80               if (columnLower[iColumn] > -1.0e20)
81                    offset = columnLower[iColumn];
82          } else if (columnLower[iColumn] <= -1.0e20) {
83               offset = columnUpper[iColumn];
84          } else {
85               // taken care of before
86               abort();
87          }
88          if (offset) {
89               objOffset += offset * objective[iColumn];
90               for (CoinBigIndex j = columnStart[iColumn];
91                         j < columnStart[iColumn] + columnLength[iColumn]; j++) {
92                    int iRow = row[j];
93                    if (rowLower[iRow] > -1.0e20)
94                         rowLower[iRow] -= offset * elementByColumn[j];
95                    if (rowUpper[iRow] < 1.0e20)
96                         rowUpper[iRow] -= offset * elementByColumn[j];
97               }
98          }
99     }
100     int * which = new int[numberRows+numberExtraRows];
101     rowCopy.reverseOrdering();
102     rowCopy.transpose();
103     double * fromRowsLower = new double[numberRows+numberExtraRows];
104     double * fromRowsUpper = new double[numberRows+numberExtraRows];
105     double * newObjective = new double[numberRows+numberExtraRows];
106     double * fromColumnsLower = new double[numberColumns];
107     double * fromColumnsUpper = new double[numberColumns];
108     for (iColumn = 0; iColumn < numberColumns; iColumn++) {
109          // Offset is already in
110          if (columnUpper[iColumn] >= 1.0e20) {
111               if (columnLower[iColumn] > -1.0e20) {
112                    fromColumnsLower[iColumn] = -COIN_DBL_MAX;
113                    fromColumnsUpper[iColumn] = objective[iColumn];
114               } else {
115                    // free
116                    fromColumnsLower[iColumn] = objective[iColumn];
117                    fromColumnsUpper[iColumn] = objective[iColumn];
118               }
119          } else if (columnLower[iColumn] <= -1.0e20) {
120               fromColumnsLower[iColumn] = objective[iColumn];
121               fromColumnsUpper[iColumn] = COIN_DBL_MAX;
122          } else {
123               abort();
124          }
125     }
126     int kRow = 0;
127     for (iRow = 0; iRow < numberRows; iRow++) {
128          if (rowLower[iRow] <= -1.0e20) {
129               assert(rowUpper[iRow] < 1.0e20);
130               newObjective[kRow] = -rowUpper[iRow];
131               fromRowsLower[kRow] = -COIN_DBL_MAX;
132               fromRowsUpper[kRow] = 0.0;
133               which[kRow] = iRow;
134               kRow++;
135          } else if (rowUpper[iRow] >= 1.0e20) {
136               newObjective[kRow] = -rowLower[iRow];
137               fromRowsLower[kRow] = 0.0;
138               fromRowsUpper[kRow] = COIN_DBL_MAX;
139               which[kRow] = iRow;
140               kRow++;
141          } else {
142               if (rowUpper[iRow] == rowLower[iRow]) {
143                    newObjective[kRow] = -rowLower[iRow];
144                    fromRowsLower[kRow] = -COIN_DBL_MAX;;
145                    fromRowsUpper[kRow] = COIN_DBL_MAX;
146                    which[kRow] = iRow;
147                    kRow++;
148               } else {
149                    // range
150                    newObjective[kRow] = -rowUpper[iRow];
151                    fromRowsLower[kRow] = -COIN_DBL_MAX;
152                    fromRowsUpper[kRow] = 0.0;
153                    which[kRow] = iRow;
154                    kRow++;
155                    newObjective[kRow] = -rowLower[iRow];
156                    fromRowsLower[kRow] = 0.0;
157                    fromRowsUpper[kRow] = COIN_DBL_MAX;
158                    which[kRow] = iRow;
159                    kRow++;
160               }
161          }
162     }
163     if (numberExtraRows) {
164          CoinPackedMatrix newCopy;
165          newCopy.submatrixOfWithDuplicates(rowCopy, kRow, which);
166          rowCopy = newCopy;
167     }
168     ClpSimplex modelDual;
169     modelDual.loadProblem(rowCopy, fromRowsLower, fromRowsUpper, newObjective,
170                           fromColumnsLower, fromColumnsUpper);
171     modelDual.setObjectiveOffset(objOffset);
172     delete [] fromRowsLower;
173     delete [] fromRowsUpper;
174     delete [] fromColumnsLower;
175     delete [] fromColumnsUpper;
176     delete [] newObjective;
177     delete [] which;
178     delete [] rowLower;
179     delete [] rowUpper;
180     modelDual.writeMps("dual.mps");
181     return 0;
182}
Note: See TracBrowser for help on using the repository browser.