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

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

make check for sample dir work without including ClpConfig?.h

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