Changeset 18 for branches


Ignore:
Timestamp:
Sep 4, 2002 12:04:19 PM (17 years ago)
Author:
forrest
Message:

Allow export model - what a kludge

Location:
branches/devel-1
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • branches/devel-1/Makefile

    r17 r18  
    4444export ExtraIncDir := ../Osi/include
    4545export ExtraLibDir :=
    46 export ExtraLibName :=
     46export ExtraLibName := 
    4747export ExtraDefine :=
    4848
  • branches/devel-1/Test/ClpMain.cpp

    r2 r18  
    77
    88#include <cassert>
    9 #define CLPVERSION "0.90"
     9#define CLPVERSION "0.92"
    1010
    1111#include "ClpFactorization.hpp"
     
    1919#include "OsiPackedVector.hpp"
    2020#include "OsiWarmStartBasis.hpp"
     21// For Branch and bound
     22#include "OsiClpSolverInterface.hpp"
     23#include "OsiCuts.hpp"
     24#include "OsiRowCut.hpp"
     25#include "OsiColCut.hpp"
     26#include "OsiOsiMessage.hpp"
     27
    2128#include <stdio.h>
    2229
     
    7178  PRIMALPIVOT,
    7279 
    73   DIRECTORY=301,IMPORT,DUALSIMPLEX,PRIMALSIMPLEX,
     80  DIRECTORY=301,IMPORT,EXPORT,RESTORE,SAVE,DUALSIMPLEX,PRIMALSIMPLEX,BAB,
    7481  MAXIMIZE,MINIMIZE,EXIT,STDIN,UNITTEST,NETLIB_DUAL,NETLIB_PRIMAL,SOLUTION,
    7582  TIGHTEN,FAKEBOUND,VERSION,
     
    806813              IMPORT);
    807814    parameters[numberParameters++]=
     815      ClpItem("export","Export model as mps file",
     816              EXPORT);
     817    parameters[numberParameters++]=
     818      ClpItem("save!Model","Save model to binary file",
     819              SAVE);
     820    parameters[numberParameters++]=
     821      ClpItem("restore!Model","Restore model from binary file",
     822              RESTORE);
     823    parameters[numberParameters++]=
    808824      ClpItem("dualS!implex","Do dual simplex algorithm",
    809825              DUALSIMPLEX);
     
    811827      ClpItem("primalS!implex","Do primal simplex algorithm",
    812828              PRIMALSIMPLEX);
     829    parameters[numberParameters++]=
     830      ClpItem("branch!Andbound","Do Branch and Bound",
     831              BAB);
    813832    parameters[numberParameters++]=
    814833      ClpItem("tight!en","Poor person's preSolve for now",
     
    10761095            }
    10771096            break;
     1097          case BAB:
     1098#if 0
     1099            if (goodModels[iModel]) {
     1100              int saveMaxIterations = models[iModel].maximumIterations();
     1101#ifdef READLINE     
     1102              currentModel = models+iModel;
     1103#endif
     1104              {
     1105                // get OsiClp stuff
     1106                OsiClpSolverInterface m(models+iModel);
     1107                m.getModelPtr()->messageHandler()->setLogLevel(0);
     1108                m.branchAndBound();
     1109                m.resolve();
     1110                std::cout<<"Optimal solution "<<m.getObjValue()<<std::endl;
     1111                m.releaseClp();
     1112              }
     1113              models[iModel].setMaximumIterations(saveMaxIterations);
     1114              time2 = cpuTime();
     1115              totalTime += time2-time1;
     1116              std::cout<<"Result "<<models[iModel].status()<<
     1117                " - "<<models[iModel].objectiveValue()<<
     1118                " iterations "<<models[iModel].numberIterations()<<
     1119                " took "<<time2-time1<<" seconds - total "<<totalTime<<std::endl;
     1120              if (models[iModel].status())
     1121                std::cerr<<"Non zero status "<<models[iModel].status()<<
     1122                  std::endl;
     1123              time1=time2;
     1124            } else {
     1125              std::cout<<"** Current model not valid"<<std::endl;
     1126            }
     1127#endif
     1128            break;
    10781129          case IMPORT:
    10791130            {
     
    11051156                                                   allowImportErrors);
    11061157                if (!status||(status>0&&allowImportErrors)) {
    1107                   // I don't think there is any need for ths but ..
     1158                  // I don't think there is any need for this but ..
    11081159                  OsiWarmStartBasis allSlack;
    11091160                  goodModels[iModel]=true;
     
    11161167                  std::cout<<"There were "<<status<<
    11171168                    " errors on input"<<std::endl;
     1169                }
     1170              }
     1171            }
     1172            break;
     1173          case EXPORT:
     1174            {
     1175              // get next field
     1176              field = getString(argc,argv);
     1177              std::string fileName;
     1178              bool canOpen=false;
     1179              if (field[0]=='/'||field[0]=='~')
     1180                fileName = field;
     1181              else
     1182                fileName = directory+field;
     1183              FILE *fp=fopen(fileName.c_str(),"w");
     1184              if (fp) {
     1185                // can open - lets go for it
     1186                fclose(fp);
     1187                canOpen=true;
     1188              } else {
     1189                std::cout<<"Unable to open file "<<fileName<<std::endl;
     1190              }
     1191              if (canOpen) {
     1192                // get OsiClp stuff
     1193                OsiClpSolverInterface m(models+iModel);
     1194                // Convert names
     1195                int iRow;
     1196                int numberRows=models[iModel].numberRows();
     1197
     1198                char ** rowNames = new char * [numberRows];
     1199                for (iRow=0;iRow<numberRows;iRow++) {
     1200                  rowNames[iRow] =
     1201                    strdup(models[iModel].rowName(iRow).c_str());
     1202                }
     1203                int iColumn;
     1204                int numberColumns=models[iModel].numberColumns();
     1205
     1206                char ** columnNames = new char * [numberColumns];
     1207                for (iColumn=0;iColumn<numberColumns;iColumn++) {
     1208                  columnNames[iColumn] =
     1209                    strdup(models[iModel].columnName(iColumn).c_str());
     1210                }
     1211                m.writeMps(fileName.c_str(),
     1212                           (const char **) rowNames,
     1213                           (const char **) columnNames);
     1214                for (iRow=0;iRow<numberRows;iRow++) {
     1215                  free(rowNames[iRow]);
     1216                }
     1217                delete [] rowNames;
     1218                for (iColumn=0;iColumn<numberColumns;iColumn++) {
     1219                  free(columnNames[iColumn]);
     1220                }
     1221                delete [] columnNames;
     1222                m.releaseClp();
     1223                time2 = cpuTime();
     1224                totalTime += time2-time1;
     1225                time1=time2;
     1226              }
     1227            }
     1228            break;
     1229          case SAVE:
     1230            {
     1231              // get next field
     1232              field = getString(argc,argv);
     1233              std::string fileName;
     1234              bool canOpen=false;
     1235              if (field[0]=='/'||field[0]=='~')
     1236                fileName = field;
     1237              else
     1238                fileName = directory+field;
     1239              FILE *fp=fopen(fileName.c_str(),"wb");
     1240              if (fp) {
     1241                // can open - lets go for it
     1242                fclose(fp);
     1243                canOpen=true;
     1244              } else {
     1245                std::cout<<"Unable to open file "<<fileName<<std::endl;
     1246              }
     1247              if (canOpen) {
     1248                int status =models[iModel].saveModel(fileName.c_str());
     1249                if (!status) {
     1250                  goodModels[iModel]=true;
     1251                  time2 = cpuTime();
     1252                  totalTime += time2-time1;
     1253                  time1=time2;
     1254                } else {
     1255                  // errors
     1256                  std::cout<<"There were errors on output"<<std::endl;
     1257                }
     1258              }
     1259            }
     1260            break;
     1261          case RESTORE:
     1262            {
     1263              // get next field
     1264              field = getString(argc,argv);
     1265              std::string fileName;
     1266              bool canOpen=false;
     1267              if (field[0]=='/'||field[0]=='~')
     1268                fileName = field;
     1269              else
     1270                fileName = directory+field;
     1271              FILE *fp=fopen(fileName.c_str(),"rb");
     1272              if (fp) {
     1273                // can open - lets go for it
     1274                fclose(fp);
     1275                canOpen=true;
     1276              } else {
     1277                std::cout<<"Unable to open file "<<fileName<<std::endl;
     1278              }
     1279              if (canOpen) {
     1280                int status =models[iModel].restoreModel(fileName.c_str());
     1281                if (!status) {
     1282                  goodModels[iModel]=true;
     1283                  time2 = cpuTime();
     1284                  totalTime += time2-time1;
     1285                  time1=time2;
     1286                } else {
     1287                  // errors
     1288                  std::cout<<"There were errors on input"<<std::endl;
    11181289                }
    11191290              }
  • branches/devel-1/Test/Makefile

    r2 r18  
    6363LIBDIRS := ${LibDir}
    6464LIBS    := ${LibName}
     65LIBS    += libOsiClp
    6566
    6667LDFLAGS := $(addprefix -L,$(LIBDIRS))
  • branches/devel-1/include/ClpModel.hpp

    r17 r18  
    261261  const std::vector<std::string> * rowNames() const
    262262  {return &rowNames_;};
     263  const std::string rowName(int iRow) const
     264  {return rowNames_[iRow];};
    263265  /// Column names
    264266  const std::vector<std::string> * columnNames() const
    265267  {return &columnNames_;};
     268  const std::string columnName(int iColumn) const
     269  {return columnNames_[iColumn];};
    266270  //@}
    267271
Note: See TracChangeset for help on using the changeset viewer.