Ignore:
Timestamp:
Jan 6, 2019 2:43:06 PM (4 months ago)
Author:
unxusr
Message:

formatting

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/src/ClpSolver.cpp

    r2384 r2385  
    1919// for printing
    2020#ifndef CLP_OUTPUT_FORMAT
    21 #define CLP_OUTPUT_FORMAT %15.8g
     21#define CLP_OUTPUT_FORMAT % 15.8g
    2222#endif
    2323#define CLP_QUOTE(s) CLP_STRING(s)
     
    3232#ifdef COIN_HAS_GLPK
    3333#include "glpk.h"
    34 extern glp_tran* cbc_glp_tran;
    35 extern glp_prob* cbc_glp_prob;
     34extern glp_tran *cbc_glp_tran;
     35extern glp_prob *cbc_glp_prob;
    3636#else
    3737#define GLP_UNDEF 1
     
    8484#endif
    8585#ifdef CLP_USEFUL_PRINTOUT
    86 static double startElapsed=0.0;
    87 static double startCpu=0.0;
    88 static std::string mpsFile="";
     86static double startElapsed = 0.0;
     87static double startCpu = 0.0;
     88static std::string mpsFile = "";
    8989extern double debugDouble[10];
    9090extern int debugInt[24];
     
    9595
    9696static double totalTime = 0.0;
    97 static bool maskMatches(const int * starts, char ** masks,
    98                         std::string & check);
     97static bool maskMatches(const int *starts, char **masks,
     98  std::string &check);
    9999#ifndef ABC_INHERIT
    100 static ClpSimplex * currentModel = NULL;
     100static ClpSimplex *currentModel = NULL;
    101101#else
    102 static AbcSimplex * currentModel = NULL;
     102static AbcSimplex *currentModel = NULL;
    103103#endif
    104104
    105105extern "C" {
    106      static void
     106static void
    107107#if defined(_MSC_VER)
    108      __cdecl
     108  __cdecl
    109109#endif // _MSC_VER
    110      signal_handler(int /*whichSignal*/)
    111      {
    112           if (currentModel != NULL)
    113                currentModel->setMaximumIterations(0); // stop at next iterations
    114           return;
    115      }
    116   void openblas_set_num_threads(int num_threads);
     110  signal_handler(int /*whichSignal*/)
     111{
     112  if (currentModel != NULL)
     113    currentModel->setMaximumIterations(0); // stop at next iterations
     114  return;
     115}
     116void openblas_set_num_threads(int num_threads);
    117117}
    118118
     
    124124
    125125#ifndef ABC_INHERIT
    126 int mainTest (int argc, const char *argv[], int algorithm,
    127               ClpSimplex empty, ClpSolve solveOptions, int switchOff, bool doVector);
     126int mainTest(int argc, const char *argv[], int algorithm,
     127  ClpSimplex empty, ClpSolve solveOptions, int switchOff, bool doVector);
    128128#else
    129 int mainTest (int argc, const char *argv[], int algorithm,
    130               AbcSimplex empty, ClpSolve solveOptions, int switchOff, bool doVector);
    131 #endif
    132 static void statistics(ClpSimplex * originalModel, ClpSimplex * model);
    133 static void generateCode(const char * fileName, int type);
     129int mainTest(int argc, const char *argv[], int algorithm,
     130  AbcSimplex empty, ClpSolve solveOptions, int switchOff, bool doVector);
     131#endif
     132static void statistics(ClpSimplex *originalModel, ClpSimplex *model);
     133static void generateCode(const char *fileName, int type);
    134134// Returns next valid field
    135135int CbcOrClpRead_mode = 1;
    136 FILE * CbcOrClpReadCommand = stdin;
     136FILE *CbcOrClpReadCommand = stdin;
    137137// Alternative to environment
    138 extern char * alternativeEnvironment;
     138extern char *alternativeEnvironment;
    139139extern int CbcOrClpEnvironmentIndex;
    140140#ifdef CLP_USER_DRIVEN1
     
    149149   Variable will change theta if currentValue - currentTheta*alpha < 0.0
    150150*/
    151 bool userChoiceValid1(const ClpSimplex * model,
    152                       int sequenceOut,
    153                       double currentValue,
    154                       double currentTheta,
    155                       double alpha,
    156                       double realAlpha)
     151bool userChoiceValid1(const ClpSimplex *model,
     152  int sequenceOut,
     153  double currentValue,
     154  double currentTheta,
     155  double alpha,
     156  double realAlpha)
    157157{
    158158  return true;
     
    163163   If you return false sequenceIn_ will be flagged as ineligible.
    164164*/
    165 bool userChoiceValid2(const ClpSimplex * model)
     165bool userChoiceValid2(const ClpSimplex *model)
    166166{
    167167  return true;
     
    169169/* If a good pivot then you may wish to unflag some variables.
    170170 */
    171 void userChoiceWasGood(ClpSimplex * model)
     171void userChoiceWasGood(ClpSimplex *model)
    172172{
    173173}
    174174#endif
    175175#ifndef ABC_INHERIT
    176 void ClpMain0(ClpSimplex * models)
     176void ClpMain0(ClpSimplex *models)
    177177#else
    178 void ClpMain0(AbcSimplex * models)
     178void ClpMain0(AbcSimplex *models)
    179179#endif
    180180{
    181           models->setPerturbation(50);
    182           models->messageHandler()->setPrefix(false);
    183 #if CLP_INHERIT_MODE>1
    184           models->setDualTolerance(1.0e-6);
    185           models->setPrimalTolerance(1.0e-6);
     181  models->setPerturbation(50);
     182  models->messageHandler()->setPrefix(false);
     183#if CLP_INHERIT_MODE > 1
     184  models->setDualTolerance(1.0e-6);
     185  models->setPrimalTolerance(1.0e-6);
    186186#endif
    187187}
    188188#ifndef ABC_INHERIT
    189 int ClpMain1(int argc, const char *argv[],ClpSimplex * models)
     189int ClpMain1(int argc, const char *argv[], ClpSimplex *models)
    190190#else
    191 int ClpMain1(int argc, const char *argv[],AbcSimplex * models)
     191int ClpMain1(int argc, const char *argv[], AbcSimplex *models)
    192192#endif
    193193{
    194           double time1 = CoinCpuTime(), time2;
    195           // Set up all non-standard stuff
    196           //int numberModels=1;
     194  double time1 = CoinCpuTime(), time2;
     195  // Set up all non-standard stuff
     196  //int numberModels=1;
    197197#ifdef CLP_USEFUL_PRINTOUT
    198           startElapsed=CoinGetTimeOfDay();
    199           startCpu=CoinCpuTime();
    200           memset(debugInt,0,sizeof(debugInt));
    201           memset(debugDouble,0,sizeof(debugDouble));
     198  startElapsed = CoinGetTimeOfDay();
     199  startCpu = CoinCpuTime();
     200  memset(debugInt, 0, sizeof(debugInt));
     201  memset(debugDouble, 0, sizeof(debugDouble));
    202202#endif
    203203#if ABOCA_LITE
    204           //__cilkrts_end_cilk();
    205           __cilkrts_set_param("nworkers","1");
    206           //abcState_=1;
     204  //__cilkrts_end_cilk();
     205  __cilkrts_set_param("nworkers", "1");
     206  //abcState_=1;
    207207#endif
    208208#if 0
     
    213213#endif
    214214#endif
    215           // default action on import
    216           int allowImportErrors = 0;
    217           int keepImportNames = 1;
    218           int doIdiot = -1;
    219           int outputFormat = 2;
    220           int slpValue = -1;
    221           int cppValue = -1;
    222           int printOptions = 0;
    223           int printMode = 0;
    224           int presolveOptions = 0;
    225           int doCrash = 0;
    226           int doVector = 0;
    227           int doSprint = -1;
    228           // set reasonable defaults
    229 #if CLP_INHERIT_MODE>1
     215  // default action on import
     216  int allowImportErrors = 0;
     217  int keepImportNames = 1;
     218  int doIdiot = -1;
     219  int outputFormat = 2;
     220  int slpValue = -1;
     221  int cppValue = -1;
     222  int printOptions = 0;
     223  int printMode = 0;
     224  int presolveOptions = 0;
     225  int doCrash = 0;
     226  int doVector = 0;
     227  int doSprint = -1;
     228  // set reasonable defaults
     229#if CLP_INHERIT_MODE > 1
    230230#define DEFAULT_PRESOLVE_PASSES 20
    231231#else
    232232#define DEFAULT_PRESOLVE_PASSES 10
    233233#endif
    234           int preSolve = DEFAULT_PRESOLVE_PASSES;
    235           bool preSolveFile = false;
    236           const char dirsep =  CoinFindDirSeparator();
    237           std::string directory;
    238           std::string dirSample;
    239           std::string dirNetlib;
    240           std::string dirMiplib;
    241           if (dirsep == '/') {
    242                directory = "./";
    243                dirSample = "../../Data/Sample/";
    244                dirNetlib = "../../Data/Netlib/";
    245                dirMiplib = "../../Data/miplib3/";
     234  int preSolve = DEFAULT_PRESOLVE_PASSES;
     235  bool preSolveFile = false;
     236  const char dirsep = CoinFindDirSeparator();
     237  std::string directory;
     238  std::string dirSample;
     239  std::string dirNetlib;
     240  std::string dirMiplib;
     241  if (dirsep == '/') {
     242    directory = "./";
     243    dirSample = "../../Data/Sample/";
     244    dirNetlib = "../../Data/Netlib/";
     245    dirMiplib = "../../Data/miplib3/";
     246  } else {
     247    directory = ".\\";
     248#ifdef COIN_MSVS
     249    // Visual Studio builds are deeper
     250    dirSample = "..\\..\\..\\..\\Data\\Sample\\";
     251    dirNetlib = "..\\..\\..\\..\\Data\\Netlib\\";
     252    dirMiplib = "..\\..\\..\\..\\Data\\miplib3\\";
     253#else
     254    dirSample = "..\\..\\Data\\Sample\\";
     255    dirNetlib = "..\\..\\Data\\Netlib\\";
     256    dirMiplib = "..\\..\\Data\\miplib3\\";
     257#endif
     258  }
     259  std::string defaultDirectory = directory;
     260  std::string importFile = "";
     261  std::string exportFile = "default.mps";
     262  std::string importBasisFile = "";
     263  int basisHasValues = 0;
     264  int substitution = 3;
     265  int dualize = 3; // dualize if looks promising
     266  std::string exportBasisFile = "default.bas";
     267  std::string saveFile = "default.prob";
     268  std::string restoreFile = "default.prob";
     269  std::string solutionFile = "stdout";
     270  std::string solutionSaveFile = "solution.file";
     271  std::string printMask = "";
     272  CbcOrClpParam parameters[CBCMAXPARAMETERS];
     273  int numberParameters;
     274  establishParams(numberParameters, parameters);
     275  parameters[whichParam(CLP_PARAM_ACTION_BASISIN, numberParameters, parameters)].setStringValue(importBasisFile);
     276  parameters[whichParam(CLP_PARAM_ACTION_BASISOUT, numberParameters, parameters)].setStringValue(exportBasisFile);
     277  parameters[whichParam(CLP_PARAM_ACTION_PRINTMASK, numberParameters, parameters)].setStringValue(printMask);
     278  parameters[whichParam(CLP_PARAM_ACTION_DIRECTORY, numberParameters, parameters)].setStringValue(directory);
     279  parameters[whichParam(CLP_PARAM_ACTION_DIRSAMPLE, numberParameters, parameters)].setStringValue(dirSample);
     280  parameters[whichParam(CLP_PARAM_ACTION_DIRNETLIB, numberParameters, parameters)].setStringValue(dirNetlib);
     281  parameters[whichParam(CBC_PARAM_ACTION_DIRMIPLIB, numberParameters, parameters)].setStringValue(dirMiplib);
     282  parameters[whichParam(CLP_PARAM_DBL_DUALBOUND, numberParameters, parameters)].setDoubleValue(models->dualBound());
     283  parameters[whichParam(CLP_PARAM_DBL_DUALTOLERANCE, numberParameters, parameters)].setDoubleValue(models->dualTolerance());
     284  parameters[whichParam(CLP_PARAM_ACTION_EXPORT, numberParameters, parameters)].setStringValue(exportFile);
     285  parameters[whichParam(CLP_PARAM_INT_IDIOT, numberParameters, parameters)].setIntValue(doIdiot);
     286  parameters[whichParam(CLP_PARAM_ACTION_IMPORT, numberParameters, parameters)].setStringValue(importFile);
     287  parameters[whichParam(CLP_PARAM_INT_SOLVERLOGLEVEL, numberParameters, parameters)].setIntValue(models->logLevel());
     288  parameters[whichParam(CLP_PARAM_INT_MAXFACTOR, numberParameters, parameters)].setIntValue(models->factorizationFrequency());
     289  parameters[whichParam(CLP_PARAM_INT_MAXITERATION, numberParameters, parameters)].setIntValue(models->maximumIterations());
     290  parameters[whichParam(CLP_PARAM_INT_OUTPUTFORMAT, numberParameters, parameters)].setIntValue(outputFormat);
     291  parameters[whichParam(CLP_PARAM_INT_PRESOLVEPASS, numberParameters, parameters)].setIntValue(preSolve);
     292  parameters[whichParam(CLP_PARAM_INT_PERTVALUE, numberParameters, parameters)].setIntValue(models->perturbation());
     293  parameters[whichParam(CLP_PARAM_DBL_PRIMALTOLERANCE, numberParameters, parameters)].setDoubleValue(models->primalTolerance());
     294  parameters[whichParam(CLP_PARAM_DBL_PRIMALWEIGHT, numberParameters, parameters)].setDoubleValue(models->infeasibilityCost());
     295  parameters[whichParam(CLP_PARAM_ACTION_RESTORE, numberParameters, parameters)].setStringValue(restoreFile);
     296  parameters[whichParam(CLP_PARAM_ACTION_SAVE, numberParameters, parameters)].setStringValue(saveFile);
     297  parameters[whichParam(CLP_PARAM_DBL_TIMELIMIT, numberParameters, parameters)].setDoubleValue(models->maximumSeconds());
     298  parameters[whichParam(CLP_PARAM_ACTION_SOLUTION, numberParameters, parameters)].setStringValue(solutionFile);
     299  parameters[whichParam(CLP_PARAM_ACTION_SAVESOL, numberParameters, parameters)].setStringValue(solutionSaveFile);
     300  parameters[whichParam(CLP_PARAM_INT_SPRINT, numberParameters, parameters)].setIntValue(doSprint);
     301  parameters[whichParam(CLP_PARAM_INT_SUBSTITUTION, numberParameters, parameters)].setIntValue(substitution);
     302  parameters[whichParam(CLP_PARAM_INT_DUALIZE, numberParameters, parameters)].setIntValue(dualize);
     303  parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, numberParameters, parameters)].setDoubleValue(1.0e-8);
     304  int verbose = 0;
     305
     306  // total number of commands read
     307  int numberGoodCommands = 0;
     308  bool *goodModels = new bool[1];
     309  goodModels[0] = false;
     310  if (models[0].numberRows() || models[0].numberColumns()) {
     311    // model already built
     312    goodModels[0] = true;
     313    numberGoodCommands = 1;
     314  }
     315#ifdef COIN_HAS_ASL
     316  ampl_info info;
     317  int usingAmpl = 0;
     318  CoinMessageHandler *generalMessageHandler = models->messageHandler();
     319  generalMessageHandler->setPrefix(false);
     320  CoinMessages generalMessages = models->messages();
     321  char generalPrint[10000];
     322  {
     323    bool noPrinting_ = false;
     324    memset(&info, 0, sizeof(info));
     325    if (argc > 2 && !strcmp(argv[2], "-AMPL")) {
     326      usingAmpl = 1;
     327      // see if log in list
     328      noPrinting_ = true;
     329      for (int i = 1; i < argc; i++) {
     330        if (!strncmp(argv[i], "log", 3)) {
     331          const char *equals = strchr(argv[i], '=');
     332          if (equals && atoi(equals + 1) > 0) {
     333            noPrinting_ = false;
     334            info.logLevel = atoi(equals + 1);
     335            int log = whichParam(CLP_PARAM_INT_LOGLEVEL, numberParameters, parameters);
     336            parameters[log].setIntValue(info.logLevel);
     337            // mark so won't be overWritten
     338            info.numberRows = -1234567;
     339            break;
     340          }
     341        }
     342      }
     343
     344      union {
     345        void *voidModel;
     346        CoinModel *model;
     347      } coinModelStart;
     348      coinModelStart.model = NULL;
     349      int returnCode = readAmpl(&info, argc, const_cast< char ** >(argv), &coinModelStart.voidModel);
     350      if (returnCode)
     351        return returnCode;
     352      if (info.numberBinary + info.numberIntegers + info.numberSos
     353        && !info.starts) {
     354        printf("Unable to handle integer problems\n");
     355        return 1;
     356      }
     357      CbcOrClpRead_mode = 2; // so will start with parameters
     358      // see if log in list (including environment)
     359      for (int i = 1; i < info.numberArguments; i++) {
     360        if (!strcmp(info.arguments[i], "log")) {
     361          if (i < info.numberArguments - 1 && atoi(info.arguments[i + 1]) > 0)
     362            noPrinting_ = false;
     363          break;
     364        }
     365      }
     366      if (noPrinting_) {
     367        models->messageHandler()->setLogLevel(0);
     368        setCbcOrClpPrinting(false);
     369      }
     370      if (!noPrinting_)
     371        printf("%d rows, %d columns and %d elements\n",
     372          info.numberRows, info.numberColumns, info.numberElements);
     373      if (!coinModelStart.model) {
     374        // linear
     375        models->loadProblem(info.numberColumns, info.numberRows,
     376          reinterpret_cast< const CoinBigIndex * >(info.starts),
     377          info.rows, info.elements,
     378          info.columnLower, info.columnUpper, info.objective,
     379          info.rowLower, info.rowUpper);
     380      } else {
     381        // QP
     382        models->loadProblem(*(coinModelStart.model));
     383      }
     384      // If we had a solution use it
     385      if (info.primalSolution) {
     386        models->setColSolution(info.primalSolution);
     387      }
     388      // status
     389      if (info.rowStatus) {
     390        unsigned char *statusArray = models->statusArray();
     391        int i;
     392        for (i = 0; i < info.numberColumns; i++)
     393          statusArray[i] = static_cast< unsigned char >(info.columnStatus[i]);
     394        statusArray += info.numberColumns;
     395        for (i = 0; i < info.numberRows; i++)
     396          statusArray[i] = static_cast< unsigned char >(info.rowStatus[i]);
     397      }
     398      freeArrays1(&info);
     399      // modify objective if necessary
     400      models->setOptimizationDirection(info.direction);
     401      models->setObjectiveOffset(-info.offset);
     402      if (info.offset) {
     403        sprintf(generalPrint, "Ampl objective offset is %g",
     404          info.offset);
     405        generalMessageHandler->message(CLP_GENERAL, generalMessages)
     406          << generalPrint
     407          << CoinMessageEol;
     408      }
     409      goodModels[0] = true;
     410      // change argc etc
     411      argc = info.numberArguments;
     412      argv = const_cast< const char ** >(info.arguments);
     413    }
     414  }
     415#endif
     416
     417  // Hidden stuff for barrier
     418  int choleskyType = 0;
     419  int gamma = 0;
     420  parameters[whichParam(CLP_PARAM_STR_BARRIERSCALE, numberParameters, parameters)].setCurrentOption(2);
     421  int scaleBarrier = 2;
     422  int doKKT = 0;
     423  int crossover = 2; // do crossover unless quadratic
     424
     425  int iModel = 0;
     426  //models[0].scaling(1);
     427  //models[0].setDualBound(1.0e6);
     428  //models[0].setDualTolerance(1.0e-7);
     429  //ClpDualRowSteepest steep;
     430  //models[0].setDualRowPivotAlgorithm(steep);
     431  //ClpPrimalColumnSteepest steepP;
     432  //models[0].setPrimalColumnPivotAlgorithm(steepP);
     433  std::string field;
     434
     435  while (1) {
     436    // next command
     437    field = CoinReadGetCommand(argc, argv);
     438
     439    // exit if null or similar
     440    if (!field.length()) {
     441      if (numberGoodCommands == 1 && goodModels[0]) {
     442        // we just had file name - do dual or primal
     443        field = "either";
     444      } else if (!numberGoodCommands) {
     445        // let's give the sucker a hint
     446        std::cout
     447          << "Clp takes input from arguments ( - switches to stdin)"
     448          << std::endl
     449          << "Enter ? for list of commands or help" << std::endl;
     450        field = "-";
     451      } else {
     452        break;
     453      }
     454    }
     455
     456    // see if ? at end
     457    int numberQuery = 0;
     458    if (field != "?" && field != "???") {
     459      size_t length = field.length();
     460      size_t i;
     461      for (i = length - 1; i > 0; i--) {
     462        if (field[i] == '?')
     463          numberQuery++;
     464        else
     465          break;
     466      }
     467      field = field.substr(0, length - numberQuery);
     468    }
     469    // find out if valid command
     470    int iParam;
     471    int numberMatches = 0;
     472    int firstMatch = -1;
     473    for (iParam = 0; iParam < numberParameters; iParam++) {
     474      int match = parameters[iParam].matches(field);
     475      if (match == 1) {
     476        numberMatches = 1;
     477        firstMatch = iParam;
     478        break;
     479      } else {
     480        if (match && firstMatch < 0)
     481          firstMatch = iParam;
     482        numberMatches += match >> 1;
     483      }
     484    }
     485    ClpSimplex *thisModel = models + iModel;
     486    if (iParam < numberParameters && !numberQuery) {
     487      // found
     488      CbcOrClpParam found = parameters[iParam];
     489      CbcOrClpParameterType type = found.type();
     490      int valid;
     491      numberGoodCommands++;
     492      if (type == CBC_PARAM_GENERALQUERY) {
     493        std::cout << "In argument list keywords have leading - "
     494                     ", -stdin or just - switches to stdin"
     495                  << std::endl;
     496        std::cout << "One command per line (and no -)" << std::endl;
     497        std::cout << "abcd? gives list of possibilities, if only one + explanation" << std::endl;
     498        std::cout << "abcd?? adds explanation, if only one fuller help" << std::endl;
     499        std::cout << "abcd without value (where expected) gives current value" << std::endl;
     500        std::cout << "abcd value sets value" << std::endl;
     501        std::cout << "Commands are:" << std::endl;
     502        int maxAcross = 10;
     503        bool evenHidden = false;
     504        int printLevel = parameters[whichParam(CLP_PARAM_STR_ALLCOMMANDS,
     505                                      numberParameters, parameters)]
     506                           .currentOptionAsInteger();
     507        int convertP[] = { 2, 1, 0 };
     508        printLevel = convertP[printLevel];
     509        if ((verbose & 8) != 0) {
     510          // even hidden
     511          evenHidden = true;
     512          verbose &= ~8;
     513        }
     514#ifdef COIN_HAS_ASL
     515        if (verbose < 4 && usingAmpl)
     516          verbose += 4;
     517#endif
     518        if (verbose)
     519          maxAcross = 1;
     520        int limits[] = { 1, 101, 201, 401, 601 };
     521        std::vector< std::string > types;
     522        types.push_back("Double parameters:");
     523        types.push_back("Int parameters:");
     524        types.push_back("Keyword parameters:");
     525        types.push_back("Actions or string parameters:");
     526        int iType;
     527        for (iType = 0; iType < 4; iType++) {
     528          int across = 0;
     529          int lengthLine = 0;
     530          if ((verbose % 4) != 0)
     531            std::cout << std::endl;
     532          std::cout << types[iType] << std::endl;
     533          if ((verbose & 2) != 0)
     534            std::cout << std::endl;
     535          for (iParam = 0; iParam < numberParameters; iParam++) {
     536            int type = parameters[iParam].type();
     537            //printf("%d type %d limits %d %d display %d\n",iParam,
     538            //   type,limits[iType],limits[iType+1],parameters[iParam].displayThis());
     539            if ((parameters[iParam].displayThis() >= printLevel || evenHidden) && type >= limits[iType]
     540              && type < limits[iType + 1]) {
     541              if (!across) {
     542                if ((verbose & 2) != 0)
     543                  std::cout << "Command ";
     544              }
     545              int length = parameters[iParam].lengthMatchName() + 1;
     546              if (lengthLine + length > 80) {
     547                std::cout << std::endl;
     548                across = 0;
     549                lengthLine = 0;
     550              }
     551              std::cout << " " << parameters[iParam].matchName();
     552              lengthLine += length;
     553              across++;
     554              if (across == maxAcross) {
     555                across = 0;
     556                if (verbose) {
     557                  // put out description as well
     558                  if ((verbose & 1) != 0)
     559                    std::cout << parameters[iParam].shortHelp();
     560                  std::cout << std::endl;
     561                  if ((verbose & 2) != 0) {
     562                    std::cout << "---- description" << std::endl;
     563                    parameters[iParam].printLongHelp();
     564                    std::cout << "----" << std::endl
     565                              << std::endl;
     566                  }
     567                } else {
     568                  std::cout << std::endl;
     569                }
     570              }
     571            }
     572          }
     573          if (across)
     574            std::cout << std::endl;
     575        }
     576      } else if (type == CBC_PARAM_FULLGENERALQUERY) {
     577        std::cout << "Full list of commands is:" << std::endl;
     578        int maxAcross = 5;
     579        int limits[] = { 1, 101, 201, 401, 601 };
     580        std::vector< std::string > types;
     581        types.push_back("Double parameters:");
     582        types.push_back("Int parameters:");
     583        types.push_back("Keyword parameters and others:");
     584        types.push_back("Actions:");
     585        int iType;
     586        for (iType = 0; iType < 4; iType++) {
     587          int across = 0;
     588          std::cout << types[iType] << std::endl;
     589          for (iParam = 0; iParam < numberParameters; iParam++) {
     590            int type = parameters[iParam].type();
     591            if (type >= limits[iType]
     592              && type < limits[iType + 1]) {
     593              if (!across)
     594                std::cout << "  ";
     595              std::cout << parameters[iParam].matchName() << "  ";
     596              across++;
     597              if (across == maxAcross) {
     598                std::cout << std::endl;
     599                across = 0;
     600              }
     601            }
     602          }
     603          if (across)
     604            std::cout << std::endl;
     605        }
     606      } else if (type < 101) {
     607        // get next field as double
     608        double value = CoinReadGetDoubleField(argc, argv, &valid);
     609        if (!valid) {
     610          parameters[iParam].setDoubleParameter(thisModel, value);
     611        } else if (valid == 1) {
     612          std::cout << " is illegal for double parameter " << parameters[iParam].name() << " value remains " << parameters[iParam].doubleValue() << std::endl;
     613        } else {
     614          std::cout << parameters[iParam].name() << " has value " << parameters[iParam].doubleValue() << std::endl;
     615        }
     616      } else if (type < 201) {
     617        // get next field as int
     618        int value = CoinReadGetIntField(argc, argv, &valid);
     619        if (!valid) {
     620          if (parameters[iParam].type() == CLP_PARAM_INT_PRESOLVEPASS)
     621            preSolve = value;
     622          else if (parameters[iParam].type() == CLP_PARAM_INT_IDIOT)
     623            doIdiot = value;
     624          else if (parameters[iParam].type() == CLP_PARAM_INT_SPRINT)
     625            doSprint = value;
     626          else if (parameters[iParam].type() == CLP_PARAM_INT_OUTPUTFORMAT)
     627            outputFormat = value;
     628          else if (parameters[iParam].type() == CLP_PARAM_INT_SLPVALUE)
     629            slpValue = value;
     630          else if (parameters[iParam].type() == CLP_PARAM_INT_CPP)
     631            cppValue = value;
     632          else if (parameters[iParam].type() == CLP_PARAM_INT_PRESOLVEOPTIONS)
     633            presolveOptions = value;
     634          else if (parameters[iParam].type() == CLP_PARAM_INT_PRINTOPTIONS)
     635            printOptions = value;
     636          else if (parameters[iParam].type() == CLP_PARAM_INT_SUBSTITUTION)
     637            substitution = value;
     638          else if (parameters[iParam].type() == CLP_PARAM_INT_DUALIZE)
     639            dualize = value;
     640          else if (parameters[iParam].type() == CLP_PARAM_INT_VERBOSE)
     641            verbose = value;
     642          parameters[iParam].setIntParameter(thisModel, value);
     643        } else if (valid == 1) {
     644          std::cout << " is illegal for integer parameter " << parameters[iParam].name() << " value remains " << parameters[iParam].intValue() << std::endl;
     645        } else {
     646          std::cout << parameters[iParam].name() << " has value " << parameters[iParam].intValue() << std::endl;
     647        }
     648      } else if (type < 401) {
     649        // one of several strings
     650        std::string value = CoinReadGetString(argc, argv);
     651        int action = parameters[iParam].parameterOption(value);
     652        if (action < 0) {
     653          if (value != "EOL") {
     654            // no match
     655            parameters[iParam].printOptions();
    246656          } else {
    247                directory = ".\\";
    248 #              ifdef COIN_MSVS
    249                // Visual Studio builds are deeper
    250                dirSample = "..\\..\\..\\..\\Data\\Sample\\";
    251                dirNetlib = "..\\..\\..\\..\\Data\\Netlib\\";
    252                dirMiplib = "..\\..\\..\\..\\Data\\miplib3\\";
    253 #              else
    254                dirSample = "..\\..\\Data\\Sample\\";
    255                dirNetlib = "..\\..\\Data\\Netlib\\";
    256                dirMiplib = "..\\..\\Data\\miplib3\\";
    257 #              endif
    258           }
    259           std::string defaultDirectory = directory;
    260           std::string importFile = "";
    261           std::string exportFile = "default.mps";
    262           std::string importBasisFile = "";
    263           int basisHasValues = 0;
    264           int substitution = 3;
    265           int dualize = 3;  // dualize if looks promising
    266           std::string exportBasisFile = "default.bas";
    267           std::string saveFile = "default.prob";
    268           std::string restoreFile = "default.prob";
    269           std::string solutionFile = "stdout";
    270           std::string solutionSaveFile = "solution.file";
    271           std::string printMask = "";
    272           CbcOrClpParam parameters[CBCMAXPARAMETERS];
    273           int numberParameters ;
    274           establishParams(numberParameters, parameters) ;
    275           parameters[whichParam(CLP_PARAM_ACTION_BASISIN, numberParameters, parameters)].setStringValue(importBasisFile);
    276           parameters[whichParam(CLP_PARAM_ACTION_BASISOUT, numberParameters, parameters)].setStringValue(exportBasisFile);
    277           parameters[whichParam(CLP_PARAM_ACTION_PRINTMASK, numberParameters, parameters)].setStringValue(printMask);
    278           parameters[whichParam(CLP_PARAM_ACTION_DIRECTORY, numberParameters, parameters)].setStringValue(directory);
    279           parameters[whichParam(CLP_PARAM_ACTION_DIRSAMPLE, numberParameters, parameters)].setStringValue(dirSample);
    280           parameters[whichParam(CLP_PARAM_ACTION_DIRNETLIB, numberParameters, parameters)].setStringValue(dirNetlib);
    281           parameters[whichParam(CBC_PARAM_ACTION_DIRMIPLIB, numberParameters, parameters)].setStringValue(dirMiplib);
    282           parameters[whichParam(CLP_PARAM_DBL_DUALBOUND, numberParameters, parameters)].setDoubleValue(models->dualBound());
    283           parameters[whichParam(CLP_PARAM_DBL_DUALTOLERANCE, numberParameters, parameters)].setDoubleValue(models->dualTolerance());
    284           parameters[whichParam(CLP_PARAM_ACTION_EXPORT, numberParameters, parameters)].setStringValue(exportFile);
    285           parameters[whichParam(CLP_PARAM_INT_IDIOT, numberParameters, parameters)].setIntValue(doIdiot);
    286           parameters[whichParam(CLP_PARAM_ACTION_IMPORT, numberParameters, parameters)].setStringValue(importFile);
    287           parameters[whichParam(CLP_PARAM_INT_SOLVERLOGLEVEL, numberParameters, parameters)].setIntValue(models->logLevel());
    288           parameters[whichParam(CLP_PARAM_INT_MAXFACTOR, numberParameters, parameters)].setIntValue(models->factorizationFrequency());
    289           parameters[whichParam(CLP_PARAM_INT_MAXITERATION, numberParameters, parameters)].setIntValue(models->maximumIterations());
    290           parameters[whichParam(CLP_PARAM_INT_OUTPUTFORMAT, numberParameters, parameters)].setIntValue(outputFormat);
    291           parameters[whichParam(CLP_PARAM_INT_PRESOLVEPASS, numberParameters, parameters)].setIntValue(preSolve);
    292           parameters[whichParam(CLP_PARAM_INT_PERTVALUE, numberParameters, parameters)].setIntValue(models->perturbation());
    293           parameters[whichParam(CLP_PARAM_DBL_PRIMALTOLERANCE, numberParameters, parameters)].setDoubleValue(models->primalTolerance());
    294           parameters[whichParam(CLP_PARAM_DBL_PRIMALWEIGHT, numberParameters, parameters)].setDoubleValue(models->infeasibilityCost());
    295           parameters[whichParam(CLP_PARAM_ACTION_RESTORE, numberParameters, parameters)].setStringValue(restoreFile);
    296           parameters[whichParam(CLP_PARAM_ACTION_SAVE, numberParameters, parameters)].setStringValue(saveFile);
    297           parameters[whichParam(CLP_PARAM_DBL_TIMELIMIT, numberParameters, parameters)].setDoubleValue(models->maximumSeconds());
    298           parameters[whichParam(CLP_PARAM_ACTION_SOLUTION, numberParameters, parameters)].setStringValue(solutionFile);
    299           parameters[whichParam(CLP_PARAM_ACTION_SAVESOL, numberParameters, parameters)].setStringValue(solutionSaveFile);
    300           parameters[whichParam(CLP_PARAM_INT_SPRINT, numberParameters, parameters)].setIntValue(doSprint);
    301           parameters[whichParam(CLP_PARAM_INT_SUBSTITUTION, numberParameters, parameters)].setIntValue(substitution);
    302           parameters[whichParam(CLP_PARAM_INT_DUALIZE, numberParameters, parameters)].setIntValue(dualize);
    303           parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, numberParameters, parameters)].setDoubleValue(1.0e-8);
    304           int verbose = 0;
    305 
    306           // total number of commands read
    307           int numberGoodCommands = 0;
    308           bool * goodModels = new bool[1];
    309           goodModels[0] = false;
    310           if (models[0].numberRows()||models[0].numberColumns()) {
    311             // model already built
    312             goodModels[0]=true;
    313             numberGoodCommands=1;
    314           }
     657            // print current value
     658            std::cout << parameters[iParam].name() << " has value " << parameters[iParam].currentOption() << std::endl;
     659          }
     660        } else {
     661          parameters[iParam].setCurrentOption(action);
     662          // for now hard wired
     663          switch (type) {
     664          case CLP_PARAM_STR_DIRECTION:
     665            if (action == 0) {
     666              models[iModel].setOptimizationDirection(1);
     667#ifdef ABC_INHERIT
     668              thisModel->setOptimizationDirection(1);
     669#endif
     670            } else if (action == 1) {
     671              models[iModel].setOptimizationDirection(-1);
     672#ifdef ABC_INHERIT
     673              thisModel->setOptimizationDirection(-1);
     674#endif
     675            } else {
     676              models[iModel].setOptimizationDirection(0);
     677#ifdef ABC_INHERIT
     678              thisModel->setOptimizationDirection(0);
     679#endif
     680            }
     681            break;
     682          case CLP_PARAM_STR_DUALPIVOT:
     683            if (action == 0) {
     684              ClpDualRowSteepest steep(3);
     685              thisModel->setDualRowPivotAlgorithm(steep);
     686#ifdef ABC_INHERIT
     687              AbcDualRowSteepest steep2(3);
     688              models[iModel].setDualRowPivotAlgorithm(steep2);
     689#endif
     690            } else if (action == 1) {
     691              //ClpDualRowDantzig dantzig;
     692              ClpDualRowDantzig dantzig;
     693              thisModel->setDualRowPivotAlgorithm(dantzig);
     694#ifdef ABC_INHERIT
     695              AbcDualRowDantzig dantzig2;
     696              models[iModel].setDualRowPivotAlgorithm(dantzig2);
     697#endif
     698            } else if (action == 2) {
     699              // partial steep
     700              ClpDualRowSteepest steep(2);
     701              thisModel->setDualRowPivotAlgorithm(steep);
     702#ifdef ABC_INHERIT
     703              AbcDualRowSteepest steep2(2);
     704              models[iModel].setDualRowPivotAlgorithm(steep2);
     705#endif
     706            } else if (action == 3) {
     707              ClpDualRowSteepest steep;
     708              thisModel->setDualRowPivotAlgorithm(steep);
     709#ifdef ABC_INHERIT
     710              AbcDualRowSteepest steep2;
     711              models[iModel].setDualRowPivotAlgorithm(steep2);
     712#endif
     713            } else if (action == 4) {
     714              // Positive edge steepest
     715              ClpPEDualRowSteepest p(fabs(parameters[whichParam(CLP_PARAM_DBL_PSI, numberParameters, parameters)].doubleValue()));
     716              thisModel->setDualRowPivotAlgorithm(p);
     717            } else if (action == 5) {
     718              // Positive edge Dantzig
     719              ClpPEDualRowDantzig p(fabs(parameters[whichParam(CLP_PARAM_DBL_PSI, numberParameters, parameters)].doubleValue()));
     720              thisModel->setDualRowPivotAlgorithm(p);
     721            }
     722            break;
     723          case CLP_PARAM_STR_PRIMALPIVOT:
     724            if (action == 0) {
     725              ClpPrimalColumnSteepest steep(3);
     726              thisModel->setPrimalColumnPivotAlgorithm(steep);
     727            } else if (action == 1) {
     728              ClpPrimalColumnSteepest steep(0);
     729              thisModel->setPrimalColumnPivotAlgorithm(steep);
     730            } else if (action == 2) {
     731              ClpPrimalColumnDantzig dantzig;
     732              thisModel->setPrimalColumnPivotAlgorithm(dantzig);
     733            } else if (action == 3) {
     734              ClpPrimalColumnSteepest steep(4);
     735              thisModel->setPrimalColumnPivotAlgorithm(steep);
     736            } else if (action == 4) {
     737              ClpPrimalColumnSteepest steep(1);
     738              thisModel->setPrimalColumnPivotAlgorithm(steep);
     739            } else if (action == 5) {
     740              ClpPrimalColumnSteepest steep(2);
     741              thisModel->setPrimalColumnPivotAlgorithm(steep);
     742            } else if (action == 6) {
     743              ClpPrimalColumnSteepest steep(10);
     744              thisModel->setPrimalColumnPivotAlgorithm(steep);
     745            } else if (action == 7) {
     746              // Positive edge steepest
     747              ClpPEPrimalColumnSteepest p(fabs(parameters[whichParam(CLP_PARAM_DBL_PSI, numberParameters, parameters)].doubleValue()));
     748              thisModel->setPrimalColumnPivotAlgorithm(p);
     749            } else if (action == 8) {
     750              // Positive edge Dantzig
     751              ClpPEPrimalColumnDantzig p(fabs(parameters[whichParam(CLP_PARAM_DBL_PSI, numberParameters, parameters)].doubleValue()));
     752              thisModel->setPrimalColumnPivotAlgorithm(p);
     753            }
     754            break;
     755          case CLP_PARAM_STR_SCALING:
     756            thisModel->scaling(action);
     757            break;
     758          case CLP_PARAM_STR_AUTOSCALE:
     759            thisModel->setAutomaticScaling(action != 0);
     760            break;
     761          case CLP_PARAM_STR_SPARSEFACTOR:
     762            thisModel->setSparseFactorization((1 - action) != 0);
     763            break;
     764          case CLP_PARAM_STR_BIASLU:
     765            thisModel->factorization()->setBiasLU(action);
     766            break;
     767          case CLP_PARAM_STR_PERTURBATION:
     768            if (action == 0)
     769              thisModel->setPerturbation(50);
     770            else
     771              thisModel->setPerturbation(100);
     772            break;
     773          case CLP_PARAM_STR_ERRORSALLOWED:
     774            allowImportErrors = action;
     775            break;
     776          case CLP_PARAM_STR_ABCWANTED:
     777#ifdef ABC_INHERIT
     778            models[iModel].setAbcState(action);
     779#elif ABOCA_LITE
     780            setAbcState(action);
     781            {
     782              char temp[3];
     783              sprintf(temp, "%d", action);
     784              __cilkrts_set_param("nworkers", temp);
     785              printf("setting cilk workers to %d\n", action);
     786            }
     787#endif
     788            break;
     789          case CLP_PARAM_STR_INTPRINT:
     790            printMode = action;
     791            break;
     792          case CLP_PARAM_STR_KEEPNAMES:
     793            keepImportNames = 1 - action;
     794            break;
     795          case CLP_PARAM_STR_PRESOLVE:
     796            if (action == 0)
     797              preSolve = DEFAULT_PRESOLVE_PASSES;
     798            else if (action == 1)
     799              preSolve = 0;
     800            else if (action == 2)
     801              preSolve = 10;
     802            else
     803              preSolveFile = true;
     804            break;
     805          case CLP_PARAM_STR_PFI:
     806            thisModel->factorization()->setForrestTomlin(action == 0);
     807            break;
     808          case CLP_PARAM_STR_FACTORIZATION:
     809            models[iModel].factorization()->forceOtherFactorization(action);
     810#ifdef ABC_INHERIT
     811            thisModel->factorization()->forceOtherFactorization(action);
     812#endif
     813            break;
     814          case CLP_PARAM_STR_CRASH:
     815            doCrash = action;
     816            break;
     817          case CLP_PARAM_STR_VECTOR:
     818            doVector = action;
     819            break;
     820          case CLP_PARAM_STR_MESSAGES:
     821            models[iModel].messageHandler()->setPrefix(action != 0);
     822#ifdef ABC_INHERIT
     823            thisModel->messageHandler()->setPrefix(action != 0);
     824#endif
     825            break;
     826          case CLP_PARAM_STR_CHOLESKY:
     827            choleskyType = action;
     828            break;
     829          case CLP_PARAM_STR_GAMMA:
     830            gamma = action;
     831            break;
     832          case CLP_PARAM_STR_BARRIERSCALE:
     833            scaleBarrier = action;
     834            break;
     835          case CLP_PARAM_STR_KKT:
     836            doKKT = action;
     837            break;
     838          case CLP_PARAM_STR_CROSSOVER:
     839            crossover = action;
     840            break;
     841          default:
     842            //abort();
     843            break;
     844          }
     845        }
     846      } else {
     847        // action
     848        if (type == CLP_PARAM_ACTION_EXIT) {
    315849#ifdef COIN_HAS_ASL
    316           ampl_info info;
    317           int usingAmpl=0;
    318           CoinMessageHandler * generalMessageHandler = models->messageHandler();
    319           generalMessageHandler->setPrefix(false);
    320           CoinMessages generalMessages = models->messages();
    321           char generalPrint[10000];
    322           {
    323             bool noPrinting_=false;
    324             memset(&info, 0, sizeof(info));
    325             if (argc > 2 && !strcmp(argv[2], "-AMPL")) {
    326               usingAmpl = 1;
    327               // see if log in list
    328               noPrinting_ = true;
    329               for (int i = 1; i < argc; i++) {
    330                     if (!strncmp(argv[i], "log", 3)) {
    331                         const char * equals = strchr(argv[i], '=');
    332                         if (equals && atoi(equals + 1) > 0) {
    333                             noPrinting_ = false;
    334                             info.logLevel = atoi(equals + 1);
    335                             int log = whichParam(CLP_PARAM_INT_LOGLEVEL, numberParameters, parameters);
    336                             parameters[log].setIntValue(info.logLevel);
    337                             // mark so won't be overWritten
    338                             info.numberRows = -1234567;
    339                             break;
    340                         }
     850          if (usingAmpl) {
     851            writeAmpl(&info);
     852            freeArrays2(&info);
     853            freeArgs(&info);
     854          }
     855#endif
     856          break; // stop all
     857        }
     858        switch (type) {
     859        case CLP_PARAM_ACTION_DUALSIMPLEX:
     860        case CLP_PARAM_ACTION_PRIMALSIMPLEX:
     861        case CLP_PARAM_ACTION_EITHERSIMPLEX:
     862        case CLP_PARAM_ACTION_BARRIER:
     863          // synonym for dual
     864        case CBC_PARAM_ACTION_BAB:
     865          if (goodModels[iModel]) {
     866#ifndef ABC_INHERIT
     867            ClpSimplex *clpModel = models + iModel;
     868#else
     869            ClpSimplex *clpModel = static_cast< ClpSimplex * >(models + iModel);
     870#endif
     871            //openblas_set_num_threads(4);
     872            // deal with positive edge
     873            double psi = parameters[whichParam(CLP_PARAM_DBL_PSI, numberParameters, parameters)].doubleValue();
     874            if (psi > 0.0) {
     875              ClpDualRowPivot *dualp = clpModel->dualRowPivot();
     876              ClpDualRowSteepest *d1 = dynamic_cast< ClpDualRowSteepest * >(dualp);
     877              ClpDualRowDantzig *d2 = dynamic_cast< ClpDualRowDantzig * >(dualp);
     878              if (d1) {
     879                ClpPEDualRowSteepest p(psi, d1->mode());
     880                clpModel->setDualRowPivotAlgorithm(p);
     881              } else if (d2) {
     882                ClpPEDualRowDantzig p(psi);
     883                clpModel->setDualRowPivotAlgorithm(p);
     884              }
     885              ClpPrimalColumnPivot *primalp = clpModel->primalColumnPivot();
     886              ClpPrimalColumnSteepest *p1 = dynamic_cast< ClpPrimalColumnSteepest * >(primalp);
     887              ClpPrimalColumnDantzig *p2 = dynamic_cast< ClpPrimalColumnDantzig * >(primalp);
     888              if (p1) {
     889                ClpPEPrimalColumnSteepest p(psi, p1->mode());
     890                clpModel->setPrimalColumnPivotAlgorithm(p);
     891              } else if (p2) {
     892                ClpPEPrimalColumnDantzig p(psi);
     893                clpModel->setPrimalColumnPivotAlgorithm(p);
     894              }
     895            }
     896            if (type == CLP_PARAM_ACTION_EITHERSIMPLEX || type == CBC_PARAM_ACTION_BAB)
     897              models[iModel].setMoreSpecialOptions(16384 | models[iModel].moreSpecialOptions());
     898            double objScale = parameters[whichParam(CLP_PARAM_DBL_OBJSCALE2, numberParameters, parameters)].doubleValue();
     899            if (objScale != 1.0) {
     900              int iColumn;
     901              int numberColumns = models[iModel].numberColumns();
     902              double *dualColumnSolution = models[iModel].dualColumnSolution();
     903              ClpObjective *obj = models[iModel].objectiveAsObject();
     904              assert(dynamic_cast< ClpLinearObjective * >(obj));
     905              double offset;
     906              double *objective = obj->gradient(NULL, NULL, offset, true);
     907              for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     908                dualColumnSolution[iColumn] *= objScale;
     909                objective[iColumn] *= objScale;
     910                ;
     911              }
     912              int iRow;
     913              int numberRows = models[iModel].numberRows();
     914              double *dualRowSolution = models[iModel].dualRowSolution();
     915              for (iRow = 0; iRow < numberRows; iRow++)
     916                dualRowSolution[iRow] *= objScale;
     917              models[iModel].setObjectiveOffset(objScale * models[iModel].objectiveOffset());
     918            }
     919            ClpSolve::SolveType method;
     920            ClpSolve::PresolveType presolveType;
     921            ClpSolve solveOptions;
     922#ifndef ABC_INHERIT
     923            ClpSimplex *model2 = models + iModel;
     924#else
     925            AbcSimplex *model2 = models + iModel;
     926#endif
     927            if (type == CLP_PARAM_ACTION_EITHERSIMPLEX || type == CBC_PARAM_ACTION_BAB)
     928              solveOptions.setSpecialOption(3, 0); // allow +-1
     929            if (dualize == 4) {
     930              solveOptions.setSpecialOption(4, 77);
     931              dualize = 0;
     932            }
     933            if (dualize) {
     934              bool tryIt = true;
     935              double fractionColumn = 1.0;
     936              double fractionRow = 1.0;
     937              if (dualize == 3) {
     938                dualize = 1;
     939                int numberColumns = model2->numberColumns();
     940                int numberRows = model2->numberRows();
     941#ifndef ABC_INHERIT
     942                if (numberRows < 50000 || 5 * numberColumns > numberRows) {
     943#else
     944                if (numberRows < 500 || 4 * numberColumns > numberRows) {
     945#endif
     946                  tryIt = false;
     947                } else {
     948                  fractionColumn = 0.1;
     949                  fractionRow = 0.3;
     950                }
     951              }
     952              if (tryIt) {
     953                ClpSimplex *thisModel = model2;
     954                thisModel = static_cast< ClpSimplexOther * >(thisModel)->dualOfModel(fractionRow, fractionColumn);
     955                if (thisModel) {
     956                  printf("Dual of model has %d rows and %d columns\n",
     957                    thisModel->numberRows(), thisModel->numberColumns());
     958                  thisModel->setOptimizationDirection(1.0);
     959#ifndef ABC_INHERIT
     960                  model2 = thisModel;
     961#else
     962                  int abcState = model2->abcState();
     963                  model2 = new AbcSimplex(*thisModel);
     964                  model2->setAbcState(abcState);
     965                  delete thisModel;
     966#endif
     967                } else {
     968                  thisModel = models + iModel;
     969                  dualize = 0;
     970                }
     971              } else {
     972                dualize = 0;
     973              }
     974            }
     975            if (preSolveFile)
     976              presolveOptions |= 0x40000000;
     977            // allow dependency
     978            presolveOptions |= 32768;
     979            solveOptions.setPresolveActions(presolveOptions);
     980            solveOptions.setSubstitution(substitution);
     981            if (preSolve != DEFAULT_PRESOLVE_PASSES && preSolve) {
     982              presolveType = ClpSolve::presolveNumber;
     983              if (preSolve < 0) {
     984                preSolve = -preSolve;
     985                if (preSolve <= 100) {
     986                  presolveType = ClpSolve::presolveNumber;
     987                  printf("Doing %d presolve passes - picking up non-costed slacks\n",
     988                    preSolve);
     989                  solveOptions.setDoSingletonColumn(true);
     990                } else {
     991                  preSolve -= 100;
     992                  presolveType = ClpSolve::presolveNumberCost;
     993                  printf("Doing %d presolve passes - picking up costed slacks\n",
     994                    preSolve);
     995                }
     996              }
     997            } else if (preSolve) {
     998              presolveType = ClpSolve::presolveOn;
     999            } else {
     1000              presolveType = ClpSolve::presolveOff;
     1001            }
     1002            solveOptions.setPresolveType(presolveType, preSolve);
     1003            if (type == CLP_PARAM_ACTION_DUALSIMPLEX || type == CBC_PARAM_ACTION_BAB) {
     1004              method = ClpSolve::useDual;
     1005            } else if (type == CLP_PARAM_ACTION_PRIMALSIMPLEX) {
     1006              method = ClpSolve::usePrimalorSprint;
     1007            } else if (type == CLP_PARAM_ACTION_EITHERSIMPLEX) {
     1008              method = ClpSolve::automatic;
     1009              if (doCrash > 3) {
     1010                solveOptions.setSpecialOption(6, 1, doCrash - 3);
     1011                doCrash = 0;
     1012              }
     1013              if (doIdiot > 0)
     1014                solveOptions.setSpecialOption(1, 2, doIdiot);
     1015            } else {
     1016              method = ClpSolve::useBarrier;
     1017              if (doIdiot > 0)
     1018                solveOptions.setSpecialOption(1, 2, doIdiot); // dense threshold
     1019              if (crossover == 1) {
     1020                method = ClpSolve::useBarrierNoCross;
     1021              } else if (crossover == 2) {
     1022                ClpObjective *obj = models[iModel].objectiveAsObject();
     1023                if (obj->type() > 1) {
     1024                  method = ClpSolve::useBarrierNoCross;
     1025                  presolveType = ClpSolve::presolveOff;
     1026                  solveOptions.setPresolveType(presolveType, preSolve);
     1027                }
     1028              }
     1029            }
     1030            solveOptions.setSolveType(method);
     1031            solveOptions.setSpecialOption(5, printOptions & 1);
     1032            if (doVector) {
     1033              ClpMatrixBase *matrix = models[iModel].clpMatrix();
     1034              if (dynamic_cast< ClpPackedMatrix * >(matrix)) {
     1035                ClpPackedMatrix *clpMatrix = dynamic_cast< ClpPackedMatrix * >(matrix);
     1036                clpMatrix->makeSpecialColumnCopy();
     1037              }
     1038            }
     1039            if (method == ClpSolve::useDual) {
     1040              // dual
     1041              if (doCrash && doCrash < 4)
     1042                solveOptions.setSpecialOption(0, 1, doCrash); // crash
     1043              else if (doIdiot)
     1044                solveOptions.setSpecialOption(0, 2, doIdiot); // possible idiot
     1045            } else if (method == ClpSolve::usePrimalorSprint) {
     1046              // primal
     1047              // if slp turn everything off
     1048              if (slpValue > 0) {
     1049                doCrash = false;
     1050                doSprint = 0;
     1051                doIdiot = -1;
     1052                solveOptions.setSpecialOption(1, 10, slpValue); // slp
     1053                method = ClpSolve::usePrimal;
     1054              }
     1055              if (doCrash > 3) {
     1056                solveOptions.setSpecialOption(6, 1, doCrash - 3);
     1057                doCrash = 0;
     1058              }
     1059              if (doCrash > 0) {
     1060                solveOptions.setSpecialOption(1, 1, doCrash); // crash
     1061              } else if (doSprint > 0) {
     1062                // sprint overrides idiot
     1063                solveOptions.setSpecialOption(1, 3, doSprint); // sprint
     1064              } else if (doIdiot > 0) {
     1065                solveOptions.setSpecialOption(1, 2, doIdiot); // idiot
     1066              } else if (slpValue <= 0) {
     1067                if (doIdiot == 0) {
     1068                  if (doSprint == 0)
     1069                    solveOptions.setSpecialOption(1, 4); // all slack
     1070                  else
     1071                    solveOptions.setSpecialOption(1, 9); // all slack or sprint
     1072                } else {
     1073                  if (doSprint == 0)
     1074                    solveOptions.setSpecialOption(1, 8); // all slack or idiot
     1075                  else
     1076                    solveOptions.setSpecialOption(1, 7); // initiative
     1077                }
     1078              }
     1079              if (basisHasValues == -1)
     1080                solveOptions.setSpecialOption(1, 11); // switch off values
     1081            } else if (method == ClpSolve::useBarrier || method == ClpSolve::useBarrierNoCross) {
     1082              int barrierOptions = choleskyType;
     1083              if (scaleBarrier) {
     1084                if ((scaleBarrier & 1) != 0)
     1085                  barrierOptions |= 8;
     1086                barrierOptions |= 2048 * (scaleBarrier >> 1);
     1087              }
     1088              if (doKKT)
     1089                barrierOptions |= 16;
     1090              if (gamma)
     1091                barrierOptions |= 32 * gamma;
     1092              if (crossover == 3)
     1093                barrierOptions |= 256; // try presolve in crossover
     1094              solveOptions.setSpecialOption(4, barrierOptions);
     1095            }
     1096            int status;
     1097            if (cppValue >= 0) {
     1098              // generate code
     1099              FILE *fp = fopen("user_driver.cpp", "w");
     1100              if (fp) {
     1101                // generate enough to do solveOptions
     1102                model2->generateCpp(fp);
     1103                solveOptions.generateCpp(fp);
     1104                fclose(fp);
     1105                // now call generate code
     1106                generateCode("user_driver.cpp", cppValue);
     1107              } else {
     1108                std::cout << "Unable to open file user_driver.cpp" << std::endl;
     1109              }
     1110            }
     1111#ifdef CLP_MULTIPLE_FACTORIZATIONS
     1112            int denseCode = parameters[whichParam(CBC_PARAM_INT_DENSE, numberParameters, parameters)].intValue();
     1113            if (denseCode != -1)
     1114              model2->factorization()->setGoDenseThreshold(denseCode);
     1115            int smallCode = parameters[whichParam(CBC_PARAM_INT_SMALLFACT, numberParameters, parameters)].intValue();
     1116            if (smallCode != -1)
     1117              model2->factorization()->setGoSmallThreshold(smallCode);
     1118            model2->factorization()->goDenseOrSmall(model2->numberRows());
     1119#endif
     1120            try {
     1121              status = model2->initialSolve(solveOptions);
     1122#ifdef COIN_HAS_ASL
     1123              if (usingAmpl) {
     1124                double value = model2->getObjValue() * model2->getObjSense();
     1125                char buf[300];
     1126                int pos = 0;
     1127                int iStat = model2->status();
     1128                if (iStat == 0) {
     1129                  pos += sprintf(buf + pos, "optimal,");
     1130                } else if (iStat == 1) {
     1131                  // infeasible
     1132                  pos += sprintf(buf + pos, "infeasible,");
     1133                } else if (iStat == 2) {
     1134                  // unbounded
     1135                  pos += sprintf(buf + pos, "unbounded,");
     1136                } else if (iStat == 3) {
     1137                  pos += sprintf(buf + pos, "stopped on iterations or time,");
     1138                } else if (iStat == 4) {
     1139                  iStat = 7;
     1140                  pos += sprintf(buf + pos, "stopped on difficulties,");
     1141                } else if (iStat == 5) {
     1142                  iStat = 3;
     1143                  pos += sprintf(buf + pos, "stopped on ctrl-c,");
     1144                } else if (iStat == 6) {
     1145                  // bab infeasible
     1146                  pos += sprintf(buf + pos, "integer infeasible,");
     1147                  iStat = 1;
     1148                } else {
     1149                  pos += sprintf(buf + pos, "status unknown,");
     1150                  iStat = 6;
     1151                }
     1152                info.problemStatus = iStat;
     1153                info.objValue = value;
     1154                pos += sprintf(buf + pos, " objective %.*g", ampl_obj_prec(),
     1155                  value);
     1156                sprintf(buf + pos, "\n%d iterations",
     1157                  model2->getIterationCount());
     1158                free(info.primalSolution);
     1159                int numberColumns = model2->numberColumns();
     1160                info.primalSolution = reinterpret_cast< double * >(malloc(numberColumns * sizeof(double)));
     1161                CoinCopyN(model2->primalColumnSolution(), numberColumns, info.primalSolution);
     1162                int numberRows = model2->numberRows();
     1163                free(info.dualSolution);
     1164                info.dualSolution = reinterpret_cast< double * >(malloc(numberRows * sizeof(double)));
     1165                CoinCopyN(model2->dualRowSolution(), numberRows, info.dualSolution);
     1166                CoinWarmStartBasis *basis = model2->getBasis();
     1167                free(info.rowStatus);
     1168                info.rowStatus = reinterpret_cast< int * >(malloc(numberRows * sizeof(int)));
     1169                free(info.columnStatus);
     1170                info.columnStatus = reinterpret_cast< int * >(malloc(numberColumns * sizeof(int)));
     1171                // Put basis in
     1172                int i;
     1173                // free,basic,ub,lb are 0,1,2,3
     1174                for (i = 0; i < numberRows; i++) {
     1175                  CoinWarmStartBasis::Status status = basis->getArtifStatus(i);
     1176                  info.rowStatus[i] = status;
     1177                }
     1178                for (i = 0; i < numberColumns; i++) {
     1179                  CoinWarmStartBasis::Status status = basis->getStructStatus(i);
     1180                  info.columnStatus[i] = status;
     1181                }
     1182                // put buffer into info
     1183                strcpy(info.buffer, buf);
     1184                delete basis;
     1185              }
     1186#endif
     1187#ifndef NDEBUG
     1188              // if infeasible check ray
     1189              if (model2->status() == 1) {
     1190                ClpSimplex *simplex = model2;
     1191                if (simplex->ray()) {
     1192                  // make sure we use non-scaled versions
     1193                  ClpPackedMatrix *saveMatrix = simplex->swapScaledMatrix(NULL);
     1194                  double *saveScale = simplex->swapRowScale(NULL);
     1195                  // could use existing arrays
     1196                  int numberRows = simplex->numberRows();
     1197                  int numberColumns = simplex->numberColumns();
     1198                  double *farkas = new double[2 * numberColumns + numberRows];
     1199                  double *bound = farkas + numberColumns;
     1200                  double *effectiveRhs = bound + numberColumns;
     1201                  // get ray as user would
     1202                  double *ray = simplex->infeasibilityRay();
     1203                  // get farkas row
     1204                  memset(farkas, 0, (2 * numberColumns + numberRows) * sizeof(double));
     1205                  simplex->transposeTimes(-1.0, ray, farkas);
     1206                  // Put nonzero bounds in bound
     1207                  const double *columnLower = simplex->columnLower();
     1208                  const double *columnUpper = simplex->columnUpper();
     1209                  int numberBad = 0;
     1210                  for (int i = 0; i < numberColumns; i++) {
     1211                    double value = farkas[i];
     1212                    double boundValue = 0.0;
     1213                    if (simplex->getStatus(i) == ClpSimplex::basic) {
     1214                      // treat as zero if small
     1215                      if (fabs(value) < 1.0e-8) {
     1216                        value = 0.0;
     1217                        farkas[i] = 0.0;
     1218                      }
     1219                      if (value) {
     1220                        //printf("basic %d direction %d farkas %g\n",
     1221                        //         i,simplex->directionOut(),value);
     1222                        if (value < 0.0)
     1223                          boundValue = CoinMax(columnLower[i], -1.0e20);
     1224                        else
     1225                          boundValue = CoinMin(columnUpper[i], 1.0e20);
     1226                      }
     1227                    } else if (fabs(value) > 1.0e-10) {
     1228                      if (value < 0.0)
     1229                        boundValue = columnLower[i];
     1230                      else
     1231                        boundValue = columnUpper[i];
    3411232                    }
    342                 }
    343 
    344                 union {
    345                     void * voidModel;
    346                     CoinModel * model;
    347                 } coinModelStart;
    348                 coinModelStart.model = NULL;
    349                 int returnCode = readAmpl(&info, argc, const_cast<char **>(argv), & coinModelStart.voidModel);
    350                 if (returnCode)
    351                     return returnCode;
    352                 if (info.numberBinary+info.numberIntegers+info.numberSos
    353                     &&!info.starts) {
    354                   printf("Unable to handle integer problems\n");
    355                   return 1;
    356                 }
    357                 CbcOrClpRead_mode = 2; // so will start with parameters
    358                 // see if log in list (including environment)
    359                 for (int i = 1; i < info.numberArguments; i++) {
    360                     if (!strcmp(info.arguments[i], "log")) {
    361                         if (i < info.numberArguments - 1 && atoi(info.arguments[i+1]) > 0)
    362                             noPrinting_ = false;
    363                         break;
     1233                    bound[i] = boundValue;
     1234                    if (fabs(boundValue) > 1.0e10)
     1235                      numberBad++;
     1236                  }
     1237                  const double *rowLower = simplex->rowLower();
     1238                  const double *rowUpper = simplex->rowUpper();
     1239                  bool printBad = simplex->logLevel() > 3;
     1240                  //int pivotRow = simplex->spareIntArray_[3];
     1241                  //bool badPivot=pivotRow<0;
     1242                  for (int i = 0; i < numberRows; i++) {
     1243                    double value = ray[i];
     1244                    double rhsValue = 0.0;
     1245                    if (simplex->getRowStatus(i) == ClpSimplex::basic) {
     1246                      // treat as zero if small
     1247                      if (fabs(value) < 1.0e-8) {
     1248                        value = 0.0;
     1249                        ray[i] = 0.0;
     1250                      }
     1251                      if (value) {
     1252                        //printf("row basic %d direction %d ray %g\n",
     1253                        //         i,simplex->directionOut(),value);
     1254                        if (value < 0.0)
     1255                          rhsValue = rowLower[i];
     1256                        else
     1257                          rhsValue = rowUpper[i];
     1258                      }
     1259                    } else if (fabs(value) > 1.0e-10) {
     1260                      if (value < 0.0)
     1261                        rhsValue = rowLower[i];
     1262                      else
     1263                        rhsValue = rowUpper[i];
    3641264                    }
    365                 }
    366                 if (noPrinting_) {
    367                     models->messageHandler()->setLogLevel(0);
    368                     setCbcOrClpPrinting(false);
    369                 }
    370                 if (!noPrinting_)
    371                     printf("%d rows, %d columns and %d elements\n",
    372                            info.numberRows, info.numberColumns, info.numberElements);
    373                 if (!coinModelStart.model) {
    374                   // linear
    375                   models->loadProblem(info.numberColumns, info.numberRows,
    376                                       reinterpret_cast<const CoinBigIndex *>(info.starts),
    377                                         info.rows, info.elements,
    378                                         info.columnLower, info.columnUpper, info.objective,
    379                                         info.rowLower, info.rowUpper);
    380                 } else {
    381                   // QP
    382                   models->loadProblem(*(coinModelStart.model));
    383                 }
    384                 // If we had a solution use it
    385                 if (info.primalSolution) {
    386                     models->setColSolution(info.primalSolution);
    387                 }
    388                 // status
    389                 if (info.rowStatus) {
    390                     unsigned char * statusArray = models->statusArray();
    391                     int i;
    392                     for (i = 0; i < info.numberColumns; i++)
    393                         statusArray[i] = static_cast<unsigned char>(info.columnStatus[i]);
    394                     statusArray += info.numberColumns;
    395                     for (i = 0; i < info.numberRows; i++)
    396                         statusArray[i] = static_cast<unsigned char>(info.rowStatus[i]);
    397                 }
    398                 freeArrays1(&info);
    399                 // modify objective if necessary
    400                 models->setOptimizationDirection(info.direction);
    401                 models->setObjectiveOffset(-info.offset);
    402                 if (info.offset) {
    403                     sprintf(generalPrint, "Ampl objective offset is %g",
    404                             info.offset);
    405                     generalMessageHandler->message(CLP_GENERAL, generalMessages)
    406                     << generalPrint
    407                     << CoinMessageEol;
    408                 }
    409                 goodModels[0] = true;
    410                 // change argc etc
    411                 argc = info.numberArguments;
    412                 argv = const_cast<const char **>(info.arguments);
    413             }
    414         }
    415 #endif
    416 
    417           // Hidden stuff for barrier
    418           int choleskyType = 0;
    419           int gamma = 0;
    420           parameters[whichParam(CLP_PARAM_STR_BARRIERSCALE, numberParameters, parameters)].setCurrentOption(2);
    421           int scaleBarrier = 2;
    422           int doKKT = 0;
    423           int crossover = 2; // do crossover unless quadratic
    424 
    425           int iModel = 0;
    426           //models[0].scaling(1);
    427           //models[0].setDualBound(1.0e6);
    428           //models[0].setDualTolerance(1.0e-7);
    429           //ClpDualRowSteepest steep;
    430           //models[0].setDualRowPivotAlgorithm(steep);
    431           //ClpPrimalColumnSteepest steepP;
    432           //models[0].setPrimalColumnPivotAlgorithm(steepP);
    433           std::string field;
    434 
    435           while (1) {
    436                // next command
    437                field = CoinReadGetCommand(argc, argv);
    438 
    439                // exit if null or similar
    440                if (!field.length()) {
    441                     if (numberGoodCommands == 1 && goodModels[0]) {
    442                          // we just had file name - do dual or primal
    443                          field = "either";
    444                     } else if (!numberGoodCommands) {
    445                          // let's give the sucker a hint
    446                          std::cout
    447                                    << "Clp takes input from arguments ( - switches to stdin)"
    448                                    << std::endl
    449                                    << "Enter ? for list of commands or help" << std::endl;
    450                          field = "-";
    451                     } else {
    452                          break;
    453                     }
    454                }
    455 
    456                // see if ? at end
    457                int numberQuery = 0;
    458                if (field != "?" && field != "???") {
    459                     size_t length = field.length();
    460                     size_t i;
    461                     for (i = length - 1; i > 0; i--) {
    462                          if (field[i] == '?')
    463                               numberQuery++;
    464                          else
    465                               break;
    466                     }
    467                     field = field.substr(0, length - numberQuery);
    468                }
    469                // find out if valid command
    470                int iParam;
    471                int numberMatches = 0;
    472                int firstMatch = -1;
    473                for ( iParam = 0; iParam < numberParameters; iParam++ ) {
    474                     int match = parameters[iParam].matches(field);
    475                     if (match == 1) {
    476                          numberMatches = 1;
    477                          firstMatch = iParam;
    478                          break;
    479                     } else {
    480                          if (match && firstMatch < 0)
    481                               firstMatch = iParam;
    482                          numberMatches += match >> 1;
    483                     }
    484                }
    485                ClpSimplex * thisModel=models+iModel;
    486                if (iParam < numberParameters && !numberQuery) {
    487                     // found
    488                     CbcOrClpParam found = parameters[iParam];
    489                     CbcOrClpParameterType type = found.type();
    490                     int valid;
    491                     numberGoodCommands++;
    492                     if (type == CBC_PARAM_GENERALQUERY) {
    493                          std::cout << "In argument list keywords have leading - "
    494                                    ", -stdin or just - switches to stdin" << std::endl;
    495                          std::cout << "One command per line (and no -)" << std::endl;
    496                          std::cout << "abcd? gives list of possibilities, if only one + explanation" << std::endl;
    497                          std::cout << "abcd?? adds explanation, if only one fuller help" << std::endl;
    498                          std::cout << "abcd without value (where expected) gives current value" << std::endl;
    499                          std::cout << "abcd value sets value" << std::endl;
    500                          std::cout << "Commands are:" << std::endl;
    501                          int maxAcross = 10;
    502                          bool evenHidden = false;
    503                          int printLevel =
    504                               parameters[whichParam(CLP_PARAM_STR_ALLCOMMANDS,
    505                                                     numberParameters, parameters)].currentOptionAsInteger();
    506                          int convertP[] = {2, 1, 0};
    507                          printLevel = convertP[printLevel];
    508                          if ((verbose & 8) != 0) {
    509                               // even hidden
    510                               evenHidden = true;
    511                               verbose &= ~8;
    512                          }
    513 #ifdef COIN_HAS_ASL
    514                          if (verbose < 4 && usingAmpl)
    515                            verbose += 4;
    516 #endif
    517                          if (verbose)
    518                               maxAcross = 1;
    519                          int limits[] = {1, 101, 201, 401, 601};
    520                          std::vector<std::string> types;
    521                          types.push_back("Double parameters:");
    522                          types.push_back("Int parameters:");
    523                          types.push_back("Keyword parameters:");
    524                          types.push_back("Actions or string parameters:");
    525                          int iType;
    526                          for (iType = 0; iType < 4; iType++) {
    527                               int across = 0;
    528                               int lengthLine = 0;
    529                               if ((verbose % 4) != 0)
    530                                    std::cout << std::endl;
    531                               std::cout << types[iType] << std::endl;
    532                               if ((verbose & 2) != 0)
    533                                    std::cout << std::endl;
    534                               for ( iParam = 0; iParam < numberParameters; iParam++ ) {
    535                                    int type = parameters[iParam].type();
    536                                    //printf("%d type %d limits %d %d display %d\n",iParam,
    537                                    //   type,limits[iType],limits[iType+1],parameters[iParam].displayThis());
    538                                    if ((parameters[iParam].displayThis() >= printLevel || evenHidden) &&
    539                                              type >= limits[iType]
    540                                              && type < limits[iType+1]) {
    541                                         if (!across) {
    542                                              if ((verbose & 2) != 0)
    543                                                   std::cout << "Command ";
    544                                         }
    545                                         int length = parameters[iParam].lengthMatchName() + 1;
    546                                         if (lengthLine + length > 80) {
    547                                              std::cout << std::endl;
    548                                              across = 0;
    549                                              lengthLine = 0;
    550                                         }
    551                                         std::cout << " " << parameters[iParam].matchName();
    552                                         lengthLine += length ;
    553                                         across++;
    554                                         if (across == maxAcross) {
    555                                              across = 0;
    556                                              if (verbose) {
    557                                                   // put out description as well
    558                                                   if ((verbose & 1) != 0)
    559                                                        std::cout << parameters[iParam].shortHelp();
    560                                                   std::cout << std::endl;
    561                                                   if ((verbose & 2) != 0) {
    562                                                        std::cout << "---- description" << std::endl;
    563                                                        parameters[iParam].printLongHelp();
    564                                                        std::cout << "----" << std::endl << std::endl;
    565                                                   }
    566                                              } else {
    567                                                   std::cout << std::endl;
    568                                              }
    569                                         }
    570                                    }
    571                               }
    572                               if (across)
    573                                    std::cout << std::endl;
    574                          }
    575                     } else if (type == CBC_PARAM_FULLGENERALQUERY) {
    576                          std::cout << "Full list of commands is:" << std::endl;
    577                          int maxAcross = 5;
    578                          int limits[] = {1, 101, 201, 401, 601};
    579                          std::vector<std::string> types;
    580                          types.push_back("Double parameters:");
    581                          types.push_back("Int parameters:");
    582                          types.push_back("Keyword parameters and others:");
    583                          types.push_back("Actions:");
    584                          int iType;
    585                          for (iType = 0; iType < 4; iType++) {
    586                               int across = 0;
    587                               std::cout << types[iType] << std::endl;
    588                               for ( iParam = 0; iParam < numberParameters; iParam++ ) {
    589                                    int type = parameters[iParam].type();
    590                                    if (type >= limits[iType]
    591                                              && type < limits[iType+1]) {
    592                                         if (!across)
    593                                              std::cout << "  ";
    594                                         std::cout << parameters[iParam].matchName() << "  ";
    595                                         across++;
    596                                         if (across == maxAcross) {
    597                                              std::cout << std::endl;
    598                                              across = 0;
    599                                         }
    600                                    }
    601                               }
    602                               if (across)
    603                                    std::cout << std::endl;
    604                          }
    605                     } else if (type < 101) {
    606                          // get next field as double
    607                          double value = CoinReadGetDoubleField(argc, argv, &valid);
    608                          if (!valid) {
    609                               parameters[iParam].setDoubleParameter(thisModel, value);
    610                          } else if (valid == 1) {
    611                               std::cout << " is illegal for double parameter " << parameters[iParam].name() << " value remains " <<
    612                                         parameters[iParam].doubleValue() << std::endl;
    613                          } else {
    614                               std::cout << parameters[iParam].name() << " has value " <<
    615                                         parameters[iParam].doubleValue() << std::endl;
    616                          }
    617                     } else if (type < 201) {
    618                          // get next field as int
    619                          int value = CoinReadGetIntField(argc, argv, &valid);
    620                          if (!valid) {
    621                               if (parameters[iParam].type() == CLP_PARAM_INT_PRESOLVEPASS)
    622                                    preSolve = value;
    623                               else if (parameters[iParam].type() == CLP_PARAM_INT_IDIOT)
    624                                    doIdiot = value;
    625                               else if (parameters[iParam].type() == CLP_PARAM_INT_SPRINT)
    626                                    doSprint = value;
    627                               else if (parameters[iParam].type() == CLP_PARAM_INT_OUTPUTFORMAT)
    628                                    outputFormat = value;
    629                               else if (parameters[iParam].type() == CLP_PARAM_INT_SLPVALUE)
    630                                    slpValue = value;
    631                               else if (parameters[iParam].type() == CLP_PARAM_INT_CPP)
    632                                    cppValue = value;
    633                               else if (parameters[iParam].type() == CLP_PARAM_INT_PRESOLVEOPTIONS)
    634                                    presolveOptions = value;
    635                               else if (parameters[iParam].type() == CLP_PARAM_INT_PRINTOPTIONS)
    636                                    printOptions = value;
    637                               else if (parameters[iParam].type() == CLP_PARAM_INT_SUBSTITUTION)
    638                                    substitution = value;
    639                               else if (parameters[iParam].type() == CLP_PARAM_INT_DUALIZE)
    640                                    dualize = value;
    641                               else if (parameters[iParam].type() == CLP_PARAM_INT_VERBOSE)
    642                                    verbose = value;
    643                               parameters[iParam].setIntParameter(thisModel, value);
    644                          } else if (valid == 1) {
    645                               std::cout << " is illegal for integer parameter " << parameters[iParam].name() << " value remains " <<
    646                                         parameters[iParam].intValue() << std::endl;
    647                          } else {
    648                               std::cout << parameters[iParam].name() << " has value " <<
    649                                         parameters[iParam].intValue() << std::endl;
    650                          }
    651                     } else if (type < 401) {
    652                          // one of several strings
    653                          std::string value = CoinReadGetString(argc, argv);
    654                          int action = parameters[iParam].parameterOption(value);
    655                          if (action < 0) {
    656                               if (value != "EOL") {
    657                                    // no match
    658                                    parameters[iParam].printOptions();
    659                               } else {
    660                                    // print current value
    661                                    std::cout << parameters[iParam].name() << " has value " <<
    662                                              parameters[iParam].currentOption() << std::endl;
    663                               }
    664                          } else {
    665                               parameters[iParam].setCurrentOption(action);
    666                               // for now hard wired
    667                               switch (type) {
    668                               case CLP_PARAM_STR_DIRECTION:
    669                                 if (action == 0) {
    670                                         models[iModel].setOptimizationDirection(1);
    671 #ifdef ABC_INHERIT
    672                                         thisModel->setOptimizationDirection(1);
    673 #endif
    674                                 }  else if (action == 1) {
    675                                         models[iModel].setOptimizationDirection(-1);
    676 #ifdef ABC_INHERIT
    677                                         thisModel->setOptimizationDirection(-1);
    678 #endif
    679                                 }  else {
    680                                         models[iModel].setOptimizationDirection(0);
    681 #ifdef ABC_INHERIT
    682                                         thisModel->setOptimizationDirection(0);
    683 #endif
    684                                 }
    685                                    break;
    686                               case CLP_PARAM_STR_DUALPIVOT:
    687                                    if (action == 0) {
    688                                         ClpDualRowSteepest steep(3);
    689                                         thisModel->setDualRowPivotAlgorithm(steep);
    690 #ifdef ABC_INHERIT
    691                                         AbcDualRowSteepest steep2(3);
    692                                         models[iModel].setDualRowPivotAlgorithm(steep2);
    693 #endif
    694                                    } else if (action == 1) {
    695                                         //ClpDualRowDantzig dantzig;
    696                                         ClpDualRowDantzig dantzig;
    697                                         thisModel->setDualRowPivotAlgorithm(dantzig);
    698 #ifdef ABC_INHERIT
    699                                         AbcDualRowDantzig dantzig2;
    700                                         models[iModel].setDualRowPivotAlgorithm(dantzig2);
    701 #endif
    702                                    } else if (action == 2) {
    703                                         // partial steep
    704                                         ClpDualRowSteepest steep(2);
    705                                         thisModel->setDualRowPivotAlgorithm(steep);
    706 #ifdef ABC_INHERIT
    707                                         AbcDualRowSteepest steep2(2);
    708                                         models[iModel].setDualRowPivotAlgorithm(steep2);
    709 #endif
    710                                    } else if (action == 3) {
    711                                         ClpDualRowSteepest steep;
    712                                         thisModel->setDualRowPivotAlgorithm(steep);
    713 #ifdef ABC_INHERIT
    714                                         AbcDualRowSteepest steep2;
    715                                         models[iModel].setDualRowPivotAlgorithm(steep2);
    716 #endif
    717                                    } else if (action == 4) {
    718                                      // Positive edge steepest
    719                                      ClpPEDualRowSteepest p(fabs(parameters[whichParam(CLP_PARAM_DBL_PSI, numberParameters, parameters)].doubleValue()));
    720                                      thisModel->setDualRowPivotAlgorithm(p);
    721                                    } else if (action == 5) {
    722                                      // Positive edge Dantzig
    723                                      ClpPEDualRowDantzig p(fabs(parameters[whichParam(CLP_PARAM_DBL_PSI, numberParameters, parameters)].doubleValue()));
    724                                      thisModel->setDualRowPivotAlgorithm(p);
    725                                    }
    726                                    break;
    727                               case CLP_PARAM_STR_PRIMALPIVOT:
    728                                    if (action == 0) {
    729                                         ClpPrimalColumnSteepest steep(3);
    730                                         thisModel->setPrimalColumnPivotAlgorithm(steep);
    731                                    } else if (action == 1) {
    732                                         ClpPrimalColumnSteepest steep(0);
    733                                         thisModel->setPrimalColumnPivotAlgorithm(steep);
    734                                    } else if (action == 2) {
    735                                         ClpPrimalColumnDantzig dantzig;
    736                                         thisModel->setPrimalColumnPivotAlgorithm(dantzig);
    737                                    } else if (action == 3) {
    738                                         ClpPrimalColumnSteepest steep(4);
    739                                         thisModel->setPrimalColumnPivotAlgorithm(steep);
    740                                    } else if (action == 4) {
    741                                         ClpPrimalColumnSteepest steep(1);
    742                                         thisModel->setPrimalColumnPivotAlgorithm(steep);
    743                                    } else if (action == 5) {
    744                                         ClpPrimalColumnSteepest steep(2);
    745                                         thisModel->setPrimalColumnPivotAlgorithm(steep);
    746                                    } else if (action == 6) {
    747                                         ClpPrimalColumnSteepest steep(10);
    748                                         thisModel->setPrimalColumnPivotAlgorithm(steep);
    749                                    } else if (action == 7) {
    750                                      // Positive edge steepest
    751                                      ClpPEPrimalColumnSteepest p(fabs(parameters[whichParam(CLP_PARAM_DBL_PSI, numberParameters, parameters)].doubleValue()));
    752                                      thisModel->setPrimalColumnPivotAlgorithm(p);
    753                                    } else if (action == 8) {
    754                                      // Positive edge Dantzig
    755                                      ClpPEPrimalColumnDantzig p(fabs(parameters[whichParam(CLP_PARAM_DBL_PSI, numberParameters, parameters)].doubleValue()));
    756                                      thisModel->setPrimalColumnPivotAlgorithm(p);
    757                                    }
    758                                    break;
    759                               case CLP_PARAM_STR_SCALING:
    760                                    thisModel->scaling(action);
    761                                    break;
    762                               case CLP_PARAM_STR_AUTOSCALE:
    763                                    thisModel->setAutomaticScaling(action != 0);
    764                                    break;
    765                               case CLP_PARAM_STR_SPARSEFACTOR:
    766                                    thisModel->setSparseFactorization((1 - action) != 0);
    767                                    break;
    768                               case CLP_PARAM_STR_BIASLU:
    769                                    thisModel->factorization()->setBiasLU(action);
    770                                    break;
    771                               case CLP_PARAM_STR_PERTURBATION:
    772                                    if (action == 0)
    773                                         thisModel->setPerturbation(50);
    774                                    else
    775                                         thisModel->setPerturbation(100);
    776                                    break;
    777                               case CLP_PARAM_STR_ERRORSALLOWED:
    778                                    allowImportErrors = action;
    779                                    break;
    780                               case CLP_PARAM_STR_ABCWANTED:
    781 #ifdef ABC_INHERIT
    782                                    models[iModel].setAbcState(action);
    783 #elif ABOCA_LITE
    784                                    setAbcState(action);
    785                                    {
    786                                      char temp[3];
    787                                      sprintf(temp,"%d",action);
    788                                      __cilkrts_set_param("nworkers",temp);
    789                                      printf("setting cilk workers to %d\n",action);
    790                                    }
    791 #endif
    792                                    break;
    793                               case CLP_PARAM_STR_INTPRINT:
    794                                    printMode = action;
    795                                    break;
    796                               case CLP_PARAM_STR_KEEPNAMES:
    797                                    keepImportNames = 1 - action;
    798                                    break;
    799                               case CLP_PARAM_STR_PRESOLVE:
    800                                    if (action == 0)
    801                                         preSolve = DEFAULT_PRESOLVE_PASSES;
    802                                    else if (action == 1)
    803                                         preSolve = 0;
    804                                    else if (action == 2)
    805                                         preSolve = 10;
    806                                    else
    807                                         preSolveFile = true;
    808                                    break;
    809                               case CLP_PARAM_STR_PFI:
    810                                    thisModel->factorization()->setForrestTomlin(action == 0);
    811                                    break;
    812                               case CLP_PARAM_STR_FACTORIZATION:
    813                                    models[iModel].factorization()->forceOtherFactorization(action);
    814 #ifdef ABC_INHERIT
    815                                    thisModel->factorization()->forceOtherFactorization(action);
    816 #endif
    817                                    break;
    818                               case CLP_PARAM_STR_CRASH:
    819                                    doCrash = action;
    820                                    break;
    821                               case CLP_PARAM_STR_VECTOR:
    822                                    doVector = action;
    823                                    break;
    824                               case CLP_PARAM_STR_MESSAGES:
    825                                    models[iModel].messageHandler()->setPrefix(action != 0);
    826 #ifdef ABC_INHERIT
    827                                    thisModel->messageHandler()->setPrefix(action != 0);
    828 #endif
    829                                    break;
    830                               case CLP_PARAM_STR_CHOLESKY:
    831                                    choleskyType = action;
    832                                    break;
    833                               case CLP_PARAM_STR_GAMMA:
    834                                    gamma = action;
    835                                    break;
    836                               case CLP_PARAM_STR_BARRIERSCALE:
    837                                    scaleBarrier = action;
    838                                    break;
    839                               case CLP_PARAM_STR_KKT:
    840                                    doKKT = action;
    841                                    break;
    842                               case CLP_PARAM_STR_CROSSOVER:
    843                                    crossover = action;
    844                                    break;
    845                               default:
    846                                    //abort();
    847                                    break;
    848                               }
    849                          }
    850                     } else {
    851                          // action
    852                          if (type == CLP_PARAM_ACTION_EXIT) {
    853 #ifdef COIN_HAS_ASL
    854                            if (usingAmpl) {
    855                              writeAmpl(&info);
    856                              freeArrays2(&info);
    857                              freeArgs(&info);
    858                            }
    859 #endif
    860                            break; // stop all
    861                          }
    862                          switch (type) {
    863                          case CLP_PARAM_ACTION_DUALSIMPLEX:
    864                          case CLP_PARAM_ACTION_PRIMALSIMPLEX:
    865                          case CLP_PARAM_ACTION_EITHERSIMPLEX:
    866                          case CLP_PARAM_ACTION_BARRIER:
    867                               // synonym for dual
    868                          case CBC_PARAM_ACTION_BAB:
    869                               if (goodModels[iModel]) {
    870 #ifndef ABC_INHERIT
    871                                 ClpSimplex * clpModel = models+iModel;
     1265                    effectiveRhs[i] = rhsValue;
     1266                    if (fabs(effectiveRhs[i]) > 1.0e10 && printBad)
     1267                      printf("Large rhs row %d %g\n",
     1268                        i, effectiveRhs[i]);
     1269                  }
     1270                  simplex->times(-1.0, bound, effectiveRhs);
     1271                  double bSum = 0.0;
     1272                  for (int i = 0; i < numberRows; i++) {
     1273                    bSum += effectiveRhs[i] * ray[i];
     1274                    if (fabs(effectiveRhs[i]) > 1.0e10 && printBad)
     1275                      printf("Large rhs row %d %g after\n",
     1276                        i, effectiveRhs[i]);
     1277                  }
     1278                  if ((numberBad || bSum > 1.0e-6) && printBad) {
     1279                    printf("Bad infeasibility ray %g  - %d bad\n",
     1280                      bSum, numberBad);
     1281                  } else {
     1282                    //printf("Good ray - infeasibility %g\n",
     1283                    //     -bSum);
     1284                  }
     1285                  delete[] ray;
     1286                  delete[] farkas;
     1287                  simplex->swapRowScale(saveScale);
     1288                  simplex->swapScaledMatrix(saveMatrix);
     1289                } else {
     1290                  //printf("No dual ray\n");
     1291                }
     1292              }
     1293#endif
     1294            } catch (CoinError e) {
     1295              e.print();
     1296              status = -1;
     1297            }
     1298            if (dualize) {
     1299              ClpSimplex *thisModel = models + iModel;
     1300              int returnCode = static_cast< ClpSimplexOther * >(thisModel)->restoreFromDual(model2);
     1301              if (model2->status() == 3)
     1302                returnCode = 0;
     1303              delete model2;
     1304              if (returnCode && dualize != 2) {
     1305                currentModel = models + iModel;
     1306                // register signal handler
     1307                signal(SIGINT, signal_handler);
     1308                thisModel->primal(1);
     1309                currentModel = NULL;
     1310              }
     1311#ifndef COIN_HAS_ASL
     1312              CoinMessageHandler *generalMessageHandler = models->messageHandler();
     1313              generalMessageHandler->setPrefix(false);
     1314              CoinMessages generalMessages = models->messages();
     1315              char generalPrint[100];
     1316#endif
     1317              sprintf(generalPrint, "After translating dual back to primal - objective value is %g",
     1318                thisModel->objectiveValue());
     1319              generalMessageHandler->message(CLP_GENERAL, generalMessages)
     1320                << generalPrint
     1321                << CoinMessageEol;
     1322              // switch off (user can switch back on)
     1323              parameters[whichParam(CLP_PARAM_INT_DUALIZE,
     1324                           numberParameters, parameters)]
     1325                .setIntValue(dualize);
     1326            }
     1327            if (status >= 0)
     1328              basisHasValues = 1;
     1329          } else {
     1330            std::cout << "** Current model not valid" << std::endl;
     1331          }
     1332          break;
     1333        case CLP_PARAM_ACTION_STATISTICS:
     1334          if (goodModels[iModel]) {
     1335            // If presolve on look at presolved
     1336            bool deleteModel2 = false;
     1337            ClpSimplex *model2 = models + iModel;
     1338            if (preSolve) {
     1339              ClpPresolve pinfo;
     1340              int presolveOptions2 = presolveOptions & ~0x40000000;
     1341              if ((presolveOptions2 & 0xffff) != 0)
     1342                pinfo.setPresolveActions(presolveOptions2);
     1343              pinfo.setSubstitution(substitution);
     1344              if ((printOptions & 1) != 0)
     1345                pinfo.statistics();
     1346              double presolveTolerance = parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, numberParameters, parameters)].doubleValue();
     1347              model2 = pinfo.presolvedModel(models[iModel], presolveTolerance,
     1348                true, preSolve);
     1349              if (model2) {
     1350                printf("Statistics for presolved model\n");
     1351                deleteModel2 = true;
     1352              } else {
     1353                printf("Presolved model looks infeasible - will use unpresolved\n");
     1354                model2 = models + iModel;
     1355              }
     1356            } else {
     1357              printf("Statistics for unpresolved model\n");
     1358              model2 = models + iModel;
     1359            }
     1360            statistics(models + iModel, model2);
     1361            if (deleteModel2)
     1362              delete model2;
     1363          } else {
     1364            std::cout << "** Current model not valid" << std::endl;
     1365          }
     1366          break;
     1367        case CLP_PARAM_ACTION_TIGHTEN:
     1368          if (goodModels[iModel]) {
     1369            int numberInfeasibilities = models[iModel].tightenPrimalBounds();
     1370            if (numberInfeasibilities)
     1371              std::cout << "** Analysis indicates model infeasible" << std::endl;
     1372          } else {
     1373            std::cout << "** Current model not valid" << std::endl;
     1374          }
     1375          break;
     1376        case CLP_PARAM_ACTION_PLUSMINUS:
     1377          if (goodModels[iModel]) {
     1378            ClpMatrixBase *saveMatrix = models[iModel].clpMatrix();
     1379            ClpPackedMatrix *clpMatrix = dynamic_cast< ClpPackedMatrix * >(saveMatrix);
     1380            if (clpMatrix) {
     1381              ClpPlusMinusOneMatrix *newMatrix = new ClpPlusMinusOneMatrix(*(clpMatrix->matrix()));
     1382              if (newMatrix->getIndices()) {
     1383                models[iModel].replaceMatrix(newMatrix);
     1384                delete saveMatrix;
     1385                std::cout << "Matrix converted to +- one matrix" << std::endl;
     1386              } else {
     1387                std::cout << "Matrix can not be converted to +- 1 matrix" << std::endl;
     1388              }
     1389            } else {
     1390              std::cout << "Matrix not a ClpPackedMatrix" << std::endl;
     1391            }
     1392          } else {
     1393            std::cout << "** Current model not valid" << std::endl;
     1394          }
     1395          break;
     1396        case CLP_PARAM_ACTION_NETWORK:
     1397          if (goodModels[iModel]) {
     1398            ClpMatrixBase *saveMatrix = models[iModel].clpMatrix();
     1399            ClpPackedMatrix *clpMatrix = dynamic_cast< ClpPackedMatrix * >(saveMatrix);
     1400            if (clpMatrix) {
     1401              ClpNetworkMatrix *newMatrix = new ClpNetworkMatrix(*(clpMatrix->matrix()));
     1402              if (newMatrix->getIndices()) {
     1403                models[iModel].replaceMatrix(newMatrix);
     1404                delete saveMatrix;
     1405                std::cout << "Matrix converted to network matrix" << std::endl;
     1406              } else {
     1407                std::cout << "Matrix can not be converted to network matrix" << std::endl;
     1408              }
     1409            } else {
     1410              std::cout << "Matrix not a ClpPackedMatrix" << std::endl;
     1411            }
     1412          } else {
     1413            std::cout << "** Current model not valid" << std::endl;
     1414          }
     1415          break;
     1416        case CLP_PARAM_ACTION_IMPORT: {
     1417          // get next field
     1418          field = CoinReadGetString(argc, argv);
     1419          if (field == "$") {
     1420            field = parameters[iParam].stringValue();
     1421          } else if (field == "EOL") {
     1422            parameters[iParam].printString();
     1423            break;
     1424          } else {
     1425            parameters[iParam].setStringValue(field);
     1426          }
     1427          std::string fileName;
     1428          bool canOpen = false;
     1429          // See if gmpl file
     1430          int gmpl = 0;
     1431          std::string gmplData;
     1432          if (field == "-") {
     1433            // stdin
     1434            canOpen = true;
     1435            fileName = "-";
     1436          } else {
     1437            // See if .lp
     1438            {
     1439              const char *c_name = field.c_str();
     1440              size_t length = strlen(c_name);
     1441              if ((length > 3 && !strncmp(c_name + length - 3, ".lp", 3)) || (length > 6 && !strncmp(c_name + length - 6, ".lp.gz", 6)) || (length > 7 && !strncmp(c_name + length - 7, ".lp.bz2", 7)))
     1442                gmpl = -1; // .lp
     1443            }
     1444            bool absolutePath;
     1445            if (dirsep == '/') {
     1446              // non Windows (or cygwin)
     1447              absolutePath = (field[0] == '/');
     1448            } else {
     1449              //Windows (non cycgwin)
     1450              absolutePath = (field[0] == '\\');
     1451              // but allow for :
     1452              if (strchr(field.c_str(), ':'))
     1453                absolutePath = true;
     1454            }
     1455            if (absolutePath) {
     1456              fileName = field;
     1457              size_t length = field.size();
     1458              size_t percent = field.find('%');
     1459              if (percent < length && percent > 0) {
     1460                gmpl = 1;
     1461                fileName = field.substr(0, percent);
     1462                gmplData = field.substr(percent + 1);
     1463                if (percent < length - 1)
     1464                  gmpl = 2; // two files
     1465                printf("GMPL model file %s and data file %s\n",
     1466                  fileName.c_str(), gmplData.c_str());
     1467              }
     1468            } else if (field[0] == '~') {
     1469              char *environVar = getenv("HOME");
     1470              if (environVar) {
     1471                std::string home(environVar);
     1472                field = field.erase(0, 1);
     1473                fileName = home + field;
     1474              } else {
     1475                fileName = field;
     1476              }
     1477            } else {
     1478              fileName = directory + field;
     1479              // See if gmpl (model & data) - or even lp file
     1480              size_t length = field.size();
     1481              size_t percent = field.find('%');
     1482              if (percent < length && percent > 0) {
     1483                gmpl = 1;
     1484                fileName = directory + field.substr(0, percent);
     1485                gmplData = directory + field.substr(percent + 1);
     1486                if (percent < length - 1)
     1487                  gmpl = 2; // two files
     1488                printf("GMPL model file %s and data file %s\n",
     1489                  fileName.c_str(), gmplData.c_str());
     1490              }
     1491            }
     1492            std::string name = fileName;
     1493            if (fileCoinReadable(name)) {
     1494              // can open - lets go for it
     1495              canOpen = true;
     1496              if (gmpl == 2) {
     1497                FILE *fp;
     1498                fp = fopen(gmplData.c_str(), "r");
     1499                if (fp) {
     1500                  fclose(fp);
     1501                } else {
     1502                  canOpen = false;
     1503                  std::cout << "Unable to open file " << gmplData << std::endl;
     1504                }
     1505              }
     1506            } else {
     1507              std::cout << "Unable to open file " << fileName << std::endl;
     1508            }
     1509          }
     1510          if (canOpen) {
     1511            int status;
     1512#ifdef CLP_USEFUL_PRINTOUT
     1513            mpsFile = fileName;
     1514#endif
     1515            if (!gmpl)
     1516              status = models[iModel].readMps(fileName.c_str(),
     1517                keepImportNames != 0,
     1518                allowImportErrors != 0);
     1519            else if (gmpl > 0)
     1520              status = models[iModel].readGMPL(fileName.c_str(),
     1521                (gmpl == 2) ? gmplData.c_str() : NULL,
     1522                keepImportNames != 0);
     1523            else
     1524#ifdef KILL_ZERO_READLP
     1525              status = models[iModel].readLp(fileName.c_str(), models[iModel].getSmallElementValue());
    8721526#else
    873                                 ClpSimplex * clpModel = static_cast<ClpSimplex *>(models+iModel);
    874 #endif
    875                                 //openblas_set_num_threads(4);
    876                                 // deal with positive edge
    877                                 double psi = parameters[whichParam(CLP_PARAM_DBL_PSI, numberParameters, parameters)].doubleValue();
    878                                 if (psi>0.0) {
    879                                   ClpDualRowPivot * dualp = clpModel->dualRowPivot();
    880                                   ClpDualRowSteepest * d1 = dynamic_cast<ClpDualRowSteepest *>(dualp);
    881                                   ClpDualRowDantzig * d2 = dynamic_cast<ClpDualRowDantzig *>(dualp);
    882                                   if (d1) {
    883                                     ClpPEDualRowSteepest p(psi,d1->mode());
    884                                     clpModel->setDualRowPivotAlgorithm(p);
    885                                   } else if (d2) {
    886                                     ClpPEDualRowDantzig p(psi);
    887                                     clpModel->setDualRowPivotAlgorithm(p);
    888                                   }
    889                                   ClpPrimalColumnPivot * primalp = clpModel->primalColumnPivot();
    890                                   ClpPrimalColumnSteepest * p1 = dynamic_cast<ClpPrimalColumnSteepest *>(primalp);
    891                                   ClpPrimalColumnDantzig * p2 = dynamic_cast<ClpPrimalColumnDantzig *>(primalp);
    892                                   if (p1) {
    893                                     ClpPEPrimalColumnSteepest p(psi,p1->mode());
    894                                     clpModel->setPrimalColumnPivotAlgorithm(p);
    895                                   } else if (p2) {
    896                                     ClpPEPrimalColumnDantzig p(psi);
    897                                     clpModel->setPrimalColumnPivotAlgorithm(p);
    898                                   }
    899                                 }
    900                                 if (type==CLP_PARAM_ACTION_EITHERSIMPLEX||
    901                                     type==CBC_PARAM_ACTION_BAB)
    902                                   models[iModel].setMoreSpecialOptions(16384|
    903                                                                        models[iModel].moreSpecialOptions());
    904                                    double objScale =
    905                                         parameters[whichParam(CLP_PARAM_DBL_OBJSCALE2, numberParameters, parameters)].doubleValue();
    906                                    if (objScale != 1.0) {
    907                                         int iColumn;
    908                                         int numberColumns = models[iModel].numberColumns();
    909                                         double * dualColumnSolution =
    910                                              models[iModel].dualColumnSolution();
    911                                         ClpObjective * obj = models[iModel].objectiveAsObject();
    912                                         assert(dynamic_cast<ClpLinearObjective *> (obj));
    913                                         double offset;
    914                                         double * objective = obj->gradient(NULL, NULL, offset, true);
    915                                         for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    916                                              dualColumnSolution[iColumn] *= objScale;
    917                                              objective[iColumn] *= objScale;;
    918                                         }
    919                                         int iRow;
    920                                         int numberRows = models[iModel].numberRows();
    921                                         double * dualRowSolution =
    922                                              models[iModel].dualRowSolution();
    923                                         for (iRow = 0; iRow < numberRows; iRow++)
    924                                              dualRowSolution[iRow] *= objScale;
    925                                         models[iModel].setObjectiveOffset(objScale * models[iModel].objectiveOffset());
    926                                    }
    927                                    ClpSolve::SolveType method;
    928                                    ClpSolve::PresolveType presolveType;
    929                                    ClpSolve solveOptions;
    930 #ifndef ABC_INHERIT
    931                                    ClpSimplex * model2 = models + iModel;
    932 #else
    933                                    AbcSimplex * model2 = models + iModel;
    934 #endif
    935                                    if (type==CLP_PARAM_ACTION_EITHERSIMPLEX||
    936                                        type==CBC_PARAM_ACTION_BAB)
    937                                      solveOptions.setSpecialOption(3,0); // allow +-1
    938                                    if (dualize==4) {
    939                                      solveOptions.setSpecialOption(4, 77);
    940                                      dualize=0;
    941                                    }
    942                                    if (dualize) {
    943                                         bool tryIt = true;
    944                                         double fractionColumn = 1.0;
    945                                         double fractionRow = 1.0;
    946                                         if (dualize == 3) {
    947                                              dualize = 1;
    948                                              int numberColumns = model2->numberColumns();
    949                                              int numberRows = model2->numberRows();
    950 #ifndef ABC_INHERIT
    951                                              if (numberRows < 50000 || 5 * numberColumns > numberRows) {
    952 #else
    953                                              if (numberRows < 500 || 4 * numberColumns > numberRows) {
    954 #endif
    955                                                   tryIt = false;
    956                                              } else {
    957                                                   fractionColumn = 0.1;
    958                                                   fractionRow = 0.3;
    959                                              }
    960                                         }
    961                                         if (tryIt) {
    962                                           ClpSimplex * thisModel=model2;
    963                                              thisModel = static_cast<ClpSimplexOther *> (thisModel)->dualOfModel(fractionRow, fractionColumn);
    964                                              if (thisModel) {
    965                                                   printf("Dual of model has %d rows and %d columns\n",
    966                                                          thisModel->numberRows(), thisModel->numberColumns());
    967                                                   thisModel->setOptimizationDirection(1.0);
    968 #ifndef ABC_INHERIT
    969                                                   model2=thisModel;
    970 #else
    971                                                   int abcState=model2->abcState();
    972                                                   model2=new AbcSimplex(*thisModel);
    973                                                   model2->setAbcState(abcState);
    974                                                   delete thisModel;
    975 #endif
    976                                              } else {
    977                                                   thisModel = models + iModel;
    978                                                   dualize = 0;
    979                                              }
    980                                         } else {
    981                                              dualize = 0;
    982                                         }
    983                                    }
    984                                    if (preSolveFile)
    985                                         presolveOptions |= 0x40000000;
    986                                    // allow dependency
    987                                    presolveOptions |= 32768;
    988                                    solveOptions.setPresolveActions(presolveOptions);
    989                                    solveOptions.setSubstitution(substitution);
    990                                    if (preSolve != DEFAULT_PRESOLVE_PASSES && preSolve) {
    991                                         presolveType = ClpSolve::presolveNumber;
    992                                         if (preSolve < 0) {
    993                                              preSolve = - preSolve;
    994                                              if (preSolve <= 100) {
    995                                                   presolveType = ClpSolve::presolveNumber;
    996                                                   printf("Doing %d presolve passes - picking up non-costed slacks\n",
    997                                                          preSolve);
    998                                                   solveOptions.setDoSingletonColumn(true);
    999                                              } else {
    1000                                                   preSolve -= 100;
    1001                                                   presolveType = ClpSolve::presolveNumberCost;
    1002                                                   printf("Doing %d presolve passes - picking up costed slacks\n",
    1003                                                          preSolve);
    1004                                              }
    1005                                         }
    1006                                    } else if (preSolve) {
    1007                                         presolveType = ClpSolve::presolveOn;
    1008                                    } else {
    1009                                         presolveType = ClpSolve::presolveOff;
    1010                                    }
    1011                                    solveOptions.setPresolveType(presolveType, preSolve);
    1012                                    if (type == CLP_PARAM_ACTION_DUALSIMPLEX ||
    1013                                              type == CBC_PARAM_ACTION_BAB) {
    1014                                         method = ClpSolve::useDual;
    1015                                    } else if (type == CLP_PARAM_ACTION_PRIMALSIMPLEX) {
    1016                                         method = ClpSolve::usePrimalorSprint;
    1017                                    } else if (type == CLP_PARAM_ACTION_EITHERSIMPLEX) {
    1018                                         method = ClpSolve::automatic;
    1019                                         if (doCrash>3) {
    1020                                           solveOptions.setSpecialOption(6, 1,doCrash-3);
    1021                                           doCrash=0;
    1022                                         }
    1023                                         if (doIdiot > 0)
    1024                                              solveOptions.setSpecialOption(1, 2, doIdiot);
    1025                                    } else {
    1026                                         method = ClpSolve::useBarrier;
    1027                                         if (doIdiot > 0)
    1028                                              solveOptions.setSpecialOption(1, 2, doIdiot); // dense threshold
    1029                                         if (crossover == 1) {
    1030                                              method = ClpSolve::useBarrierNoCross;
    1031                                         } else if (crossover == 2) {
    1032                                              ClpObjective * obj = models[iModel].objectiveAsObject();
    1033                                              if (obj->type() > 1) {
    1034                                                   method = ClpSolve::useBarrierNoCross;
    1035                                                   presolveType = ClpSolve::presolveOff;
    1036                                                   solveOptions.setPresolveType(presolveType, preSolve);
    1037                                              }
    1038                                         }
    1039                                    }
    1040                                    solveOptions.setSolveType(method);
    1041                                    solveOptions.setSpecialOption(5, printOptions & 1);
    1042                                    if (doVector) {
    1043                                         ClpMatrixBase * matrix = models[iModel].clpMatrix();
    1044                                         if (dynamic_cast< ClpPackedMatrix*>(matrix)) {
    1045                                              ClpPackedMatrix * clpMatrix = dynamic_cast< ClpPackedMatrix*>(matrix);
    1046                                              clpMatrix->makeSpecialColumnCopy();
    1047                                         }
    1048                                    }
    1049                                    if (method == ClpSolve::useDual) {
    1050                                         // dual
    1051                                         if (doCrash&&doCrash<4)
    1052                                              solveOptions.setSpecialOption(0, 1, doCrash); // crash
    1053                                         else if (doIdiot)
    1054                                              solveOptions.setSpecialOption(0, 2, doIdiot); // possible idiot
    1055                                    } else if (method == ClpSolve::usePrimalorSprint) {
    1056                                         // primal
    1057                                         // if slp turn everything off
    1058                                         if (slpValue > 0) {
    1059                                              doCrash = false;
    1060                                              doSprint = 0;
    1061                                              doIdiot = -1;
    1062                                              solveOptions.setSpecialOption(1, 10, slpValue); // slp
    1063                                              method = ClpSolve::usePrimal;
    1064                                         }
    1065                                         if (doCrash>3) {
    1066                                           solveOptions.setSpecialOption(6, 1,doCrash-3);
    1067                                           doCrash=0;
    1068                                         }
    1069                                         if (doCrash>0) {
    1070                                              solveOptions.setSpecialOption(1, 1, doCrash); // crash
    1071                                         } else if (doSprint > 0) {
    1072                                              // sprint overrides idiot
    1073                                              solveOptions.setSpecialOption(1, 3, doSprint); // sprint
    1074                                         } else if (doIdiot > 0) {
    1075                                              solveOptions.setSpecialOption(1, 2, doIdiot); // idiot
    1076                                         } else if (slpValue <= 0) {
    1077                                              if (doIdiot == 0) {
    1078                                                   if (doSprint == 0)
    1079                                                        solveOptions.setSpecialOption(1, 4); // all slack
    1080                                                   else
    1081                                                        solveOptions.setSpecialOption(1, 9); // all slack or sprint
    1082                                              } else {
    1083                                                   if (doSprint == 0)
    1084                                                        solveOptions.setSpecialOption(1, 8); // all slack or idiot
    1085                                                   else
    1086                                                        solveOptions.setSpecialOption(1, 7); // initiative
    1087                                              }
    1088                                         }
    1089                                         if (basisHasValues == -1)
    1090                                              solveOptions.setSpecialOption(1, 11); // switch off values
    1091                                    } else if (method == ClpSolve::useBarrier || method == ClpSolve::useBarrierNoCross) {
    1092                                         int barrierOptions = choleskyType;
    1093                                         if (scaleBarrier) {
    1094                                              if ((scaleBarrier & 1) != 0)
    1095                                                   barrierOptions |= 8;
    1096                                              barrierOptions |= 2048 * (scaleBarrier >> 1);
    1097                                         }
    1098                                         if (doKKT)
    1099                                              barrierOptions |= 16;
    1100                                         if (gamma)
    1101                                              barrierOptions |= 32 * gamma;
    1102                                         if (crossover == 3)
    1103                                              barrierOptions |= 256; // try presolve in crossover
    1104                                         solveOptions.setSpecialOption(4, barrierOptions);
    1105                                    }
    1106                                    int status;
    1107                                    if (cppValue >= 0) {
    1108                                         // generate code
    1109                                         FILE * fp = fopen("user_driver.cpp", "w");
    1110                                         if (fp) {
    1111                                              // generate enough to do solveOptions
    1112                                              model2->generateCpp(fp);
    1113                                              solveOptions.generateCpp(fp);
    1114                                              fclose(fp);
    1115                                              // now call generate code
    1116                                              generateCode("user_driver.cpp", cppValue);
    1117                                         } else {
    1118                                              std::cout << "Unable to open file user_driver.cpp" << std::endl;
    1119                                         }
    1120                                    }
    1121 #ifdef CLP_MULTIPLE_FACTORIZATIONS
    1122                                    int denseCode = parameters[whichParam(CBC_PARAM_INT_DENSE, numberParameters, parameters)].intValue();
    1123                                    if (denseCode!=-1)
    1124                                      model2->factorization()->setGoDenseThreshold(denseCode);
    1125                                    int smallCode = parameters[whichParam(CBC_PARAM_INT_SMALLFACT, numberParameters, parameters)].intValue();
    1126                                    if (smallCode!=-1)
    1127                                      model2->factorization()->setGoSmallThreshold(smallCode);
    1128                                    model2->factorization()->goDenseOrSmall(model2->numberRows());
    1129 #endif
    1130                                    try {
    1131                                         status = model2->initialSolve(solveOptions);
    1132 #ifdef COIN_HAS_ASL
    1133                             if (usingAmpl) {
    1134                                 double value = model2->getObjValue() * model2->getObjSense();
    1135                                 char buf[300];
    1136                                 int pos = 0;
    1137                                 int iStat = model2->status();
    1138                                 if (iStat == 0) {
    1139                                     pos += sprintf(buf + pos, "optimal," );
    1140                                 } else if (iStat == 1) {
    1141                                     // infeasible
    1142                                     pos += sprintf(buf + pos, "infeasible,");
    1143                                 } else if (iStat == 2) {
    1144                                     // unbounded
    1145                                     pos += sprintf(buf + pos, "unbounded,");
    1146                                 } else if (iStat == 3) {
    1147                                     pos += sprintf(buf + pos, "stopped on iterations or time,");
    1148                                 } else if (iStat == 4) {
    1149                                     iStat = 7;
    1150                                     pos += sprintf(buf + pos, "stopped on difficulties,");
    1151                                 } else if (iStat == 5) {
    1152                                     iStat = 3;
    1153                                     pos += sprintf(buf + pos, "stopped on ctrl-c,");
    1154                                 } else if (iStat == 6) {
    1155                                     // bab infeasible
    1156                                     pos += sprintf(buf + pos, "integer infeasible,");
    1157                                     iStat = 1;
    1158                                 } else {
    1159                                     pos += sprintf(buf + pos, "status unknown,");
    1160                                     iStat = 6;
    1161                                 }
    1162                                 info.problemStatus = iStat;
    1163                                 info.objValue = value;
    1164                                 pos += sprintf(buf + pos, " objective %.*g", ampl_obj_prec(),
    1165                                                value);
    1166                                 sprintf(buf + pos, "\n%d iterations",
    1167                                         model2->getIterationCount());
    1168                                 free(info.primalSolution);
    1169                                 int numberColumns = model2->numberColumns();
    1170                                 info.primalSolution = reinterpret_cast<double *> (malloc(numberColumns * sizeof(double)));
    1171                                 CoinCopyN(model2->primalColumnSolution(), numberColumns, info.primalSolution);
    1172                                 int numberRows = model2->numberRows();
    1173                                 free(info.dualSolution);
    1174                                 info.dualSolution = reinterpret_cast<double *> (malloc(numberRows * sizeof(double)));
    1175                                 CoinCopyN(model2->dualRowSolution(), numberRows, info.dualSolution);
    1176                                 CoinWarmStartBasis * basis = model2->getBasis();
    1177                                 free(info.rowStatus);
    1178                                 info.rowStatus = reinterpret_cast<int *> (malloc(numberRows * sizeof(int)));
    1179                                 free(info.columnStatus);
    1180                                 info.columnStatus = reinterpret_cast<int *> (malloc(numberColumns * sizeof(int)));
    1181                                 // Put basis in
    1182                                 int i;
    1183                                 // free,basic,ub,lb are 0,1,2,3
    1184                                 for (i = 0; i < numberRows; i++) {
    1185                                     CoinWarmStartBasis::Status status = basis->getArtifStatus(i);
    1186                                     info.rowStatus[i] = status;
    1187                                 }
    1188                                 for (i = 0; i < numberColumns; i++) {
    1189                                     CoinWarmStartBasis::Status status = basis->getStructStatus(i);
    1190                                     info.columnStatus[i] = status;
    1191                                 }
    1192                                 // put buffer into info
    1193                                 strcpy(info.buffer, buf);
    1194                                 delete basis;
    1195                             }
    1196 #endif
    1197 #ifndef NDEBUG
    1198                                         // if infeasible check ray
    1199                                         if (model2->status()==1) {
    1200                                           ClpSimplex * simplex = model2;
    1201                                           if(simplex->ray()) {
    1202                                             // make sure we use non-scaled versions
    1203                                             ClpPackedMatrix * saveMatrix = simplex->swapScaledMatrix(NULL);
    1204                                             double * saveScale = simplex->swapRowScale(NULL);
    1205                                             // could use existing arrays
    1206                                             int numberRows=simplex->numberRows();
    1207                                             int numberColumns=simplex->numberColumns();
    1208                                             double * farkas = new double [2*numberColumns+numberRows];
    1209                                             double * bound = farkas + numberColumns;
    1210                                             double * effectiveRhs = bound + numberColumns;
    1211                                             // get ray as user would
    1212                                             double * ray = simplex->infeasibilityRay();
    1213                                             // get farkas row
    1214                                             memset(farkas,0,(2*numberColumns+numberRows)*sizeof(double));
    1215                                             simplex->transposeTimes(-1.0,ray,farkas);
    1216                                             // Put nonzero bounds in bound
    1217                                             const double * columnLower = simplex->columnLower();
    1218                                             const double * columnUpper = simplex->columnUpper();
    1219                                             int numberBad=0;
    1220                                             for (int i=0;i<numberColumns;i++) {
    1221                                               double value = farkas[i];
    1222                                               double boundValue=0.0;
    1223                                               if (simplex->getStatus(i)==ClpSimplex::basic) {
    1224                                                 // treat as zero if small
    1225                                                 if (fabs(value)<1.0e-8) {
    1226                                                   value=0.0;
    1227                                                   farkas[i]=0.0;
    1228                                                 }
    1229                                                 if (value) {
    1230                                                   //printf("basic %d direction %d farkas %g\n",
    1231                                                   //       i,simplex->directionOut(),value);
    1232                                                   if (value<0.0)
    1233                                                     boundValue=CoinMax(columnLower[i],-1.0e20);
    1234                                                   else
    1235                                                     boundValue=CoinMin(columnUpper[i],1.0e20);
    1236                                                 }
    1237                                               } else if (fabs(value)>1.0e-10) {
    1238                                                 if (value<0.0)
    1239                                                   boundValue=columnLower[i];
    1240                                                 else
    1241                                                   boundValue=columnUpper[i];
    1242                                               }
    1243                                               bound[i]=boundValue;
    1244                                               if (fabs(boundValue)>1.0e10)
    1245                                                 numberBad++;
    1246                                             }
    1247                                             const double * rowLower = simplex->rowLower();
    1248                                             const double * rowUpper = simplex->rowUpper();
    1249                                             bool printBad=simplex->logLevel()>3;
    1250                                             //int pivotRow = simplex->spareIntArray_[3];
    1251                                             //bool badPivot=pivotRow<0;
    1252                                             for (int i=0;i<numberRows;i++) {
    1253                                               double value = ray[i];
    1254                                               double rhsValue=0.0;
    1255                                               if (simplex->getRowStatus(i)==ClpSimplex::basic) {
    1256                                                 // treat as zero if small
    1257                                                 if (fabs(value)<1.0e-8) {
    1258                                                   value=0.0;
    1259                                                   ray[i]=0.0;
    1260                                                 }
    1261                                                 if (value) {
    1262                                                   //printf("row basic %d direction %d ray %g\n",
    1263                                                   //       i,simplex->directionOut(),value);
    1264                                                   if (value<0.0)
    1265                                                     rhsValue=rowLower[i];
    1266                                                   else
    1267                                                     rhsValue=rowUpper[i];
    1268                                                 }
    1269                                               } else if (fabs(value)>1.0e-10) {
    1270                                                 if (value<0.0)
    1271                                                   rhsValue=rowLower[i];
    1272                                                 else
    1273                                                   rhsValue=rowUpper[i];
    1274                                               }
    1275                                               effectiveRhs[i]=rhsValue;
    1276                                               if (fabs(effectiveRhs[i])>1.0e10&&printBad)
    1277                                                 printf("Large rhs row %d %g\n",
    1278                                                        i,effectiveRhs[i]);
    1279                                             }
    1280                                             simplex->times(-1.0,bound,effectiveRhs);
    1281                                             double bSum=0.0;
    1282                                             for (int i=0;i<numberRows;i++) {
    1283                                               bSum += effectiveRhs[i]*ray[i];
    1284                                               if (fabs(effectiveRhs[i])>1.0e10&&printBad)
    1285                                                 printf("Large rhs row %d %g after\n",
    1286                                                        i,effectiveRhs[i]);
    1287                                             }
    1288                                             if ((numberBad||bSum>1.0e-6)&&printBad) {
    1289                                               printf("Bad infeasibility ray %g  - %d bad\n",
    1290                                                      bSum,numberBad);
    1291                                             } else {
    1292                                               //printf("Good ray - infeasibility %g\n",
    1293                                               //     -bSum);
    1294                                             }
    1295                                             delete [] ray;
    1296                                             delete [] farkas;
    1297                                             simplex->swapRowScale(saveScale);
    1298                                             simplex->swapScaledMatrix(saveMatrix);
    1299                                           } else {
    1300                                             //printf("No dual ray\n");
    1301                                           }
    1302                                         }
    1303 #endif
    1304                                    } catch (CoinError e) {
    1305                                         e.print();
    1306                                         status = -1;
    1307                                    }
    1308                                    if (dualize) {
    1309                                      ClpSimplex * thisModel=models+iModel;
    1310                                         int returnCode = static_cast<ClpSimplexOther *> (thisModel)->restoreFromDual(model2);
    1311                                         if (model2->status() == 3)
    1312                                              returnCode = 0;
    1313                                         delete model2;
    1314                                         if (returnCode && dualize != 2) {
    1315                                              currentModel = models + iModel;
    1316                                              // register signal handler
    1317                                              signal(SIGINT, signal_handler);
    1318                                              thisModel->primal(1);
    1319                                              currentModel = NULL;
    1320                                         }
    1321 #ifndef COIN_HAS_ASL
    1322                                         CoinMessageHandler * generalMessageHandler = models->messageHandler();
    1323                                         generalMessageHandler->setPrefix(false);
    1324                                         CoinMessages generalMessages = models->messages();
    1325                                         char generalPrint[100];
    1326 #endif
    1327                                         sprintf(generalPrint, "After translating dual back to primal - objective value is %g",
    1328                                                 thisModel->objectiveValue());
    1329                                         generalMessageHandler->message(CLP_GENERAL, generalMessages)
    1330                                         << generalPrint
    1331                                         << CoinMessageEol;
    1332                                         // switch off (user can switch back on)
    1333                                         parameters[whichParam(CLP_PARAM_INT_DUALIZE,
    1334                                                               numberParameters, parameters)].setIntValue(dualize);
    1335                                    }
    1336                                    if (status >= 0)
    1337                                         basisHasValues = 1;
    1338                               } else {
    1339                                    std::cout << "** Current model not valid" << std::endl;
    1340                               }
    1341                               break;
    1342                          case CLP_PARAM_ACTION_STATISTICS:
    1343                               if (goodModels[iModel]) {
    1344                                    // If presolve on look at presolved
    1345                                    bool deleteModel2 = false;
    1346                                    ClpSimplex * model2 = models + iModel;
    1347                                    if (preSolve) {
    1348                                         ClpPresolve pinfo;
    1349                                         int presolveOptions2 = presolveOptions&~0x40000000;
    1350                                         if ((presolveOptions2 & 0xffff) != 0)
    1351                                              pinfo.setPresolveActions(presolveOptions2);
    1352                                         pinfo.setSubstitution(substitution);
    1353                                         if ((printOptions & 1) != 0)
    1354                                              pinfo.statistics();
    1355                                         double presolveTolerance =
    1356                                              parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, numberParameters, parameters)].doubleValue();
    1357                                         model2 =
    1358                                              pinfo.presolvedModel(models[iModel], presolveTolerance,
    1359                                                                   true, preSolve);
    1360                                         if (model2) {
    1361                                              printf("Statistics for presolved model\n");
    1362                                              deleteModel2 = true;
    1363                                         } else {
    1364                                              printf("Presolved model looks infeasible - will use unpresolved\n");
    1365                                              model2 = models + iModel;
    1366                                         }
    1367                                    } else {
    1368                                         printf("Statistics for unpresolved model\n");
    1369                                         model2 =  models + iModel;
    1370                                    }
    1371                                    statistics(models + iModel, model2);
    1372                                    if (deleteModel2)
    1373                                         delete model2;
    1374                               } else {
    1375                                    std::cout << "** Current model not valid" << std::endl;
    1376                               }
    1377                               break;
    1378                          case CLP_PARAM_ACTION_TIGHTEN:
    1379                               if (goodModels[iModel]) {
    1380                                    int numberInfeasibilities = models[iModel].tightenPrimalBounds();
    1381                                    if (numberInfeasibilities)
    1382                                         std::cout << "** Analysis indicates model infeasible" << std::endl;
    1383                               } else {
    1384                                    std::cout << "** Current model not valid" << std::endl;
    1385                               }
    1386                               break;
    1387                          case CLP_PARAM_ACTION_PLUSMINUS:
    1388                               if (goodModels[iModel]) {
    1389                                    ClpMatrixBase * saveMatrix = models[iModel].clpMatrix();
    1390                                    ClpPackedMatrix* clpMatrix =
    1391                                         dynamic_cast< ClpPackedMatrix*>(saveMatrix);
    1392                                    if (clpMatrix) {
    1393                                         ClpPlusMinusOneMatrix * newMatrix = new ClpPlusMinusOneMatrix(*(clpMatrix->matrix()));
    1394                                         if (newMatrix->getIndices()) {
    1395                                              models[iModel].replaceMatrix(newMatrix);
    1396                                              delete saveMatrix;
    1397                                              std::cout << "Matrix converted to +- one matrix" << std::endl;
    1398                                         } else {
    1399                                              std::cout << "Matrix can not be converted to +- 1 matrix" << std::endl;
    1400                                         }
    1401                                    } else {
    1402                                         std::cout << "Matrix not a ClpPackedMatrix" << std::endl;
    1403                                    }
    1404                               } else {
    1405                                    std::cout << "** Current model not valid" << std::endl;
    1406                               }
    1407                               break;
    1408                          case CLP_PARAM_ACTION_NETWORK:
    1409                               if (goodModels[iModel]) {
    1410                                    ClpMatrixBase * saveMatrix = models[iModel].clpMatrix();
    1411                                    ClpPackedMatrix* clpMatrix =
    1412                                         dynamic_cast< ClpPackedMatrix*>(saveMatrix);
    1413                                    if (clpMatrix) {
    1414                                         ClpNetworkMatrix * newMatrix = new ClpNetworkMatrix(*(clpMatrix->matrix()));
    1415                                         if (newMatrix->getIndices()) {
    1416                                              models[iModel].replaceMatrix(newMatrix);
    1417                                              delete saveMatrix;
    1418                                              std::cout << "Matrix converted to network matrix" << std::endl;
    1419                                         } else {
    1420                                              std::cout << "Matrix can not be converted to network matrix" << std::endl;
    1421                                         }
    1422                                    } else {
    1423                                         std::cout << "Matrix not a ClpPackedMatrix" << std::endl;
    1424                                    }
    1425                               } else {
    1426                                    std::cout << "** Current model not valid" << std::endl;
    1427                               }
    1428                               break;
    1429                          case CLP_PARAM_ACTION_IMPORT: {
    1430                               // get next field
    1431                               field = CoinReadGetString(argc, argv);
    1432                               if (field == "$") {
    1433                                    field = parameters[iParam].stringValue();
    1434                               } else if (field == "EOL") {
    1435                                    parameters[iParam].printString();
    1436                                    break;
    1437                               } else {
    1438                                    parameters[iParam].setStringValue(field);
    1439                               }
    1440                               std::string fileName;
    1441                               bool canOpen = false;
    1442                               // See if gmpl file
    1443                               int gmpl = 0;
    1444                               std::string gmplData;
    1445                               if (field == "-") {
    1446                                    // stdin
    1447                                    canOpen = true;
    1448                                    fileName = "-";
    1449                               } else {
    1450                                    // See if .lp
    1451                                    {
    1452                                         const char * c_name = field.c_str();
    1453                                         size_t length = strlen(c_name);
    1454                                         if ((length > 3 && !strncmp(c_name + length - 3, ".lp", 3))||
    1455                                             (length > 6 && !strncmp(c_name + length - 6, ".lp.gz", 6)) ||
    1456                                             (length > 7 && !strncmp(c_name + length - 7, ".lp.bz2", 7)))
    1457                                             gmpl = -1; // .lp
    1458                                    }
    1459                                    bool absolutePath;
    1460                                    if (dirsep == '/') {
    1461                                         // non Windows (or cygwin)
    1462                                         absolutePath = (field[0] == '/');
    1463                                    } else {
    1464                                         //Windows (non cycgwin)
    1465                                         absolutePath = (field[0] == '\\');
    1466                                         // but allow for :
    1467                                         if (strchr(field.c_str(), ':'))
    1468                                              absolutePath = true;
    1469                                    }
    1470                                    if (absolutePath) {
    1471                                         fileName = field;
    1472                                         size_t length = field.size();
    1473                                         size_t percent = field.find('%');
    1474                                         if (percent < length && percent > 0) {
    1475                                              gmpl = 1;
    1476                                              fileName = field.substr(0, percent);
    1477                                              gmplData = field.substr(percent + 1);
    1478                                              if (percent < length - 1)
    1479                                                   gmpl = 2; // two files
    1480                                              printf("GMPL model file %s and data file %s\n",
    1481                                                     fileName.c_str(), gmplData.c_str());
    1482                                         }
    1483                                    } else if (field[0] == '~') {
    1484                                         char * environVar = getenv("HOME");
    1485                                         if (environVar) {
    1486                                              std::string home(environVar);
    1487                                              field = field.erase(0, 1);
    1488                                              fileName = home + field;
    1489                                         } else {
    1490                                              fileName = field;
    1491                                         }
    1492                                    } else {
    1493                                         fileName = directory + field;
    1494                                         // See if gmpl (model & data) - or even lp file
    1495                                         size_t length = field.size();
    1496                                         size_t percent = field.find('%');
    1497                                         if (percent < length && percent > 0) {
    1498                                              gmpl = 1;
    1499                                              fileName = directory + field.substr(0, percent);
    1500                                              gmplData = directory + field.substr(percent + 1);
    1501                                              if (percent < length - 1)
    1502                                                   gmpl = 2; // two files
    1503                                              printf("GMPL model file %s and data file %s\n",
    1504                                                     fileName.c_str(), gmplData.c_str());
    1505                                         }
    1506                                    }
    1507                                    std::string name = fileName;
    1508                                    if (fileCoinReadable(name)) {
    1509                                         // can open - lets go for it
    1510                                         canOpen = true;
    1511                                         if (gmpl == 2) {
    1512                                              FILE *fp;
    1513                                              fp = fopen(gmplData.c_str(), "r");
    1514                                              if (fp) {
    1515                                                   fclose(fp);
    1516                                              } else {
    1517                                                   canOpen = false;
    1518                                                   std::cout << "Unable to open file " << gmplData << std::endl;
    1519                                              }
    1520                                         }
    1521                                    } else {
    1522                                         std::cout << "Unable to open file " << fileName << std::endl;
    1523                                    }
    1524                               }
    1525                               if (canOpen) {
    1526                                    int status;
    1527 #ifdef CLP_USEFUL_PRINTOUT
    1528                                    mpsFile=fileName;
    1529 #endif
    1530                                    if (!gmpl)
    1531                                         status = models[iModel].readMps(fileName.c_str(),
    1532                                                                         keepImportNames != 0,
    1533                                                                         allowImportErrors != 0);
    1534                                    else if (gmpl > 0)
    1535                                         status = models[iModel].readGMPL(fileName.c_str(),
    1536                                                                          (gmpl == 2) ? gmplData.c_str() : NULL,
    1537                                                                          keepImportNames != 0);
    1538                                    else
    1539 #ifdef KILL_ZERO_READLP
    1540                                      status = models[iModel].readLp(fileName.c_str(), models[iModel].getSmallElementValue());
    1541 #else
    1542                                      status = models[iModel].readLp(fileName.c_str(), 1.0e-12);
    1543 #endif
    1544                                    if (!status || (status > 0 && allowImportErrors)) {
    1545                                         goodModels[iModel] = true;
    1546                                         // sets to all slack (not necessary?)
    1547                                         thisModel->createStatus();
    1548                                         time2 = CoinCpuTime();
    1549                                         totalTime += time2 - time1;
    1550                                         time1 = time2;
    1551                                         // Go to canned file if just input file
    1552                                         if (CbcOrClpRead_mode == 2 && argc == 2) {
    1553                                              // only if ends .mps
    1554                                              char * find = const_cast<char *>(strstr(fileName.c_str(), ".mps"));
    1555                                              if (find && find[4] == '\0') {
    1556                                                   find[1] = 'p';
    1557                                                   find[2] = 'a';
    1558                                                   find[3] = 'r';
    1559                                                   FILE *fp = fopen(fileName.c_str(), "r");
    1560                                                   if (fp) {
    1561                                                        CbcOrClpReadCommand = fp; // Read from that file
    1562                                                        CbcOrClpRead_mode = -1;
    1563                                                   }
    1564                                              }
    1565                                         }
    1566                                    } else {
    1567                                         // errors
    1568                                         std::cout << "There were " << status <<
    1569                                                   " errors on input" << std::endl;
    1570                                    }
    1571                               }
    1572                          }
    1573                          break;
    1574                          case CLP_PARAM_ACTION_EXPORT:
    1575                               if (goodModels[iModel]) {
    1576                                    double objScale =
    1577                                         parameters[whichParam(CLP_PARAM_DBL_OBJSCALE2, numberParameters, parameters)].doubleValue();
    1578                                    if (objScale != 1.0) {
    1579                                         int iColumn;
    1580                                         int numberColumns = models[iModel].numberColumns();
    1581                                         double * dualColumnSolution =
    1582                                              models[iModel].dualColumnSolution();
    1583                                         ClpObjective * obj = models[iModel].objectiveAsObject();
    1584                                         assert(dynamic_cast<ClpLinearObjective *> (obj));
    1585                                         double offset;
    1586                                         double * objective = obj->gradient(NULL, NULL, offset, true);
    1587                                         for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    1588                                              dualColumnSolution[iColumn] *= objScale;
    1589                                              objective[iColumn] *= objScale;;
    1590                                         }
    1591                                         int iRow;
    1592                                         int numberRows = models[iModel].numberRows();
    1593                                         double * dualRowSolution =
    1594                                              models[iModel].dualRowSolution();
    1595                                         for (iRow = 0; iRow < numberRows; iRow++)
    1596                                              dualRowSolution[iRow] *= objScale;
    1597                                         models[iModel].setObjectiveOffset(objScale * models[iModel].objectiveOffset());
    1598                                    }
    1599                                    // get next field
    1600                                    field = CoinReadGetString(argc, argv);
    1601                                    if (field == "$") {
    1602                                         field = parameters[iParam].stringValue();
    1603                                    } else if (field == "EOL") {
    1604                                         parameters[iParam].printString();
    1605                                         break;
    1606                                    } else {
    1607                                         parameters[iParam].setStringValue(field);
    1608                                    }
    1609                                    std::string fileName;
    1610                                    bool canOpen = false;
    1611                                    if (field[0] == '/' || field[0] == '\\') {
    1612                                         fileName = field;
    1613                                    } else if (field[0] == '~') {
    1614                                         char * environVar = getenv("HOME");
    1615                                         if (environVar) {
    1616                                              std::string home(environVar);
    1617                                              field = field.erase(0, 1);
    1618                                              fileName = home + field;
    1619                                         } else {
    1620                                              fileName = field;
    1621                                         }
    1622                                    } else {
    1623                                         fileName = directory + field;
    1624                                    }
    1625                                    FILE *fp = fopen(fileName.c_str(), "w");
    1626                                    if (fp) {
    1627                                         // can open - lets go for it
    1628                                         fclose(fp);
    1629                                         canOpen = true;
    1630                                    } else {
    1631                                         std::cout << "Unable to open file " << fileName << std::endl;
    1632                                    }
    1633                                    if (canOpen) {
    1634                                         // If presolve on then save presolved
    1635                                         bool deleteModel2 = false;
    1636                                         ClpSimplex * model2 = models + iModel;
    1637                                         if (dualize && dualize < 3) {
    1638                                              model2 = static_cast<ClpSimplexOther *> (model2)->dualOfModel();
    1639                                              printf("Dual of model has %d rows and %d columns\n",
    1640                                                     model2->numberRows(), model2->numberColumns());
    1641                                              model2->setOptimizationDirection(1.0);
    1642                                              preSolve = 0; // as picks up from model
    1643                                         }
    1644                                         if (preSolve) {
    1645                                              ClpPresolve pinfo;
    1646                                              int presolveOptions2 = presolveOptions&~0x40000000;
    1647                                              if ((presolveOptions2 & 0xffff) != 0)
    1648                                                   pinfo.setPresolveActions(presolveOptions2);
    1649                                              pinfo.setSubstitution(substitution);
    1650                                              if ((printOptions & 1) != 0)
    1651                                                   pinfo.statistics();
    1652                                              double presolveTolerance =
    1653                                                   parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, numberParameters, parameters)].doubleValue();
    1654                                              model2 =
    1655                                                   pinfo.presolvedModel(models[iModel], presolveTolerance,
    1656                                                                        true, preSolve, false, false);
    1657                                              if (model2) {
    1658                                                   printf("Saving presolved model on %s\n",
    1659                                                          fileName.c_str());
    1660                                                   deleteModel2 = true;
    1661                                              } else {
    1662                                                   printf("Presolved model looks infeasible - saving original on %s\n",
    1663                                                          fileName.c_str());
    1664                                                   deleteModel2 = false;
    1665                                                   model2 = models + iModel;
    1666 
    1667                                              }
    1668                                         } else {
    1669                                              printf("Saving model on %s\n",
    1670                                                     fileName.c_str());
    1671                                         }
     1527              status = models[iModel].readLp(fileName.c_str(), 1.0e-12);
     1528#endif
     1529            if (!status || (status > 0 && allowImportErrors)) {
     1530              goodModels[iModel] = true;
     1531              // sets to all slack (not necessary?)
     1532              thisModel->createStatus();
     1533              time2 = CoinCpuTime();
     1534              totalTime += time2 - time1;
     1535              time1 = time2;
     1536              // Go to canned file if just input file
     1537              if (CbcOrClpRead_mode == 2 && argc == 2) {
     1538                // only if ends .mps
     1539                char *find = const_cast< char * >(strstr(fileName.c_str(), ".mps"));
     1540                if (find && find[4] == '\0') {
     1541                  find[1] = 'p';
     1542                  find[2] = 'a';
     1543                  find[3] = 'r';
     1544                  FILE *fp = fopen(fileName.c_str(), "r");
     1545                  if (fp) {
     1546                    CbcOrClpReadCommand = fp; // Read from that file
     1547                    CbcOrClpRead_mode = -1;
     1548                  }
     1549                }
     1550              }
     1551            } else {
     1552              // errors
     1553              std::cout << "There were " << status << " errors on input" << std::endl;
     1554            }
     1555          }
     1556        } break;
     1557        case CLP_PARAM_ACTION_EXPORT:
     1558          if (goodModels[iModel]) {
     1559            double objScale = parameters[whichParam(CLP_PARAM_DBL_OBJSCALE2, numberParameters, parameters)].doubleValue();
     1560            if (objScale != 1.0) {
     1561              int iColumn;
     1562              int numberColumns = models[iModel].numberColumns();
     1563              double *dualColumnSolution = models[iModel].dualColumnSolution();
     1564              ClpObjective *obj = models[iModel].objectiveAsObject();
     1565              assert(dynamic_cast< ClpLinearObjective * >(obj));
     1566              double offset;
     1567              double *objective = obj->gradient(NULL, NULL, offset, true);
     1568              for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     1569                dualColumnSolution[iColumn] *= objScale;
     1570                objective[iColumn] *= objScale;
     1571                ;
     1572              }
     1573              int iRow;
     1574              int numberRows = models[iModel].numberRows();
     1575              double *dualRowSolution = models[iModel].dualRowSolution();
     1576              for (iRow = 0; iRow < numberRows; iRow++)
     1577                dualRowSolution[iRow] *= objScale;
     1578              models[iModel].setObjectiveOffset(objScale * models[iModel].objectiveOffset());
     1579            }
     1580            // get next field
     1581            field = CoinReadGetString(argc, argv);
     1582            if (field == "$") {
     1583              field = parameters[iParam].stringValue();
     1584            } else if (field == "EOL") {
     1585              parameters[iParam].printString();
     1586              break;
     1587            } else {
     1588              parameters[iParam].setStringValue(field);
     1589            }
     1590            std::string fileName;
     1591            bool canOpen = false;
     1592            if (field[0] == '/' || field[0] == '\\') {
     1593              fileName = field;
     1594            } else if (field[0] == '~') {
     1595              char *environVar = getenv("HOME");
     1596              if (environVar) {
     1597                std::string home(environVar);
     1598                field = field.erase(0, 1);
     1599                fileName = home + field;
     1600              } else {
     1601                fileName = field;
     1602              }
     1603            } else {
     1604              fileName = directory + field;
     1605            }
     1606            FILE *fp = fopen(fileName.c_str(), "w");
     1607            if (fp) {
     1608              // can open - lets go for it
     1609              fclose(fp);
     1610              canOpen = true;
     1611            } else {
     1612              std::cout << "Unable to open file " << fileName << std::endl;
     1613            }
     1614            if (canOpen) {
     1615              // If presolve on then save presolved
     1616              bool deleteModel2 = false;
     1617              ClpSimplex *model2 = models + iModel;
     1618              if (dualize && dualize < 3) {
     1619                model2 = static_cast< ClpSimplexOther * >(model2)->dualOfModel();
     1620                printf("Dual of model has %d rows and %d columns\n",
     1621                  model2->numberRows(), model2->numberColumns());
     1622                model2->setOptimizationDirection(1.0);
     1623                preSolve = 0; // as picks up from model
     1624              }
     1625              if (preSolve) {
     1626                ClpPresolve pinfo;
     1627                int presolveOptions2 = presolveOptions & ~0x40000000;
     1628                if ((presolveOptions2 & 0xffff) != 0)
     1629                  pinfo.setPresolveActions(presolveOptions2);
     1630                pinfo.setSubstitution(substitution);
     1631                if ((printOptions & 1) != 0)
     1632                  pinfo.statistics();
     1633                double presolveTolerance = parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, numberParameters, parameters)].doubleValue();
     1634                model2 = pinfo.presolvedModel(models[iModel], presolveTolerance,
     1635                  true, preSolve, false, false);
     1636                if (model2) {
     1637                  printf("Saving presolved model on %s\n",
     1638                    fileName.c_str());
     1639                  deleteModel2 = true;
     1640                } else {
     1641                  printf("Presolved model looks infeasible - saving original on %s\n",
     1642                    fileName.c_str());
     1643                  deleteModel2 = false;
     1644                  model2 = models + iModel;
     1645                }
     1646              } else {
     1647                printf("Saving model on %s\n",
     1648                  fileName.c_str());
     1649              }
    16721650#if 0
    16731651                                        // Convert names
     
    17361714                                        }
    17371715#else
    1738                                         model2->writeMps(fileName.c_str(), (outputFormat - 1) / 2, 1 + ((outputFormat - 1) & 1));
    1739 #endif
    1740                                         if (deleteModel2)
    1741                                              delete model2;
    1742                                         time2 = CoinCpuTime();
    1743                                         totalTime += time2 - time1;
    1744                                         time1 = time2;
    1745                                    }
    1746                               } else {
    1747                                    std::cout << "** Current model not valid" << std::endl;
    1748                               }
    1749                               break;
    1750                          case CLP_PARAM_ACTION_BASISIN:
    1751                               if (goodModels[iModel]) {
    1752                                    // get next field
    1753                                    field = CoinReadGetString(argc, argv);
    1754                                    if (field == "$") {
    1755                                         field = parameters[iParam].stringValue();
    1756                                    } else if (field == "EOL") {
    1757                                         parameters[iParam].printString();
    1758                                         break;
    1759                                    } else {
    1760                                         parameters[iParam].setStringValue(field);
    1761                                    }
    1762                                    std::string fileName;
    1763                                    bool canOpen = false;
    1764                                    if (field == "-") {
    1765                                         // stdin
    1766                                         canOpen = true;
    1767                                         fileName = "-";
    1768                                    } else {
    1769                                         if (field[0] == '/' || field[0] == '\\') {
    1770                                              fileName = field;
    1771                                         } else if (field[0] == '~') {
    1772                                              char * environVar = getenv("HOME");
    1773                                              if (environVar) {
    1774                                                   std::string home(environVar);
    1775                                                   field = field.erase(0, 1);
    1776                                                   fileName = home + field;
    1777                                              } else {
    1778                                                   fileName = field;
    1779                                              }
    1780                                         } else {
    1781                                              fileName = directory + field;
    1782                                         }
    1783                                         FILE *fp = fopen(fileName.c_str(), "r");
    1784                                         if (fp) {
    1785                                              // can open - lets go for it
    1786                                              fclose(fp);
    1787                                              canOpen = true;
    1788                                         } else {
    1789                                              std::cout << "Unable to open file " << fileName << std::endl;
    1790                                         }
    1791                                    }
    1792                                    if (canOpen) {
    1793                                         int values = thisModel->readBasis(fileName.c_str());
    1794                                         if (values == 0)
    1795                                              basisHasValues = -1;
    1796                                         else
    1797                                              basisHasValues = 1;
    1798                                    }
    1799                               } else {
    1800                                    std::cout << "** Current model not valid" << std::endl;
    1801                               }
    1802                               break;
    1803                          case CLP_PARAM_ACTION_PRINTMASK:
    1804                               // get next field
    1805                          {
    1806                               std::string name = CoinReadGetString(argc, argv);
    1807                               if (name != "EOL") {
    1808                                    parameters[iParam].setStringValue(name);
    1809                                    printMask = name;
    1810                               } else {
    1811                                    parameters[iParam].printString();
    1812                               }
    1813                          }
    1814                          break;
    1815                          case CLP_PARAM_ACTION_BASISOUT:
    1816                               if (goodModels[iModel]) {
    1817                                    // get next field
    1818                                    field = CoinReadGetString(argc, argv);
    1819                                    if (field == "$") {
    1820                                         field = parameters[iParam].stringValue();
    1821                                    } else if (field == "EOL") {
    1822                                         parameters[iParam].printString();
    1823                                         break;
    1824                                    } else {
    1825                                         parameters[iParam].setStringValue(field);
    1826                                    }
    1827                                    std::string fileName;
    1828                                    bool canOpen = false;
    1829                                    if (field[0] == '/' || field[0] == '\\') {
    1830                                         fileName = field;
    1831                                    } else if (field[0] == '~') {
    1832                                         char * environVar = getenv("HOME");
    1833                                         if (environVar) {
    1834                                              std::string home(environVar);
    1835                                              field = field.erase(0, 1);
    1836                                              fileName = home + field;
    1837                                         } else {
    1838                                              fileName = field;
    1839                                         }
    1840                                    } else {
    1841                                         fileName = directory + field;
    1842                                    }
    1843                                    FILE *fp = fopen(fileName.c_str(), "w");
    1844                                    if (fp) {
    1845                                         // can open - lets go for it
    1846                                         fclose(fp);
    1847                                         canOpen = true;
    1848                                    } else {
    1849                                         std::cout << "Unable to open file " << fileName << std::endl;
    1850                                    }
    1851                                    if (canOpen) {
    1852                                         ClpSimplex * model2 = models + iModel;
    1853                                         model2->writeBasis(fileName.c_str(), outputFormat > 1, outputFormat - 2);
    1854                                         time2 = CoinCpuTime();
    1855                                         totalTime += time2 - time1;
    1856                                         time1 = time2;
    1857                                    }
    1858                               } else {
    1859                                    std::cout << "** Current model not valid" << std::endl;
    1860                               }
    1861                               break;
    1862                          case CLP_PARAM_ACTION_PARAMETRICS:
    1863                               if (goodModels[iModel]) {
    1864                                    // get next field
    1865                                    field = CoinReadGetString(argc, argv);
    1866                                    if (field == "$") {
    1867                                         field = parameters[iParam].stringValue();
    1868                                    } else if (field == "EOL") {
    1869                                         parameters[iParam].printString();
    1870                                         break;
    1871                                    } else {
    1872                                         parameters[iParam].setStringValue(field);
    1873                                    }
    1874                                    std::string fileName;
    1875                                    //bool canOpen = false;
    1876                                    if (field[0] == '/' || field[0] == '\\') {
    1877                                         fileName = field;
    1878                                    } else if (field[0] == '~') {
    1879                                         char * environVar = getenv("HOME");
    1880                                         if (environVar) {
    1881                                              std::string home(environVar);
    1882                                              field = field.erase(0, 1);
    1883                                              fileName = home + field;
    1884                                         } else {
    1885                                              fileName = field;
    1886                                         }
    1887                                    } else {
    1888                                         fileName = directory + field;
    1889                                    }
    1890                                    ClpSimplex * model2 = models + iModel;
    1891                                    static_cast<ClpSimplexOther *> (model2)->parametrics(fileName.c_str());
    1892                                    time2 = CoinCpuTime();
    1893                                    totalTime += time2 - time1;
    1894                                    time1 = time2;
    1895                               } else {
    1896                                    std::cout << "** Current model not valid" << std::endl;
    1897                               }
    1898                               break;
    1899                          case CLP_PARAM_ACTION_SAVE: {
    1900                               // get next field
    1901                               field = CoinReadGetString(argc, argv);
    1902                               if (field == "$") {
    1903                                    field = parameters[iParam].stringValue();
    1904                               } else if (field == "EOL") {
    1905                                    parameters[iParam].printString();
    1906                                    break;
    1907                               } else {
    1908                                    parameters[iParam].setStringValue(field);
    1909                               }
    1910                               std::string fileName;
    1911                               bool canOpen = false;
    1912                               if (field[0] == '/' || field[0] == '\\') {
    1913                                    fileName = field;
    1914                               } else if (field[0] == '~') {
    1915                                    char * environVar = getenv("HOME");
    1916                                    if (environVar) {
    1917                                         std::string home(environVar);
    1918                                         field = field.erase(0, 1);
    1919                                         fileName = home + field;
    1920                                    } else {
    1921                                         fileName = field;
    1922                                    }
    1923                               } else {
    1924                                    fileName = directory + field;
    1925                               }
    1926                               FILE *fp = fopen(fileName.c_str(), "wb");
    1927                               if (fp) {
    1928                                    // can open - lets go for it
    1929                                    fclose(fp);
    1930                                    canOpen = true;
    1931                               } else {
    1932                                    std::cout << "Unable to open file " << fileName << std::endl;
    1933                               }
    1934                               if (canOpen) {
    1935                                    int status;
    1936                                    // If presolve on then save presolved
    1937                                    bool deleteModel2 = false;
    1938                                    ClpSimplex * model2 = models + iModel;
    1939                                    if (preSolve) {
    1940                                         ClpPresolve pinfo;
    1941                                         double presolveTolerance =
    1942                                              parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, numberParameters, parameters)].doubleValue();
    1943                                         model2 =
    1944                                              pinfo.presolvedModel(models[iModel], presolveTolerance,
    1945                                                                   false, preSolve);
    1946                                         if (model2) {
    1947                                              printf("Saving presolved model on %s\n",
    1948                                                     fileName.c_str());
    1949                                              deleteModel2 = true;
    1950                                         } else {
    1951                                              printf("Presolved model looks infeasible - saving original on %s\n",
    1952                                                     fileName.c_str());
    1953                                              deleteModel2 = false;
    1954                                              model2 = models + iModel;
    1955 
    1956                                         }
    1957                                    } else {
    1958                                         printf("Saving model on %s\n",
    1959                                                fileName.c_str());
    1960                                    }
    1961                                    status = model2->saveModel(fileName.c_str());
    1962                                    if (deleteModel2)
    1963                                         delete model2;
    1964                                    if (!status) {
    1965                                         goodModels[iModel] = true;
    1966                                         time2 = CoinCpuTime();
    1967                                         totalTime += time2 - time1;
    1968                                         time1 = time2;
    1969                                    } else {
    1970                                         // errors
    1971                                         std::cout << "There were errors on output" << std::endl;
    1972                                    }
    1973                               }
    1974                          }
    1975                          break;
    1976                          case CLP_PARAM_ACTION_RESTORE: {
    1977                               // get next field
    1978                               field = CoinReadGetString(argc, argv);
    1979                               if (field == "$") {
    1980                                    field = parameters[iParam].stringValue();
    1981                               } else if (field == "EOL") {
    1982                                    parameters[iParam].printString();
    1983                                    break;
    1984                               } else {
    1985                                    parameters[iParam].setStringValue(field);
    1986                               }
    1987                               std::string fileName;
    1988                               bool canOpen = false;
    1989                               if (field[0] == '/' || field[0] == '\\') {
    1990                                    fileName = field;
    1991                               } else if (field[0] == '~') {
    1992                                    char * environVar = getenv("HOME");
    1993                                    if (environVar) {
    1994                                         std::string home(environVar);
    1995                                         field = field.erase(0, 1);
    1996                                         fileName = home + field;
    1997                                    } else {
    1998                                         fileName = field;
    1999                                    }
    2000                               } else {
    2001                                    fileName = directory + field;
    2002                               }
    2003                               FILE *fp = fopen(fileName.c_str(), "rb");
    2004                               if (fp) {
    2005                                    // can open - lets go for it
    2006                                    fclose(fp);
    2007                                    canOpen = true;
    2008                               } else {
    2009                                    std::cout << "Unable to open file " << fileName << std::endl;
    2010                               }
    2011                               if (canOpen) {
    2012                                    int status = models[iModel].restoreModel(fileName.c_str());
    2013                                    if (!status) {
    2014                                         goodModels[iModel] = true;
    2015                                         time2 = CoinCpuTime();
    2016                                         totalTime += time2 - time1;
    2017                                         time1 = time2;
    2018                                    } else {
    2019                                         // errors
    2020                                         std::cout << "There were errors on input" << std::endl;
    2021                                    }
    2022                               }
    2023                          }
    2024                          break;
    2025                          case CLP_PARAM_ACTION_MAXIMIZE:
    2026                               models[iModel].setOptimizationDirection(-1);
     1716              model2->writeMps(fileName.c_str(), (outputFormat - 1) / 2, 1 + ((outputFormat - 1) & 1));
     1717#endif
     1718              if (deleteModel2)
     1719                delete model2;
     1720              time2 = CoinCpuTime();
     1721              totalTime += time2 - time1;
     1722              time1 = time2;
     1723            }
     1724          } else {
     1725            std::cout << "** Current model not valid" << std::endl;
     1726          }
     1727          break;
     1728        case CLP_PARAM_ACTION_BASISIN:
     1729          if (goodModels[iModel]) {
     1730            // get next field
     1731            field = CoinReadGetString(argc, argv);
     1732            if (field == "$") {
     1733              field = parameters[iParam].stringValue();
     1734            } else if (field == "EOL") {
     1735              parameters[iParam].printString();
     1736              break;
     1737            } else {
     1738              parameters[iParam].setStringValue(field);
     1739            }
     1740            std::string fileName;
     1741            bool canOpen = false;
     1742            if (field == "-") {
     1743              // stdin
     1744              canOpen = true;
     1745              fileName = "-";
     1746            } else {
     1747              if (field[0] == '/' || field[0] == '\\') {
     1748                fileName = field;
     1749              } else if (field[0] == '~') {
     1750                char *environVar = getenv("HOME");
     1751                if (environVar) {
     1752                  std::string home(environVar);
     1753                  field = field.erase(0, 1);
     1754                  fileName = home + field;
     1755                } else {
     1756                  fileName = field;
     1757                }
     1758              } else {
     1759                fileName = directory + field;
     1760              }
     1761              FILE *fp = fopen(fileName.c_str(), "r");
     1762              if (fp) {
     1763                // can open - lets go for it
     1764                fclose(fp);
     1765                canOpen = true;
     1766              } else {
     1767                std::cout << "Unable to open file " << fileName << std::endl;
     1768              }
     1769            }
     1770            if (canOpen) {
     1771              int values = thisModel->readBasis(fileName.c_str());
     1772              if (values == 0)
     1773                basisHasValues = -1;
     1774              else
     1775                basisHasValues = 1;
     1776            }
     1777          } else {
     1778            std::cout << "** Current model not valid" << std::endl;
     1779          }
     1780          break;
     1781        case CLP_PARAM_ACTION_PRINTMASK:
     1782          // get next field
     1783          {
     1784            std::string name = CoinReadGetString(argc, argv);
     1785            if (name != "EOL") {
     1786              parameters[iParam].setStringValue(name);
     1787              printMask = name;
     1788            } else {
     1789              parameters[iParam].printString();
     1790            }
     1791          }
     1792          break;
     1793        case CLP_PARAM_ACTION_BASISOUT:
     1794          if (goodModels[iModel]) {
     1795            // get next field
     1796            field = CoinReadGetString(argc, argv);
     1797            if (field == "$") {
     1798              field = parameters[iParam].stringValue();
     1799            } else if (field == "EOL") {
     1800              parameters[iParam].printString();
     1801              break;
     1802            } else {
     1803              parameters[iParam].setStringValue(field);
     1804            }
     1805            std::string fileName;
     1806            bool canOpen = false;
     1807            if (field[0] == '/' || field[0] == '\\') {
     1808              fileName = field;
     1809            } else if (field[0] == '~') {
     1810              char *environVar = getenv("HOME");
     1811              if (environVar) {
     1812                std::string home(environVar);
     1813                field = field.erase(0, 1);
     1814                fileName = home + field;
     1815              } else {
     1816                fileName = field;
     1817              }
     1818            } else {
     1819              fileName = directory + field;
     1820            }
     1821            FILE *fp = fopen(fileName.c_str(), "w");
     1822            if (fp) {
     1823              // can open - lets go for it
     1824              fclose(fp);
     1825              canOpen = true;
     1826            } else {
     1827              std::cout << "Unable to open file " << fileName << std::endl;
     1828            }
     1829            if (canOpen) {
     1830              ClpSimplex *model2 = models + iModel;
     1831              model2->writeBasis(fileName.c_str(), outputFormat > 1, outputFormat - 2);
     1832              time2 = CoinCpuTime();
     1833              totalTime += time2 - time1;
     1834              time1 = time2;
     1835            }
     1836          } else {
     1837            std::cout << "** Current model not valid" << std::endl;
     1838          }
     1839          break;
     1840        case CLP_PARAM_ACTION_PARAMETRICS:
     1841          if (goodModels[iModel]) {
     1842            // get next field
     1843            field = CoinReadGetString(argc, argv);
     1844            if (field == "$") {
     1845              field = parameters[iParam].stringValue();
     1846            } else if (field == "EOL") {
     1847              parameters[iParam].printString();
     1848              break;
     1849            } else {
     1850              parameters[iParam].setStringValue(field);
     1851            }
     1852            std::string fileName;
     1853            //bool canOpen = false;
     1854            if (field[0] == '/' || field[0] == '\\') {
     1855              fileName = field;
     1856            } else if (field[0] == '~') {
     1857              char *environVar = getenv("HOME");
     1858              if (environVar) {
     1859                std::string home(environVar);
     1860                field = field.erase(0, 1);
     1861                fileName = home + field;
     1862              } else {
     1863                fileName = field;
     1864              }
     1865            } else {
     1866              fileName = directory + field;
     1867            }
     1868            ClpSimplex *model2 = models + iModel;
     1869            static_cast< ClpSimplexOther * >(model2)->parametrics(fileName.c_str());
     1870            time2 = CoinCpuTime();
     1871            totalTime += time2 - time1;
     1872            time1 = time2;
     1873          } else {
     1874            std::cout << "** Current model not valid" << std::endl;
     1875          }
     1876          break;
     1877        case CLP_PARAM_ACTION_SAVE: {
     1878          // get next field
     1879          field = CoinReadGetString(argc, argv);
     1880          if (field == "$") {
     1881            field = parameters[iParam].stringValue();
     1882          } else if (field == "EOL") {
     1883            parameters[iParam].printString();
     1884            break;
     1885          } else {
     1886            parameters[iParam].setStringValue(field);
     1887          }
     1888          std::string fileName;
     1889          bool canOpen = false;
     1890          if (field[0] == '/' || field[0] == '\\') {
     1891            fileName = field;
     1892          } else if (field[0] == '~') {
     1893            char *environVar = getenv("HOME");
     1894            if (environVar) {
     1895              std::string home(environVar);
     1896              field = field.erase(0, 1);
     1897              fileName = home + field;
     1898            } else {
     1899              fileName = field;
     1900            }
     1901          } else {
     1902            fileName = directory + field;
     1903          }
     1904          FILE *fp = fopen(fileName.c_str(), "wb");
     1905          if (fp) {
     1906            // can open - lets go for it
     1907            fclose(fp);
     1908            canOpen = true;
     1909          } else {
     1910            std::cout << "Unable to open file " << fileName << std::endl;
     1911          }
     1912          if (canOpen) {
     1913            int status;
     1914            // If presolve on then save presolved
     1915            bool deleteModel2 = false;
     1916            ClpSimplex *model2 = models + iModel;
     1917            if (preSolve) {
     1918              ClpPresolve pinfo;
     1919              double presolveTolerance = parameters[whichParam(CLP_PARAM_DBL_PRESOLVETOLERANCE, numberParameters, parameters)].doubleValue();
     1920              model2 = pinfo.presolvedModel(models[iModel], presolveTolerance,
     1921                false, preSolve);
     1922              if (model2) {
     1923                printf("Saving presolved model on %s\n",
     1924                  fileName.c_str());
     1925                deleteModel2 = true;
     1926              } else {
     1927                printf("Presolved model looks infeasible - saving original on %s\n",
     1928                  fileName.c_str());
     1929                deleteModel2 = false;
     1930                model2 = models + iModel;
     1931              }
     1932            } else {
     1933              printf("Saving model on %s\n",
     1934                fileName.c_str());
     1935            }
     1936            status = model2->saveModel(fileName.c_str());
     1937            if (deleteModel2)
     1938              delete model2;
     1939            if (!status) {
     1940              goodModels[iModel] = true;
     1941              time2 = CoinCpuTime();
     1942              totalTime += time2 - time1;
     1943              time1 = time2;
     1944            } else {
     1945              // errors
     1946              std::cout << "There were errors on output" << std::endl;
     1947            }
     1948          }
     1949        } break;
     1950        case CLP_PARAM_ACTION_RESTORE: {
     1951          // get next field
     1952          field = CoinReadGetString(argc, argv);
     1953          if (field == "$") {
     1954            field = parameters[iParam].stringValue();
     1955          } else if (field == "EOL") {
     1956            parameters[iParam].printString();
     1957            break;
     1958          } else {
     1959            parameters[iParam].setStringValue(field);
     1960          }
     1961          std::string fileName;
     1962          bool canOpen = false;
     1963          if (field[0] == '/' || field[0] == '\\') {
     1964            fileName = field;
     1965          } else if (field[0] == '~') {
     1966            char *environVar = getenv("HOME");
     1967            if (environVar) {
     1968              std::string home(environVar);
     1969              field = field.erase(0, 1);
     1970              fileName = home + field;
     1971            } else {
     1972              fileName = field;
     1973            }
     1974          } else {
     1975            fileName = directory + field;
     1976          }
     1977          FILE *fp = fopen(fileName.c_str(), "rb");
     1978          if (fp) {
     1979            // can open - lets go for it
     1980            fclose(fp);
     1981            canOpen = true;
     1982          } else {
     1983            std::cout << "Unable to open file " << fileName << std::endl;
     1984          }
     1985          if (canOpen) {
     1986            int status = models[iModel].restoreModel(fileName.c_str());
     1987            if (!status) {
     1988              goodModels[iModel] = true;
     1989              time2 = CoinCpuTime();
     1990              totalTime += time2 - time1;
     1991              time1 = time2;
     1992            } else {
     1993              // errors
     1994              std::cout << "There were errors on input" << std::endl;
     1995            }
     1996          }
     1997        } break;
     1998        case CLP_PARAM_ACTION_MAXIMIZE:
     1999          models[iModel].setOptimizationDirection(-1);
    20272000#ifdef ABC_INHERIT
    2028                               thisModel->setOptimizationDirection(-1);
    2029 #endif
    2030                               break;
    2031                          case CLP_PARAM_ACTION_MINIMIZE:
    2032                               models[iModel].setOptimizationDirection(1);
     2001          thisModel->setOptimizationDirection(-1);
     2002#endif
     2003          break;
     2004        case CLP_PARAM_ACTION_MINIMIZE:
     2005          models[iModel].setOptimizationDirection(1);
    20332006#ifdef ABC_INHERIT
    2034                               thisModel->setOptimizationDirection(1);
    2035 #endif
    2036                               break;
    2037                          case CLP_PARAM_ACTION_ALLSLACK:
    2038                               thisModel->allSlackBasis(true);
     2007          thisModel->setOptimizationDirection(1);
     2008#endif
     2009          break;
     2010        case CLP_PARAM_ACTION_ALLSLACK:
     2011          thisModel->allSlackBasis(true);
    20392012#ifdef ABC_INHERIT
    2040                               models[iModel].allSlackBasis();
    2041 #endif
    2042                               break;
    2043                          case CLP_PARAM_ACTION_REVERSE:
    2044                               if (goodModels[iModel]) {
    2045                                    int iColumn;
    2046                                    int numberColumns = models[iModel].numberColumns();
    2047                                    double * dualColumnSolution =
    2048                                         models[iModel].dualColumnSolution();
    2049                                    ClpObjective * obj = models[iModel].objectiveAsObject();
    2050                                    assert(dynamic_cast<ClpLinearObjective *> (obj));
    2051                                    double offset;
    2052                                    double * objective = obj->gradient(NULL, NULL, offset, true);
    2053                                    for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    2054                                         dualColumnSolution[iColumn] = -dualColumnSolution[iColumn];
    2055                                         objective[iColumn] = -objective[iColumn];
    2056                                    }
    2057                                    int iRow;
    2058                                    int numberRows = models[iModel].numberRows();
    2059                                    double * dualRowSolution =
    2060                                         models[iModel].dualRowSolution();
    2061                                    for (iRow = 0; iRow < numberRows; iRow++) {
    2062                                         dualRowSolution[iRow] = -dualRowSolution[iRow];
    2063                                    }
    2064                                    models[iModel].setObjectiveOffset(-models[iModel].objectiveOffset());
    2065                               }
    2066                               break;
    2067                          case CLP_PARAM_ACTION_DIRECTORY: {
    2068                               std::string name = CoinReadGetString(argc, argv);
    2069                               if (name != "EOL") {
    2070                                    size_t length = name.length();
    2071                                    if (length > 0 && name[length-1] == dirsep) {
    2072                                         directory = name;
    2073                                    } else {
    2074                                         directory = name + dirsep;
    2075                                    }
    2076                                    parameters[iParam].setStringValue(directory);
    2077                               } else {
    2078                                    parameters[iParam].printString();
    2079                               }
    2080                          }
    2081                          break;
    2082                          case CLP_PARAM_ACTION_DIRSAMPLE: {
    2083                               std::string name = CoinReadGetString(argc, argv);
    2084                               if (name != "EOL") {
    2085                                    size_t length = name.length();
    2086                                    if (length > 0 && name[length-1] == dirsep) {
    2087                                         dirSample = name;
    2088                                    } else {
    2089                                         dirSample = name + dirsep;
    2090                                    }
    2091                                    parameters[iParam].setStringValue(dirSample);
    2092                               } else {
    2093                                    parameters[iParam].printString();
    2094                               }
    2095                          }
    2096                          break;
    2097                          case CLP_PARAM_ACTION_DIRNETLIB: {
    2098                               std::string name = CoinReadGetString(argc, argv);
    2099                               if (name != "EOL") {
    2100                                    size_t length = name.length();
    2101                                    if (length > 0 && name[length-1] == dirsep) {
    2102                                         dirNetlib = name;
    2103                                    } else {
    2104                                         dirNetlib = name + dirsep;
    2105                                    }
    2106                                    parameters[iParam].setStringValue(dirNetlib);
    2107                               } else {
    2108                                    parameters[iParam].printString();
    2109                               }
    2110                          }
    2111                          break;
    2112                          case CBC_PARAM_ACTION_DIRMIPLIB: {
    2113                               std::string name = CoinReadGetString(argc, argv);
    2114                               if (name != "EOL") {
    2115                                    size_t length = name.length();
    2116                                    if (length > 0 && name[length-1] == dirsep) {
    2117                                         dirMiplib = name;
    2118                                    } else {
    2119                                         dirMiplib = name + dirsep;
    2120                                    }
    2121                                    parameters[iParam].setStringValue(dirMiplib);
    2122                               } else {
    2123                                    parameters[iParam].printString();
    2124                               }
    2125                          }
    2126                          break;
    2127                          case CLP_PARAM_ACTION_STDIN:
    2128                               CbcOrClpRead_mode = -1;
    2129                               break;
    2130                          case CLP_PARAM_ACTION_NETLIB_DUAL:
    2131                          case CLP_PARAM_ACTION_NETLIB_EITHER:
    2132                          case CLP_PARAM_ACTION_NETLIB_BARRIER:
    2133                          case CLP_PARAM_ACTION_NETLIB_PRIMAL:
    2134                          case CLP_PARAM_ACTION_NETLIB_TUNE: {
    2135                               // create fields for unitTest
    2136                               const char * fields[4];
    2137                               int nFields = 4;
    2138                               fields[0] = "fake main from unitTest";
    2139                               std::string mpsfield = "-dirSample=";
    2140                               mpsfield += dirSample.c_str();
    2141                               fields[1] = mpsfield.c_str();
    2142                               std::string netfield = "-dirNetlib=";
    2143                               netfield += dirNetlib.c_str();
    2144                               fields[2] = netfield.c_str();
    2145                               fields[3] = "-netlib";
    2146                               int algorithm;
    2147                               if (type == CLP_PARAM_ACTION_NETLIB_DUAL) {
    2148                                    std::cerr << "Doing netlib with dual algorithm" << std::endl;
    2149                                    algorithm = 0;
    2150                                    models[iModel].setMoreSpecialOptions(models[iModel].moreSpecialOptions()|32768);
    2151                               } else if (type == CLP_PARAM_ACTION_NETLIB_BARRIER) {
    2152                                    std::cerr << "Doing netlib with barrier algorithm" << std::endl;
    2153                                    algorithm = 2;
    2154                               } else if (type == CLP_PARAM_ACTION_NETLIB_EITHER) {
    2155                                    std::cerr << "Doing netlib with dual or primal algorithm" << std::endl;
    2156                                    algorithm = 3;
    2157                               } else if (type == CLP_PARAM_ACTION_NETLIB_TUNE) {
    2158                                    std::cerr << "Doing netlib with best algorithm!" << std::endl;
    2159                                    algorithm = 5;
    2160                                    // uncomment next to get active tuning
    2161                                    // algorithm=6;
    2162                               } else {
    2163                                    std::cerr << "Doing netlib with primal algorithm" << std::endl;
    2164                                    algorithm = 1;
    2165                               }
    2166                               //int specialOptions = models[iModel].specialOptions();
    2167                               models[iModel].setSpecialOptions(0);
    2168                               ClpSolve solveOptions;
    2169                               ClpSolve::PresolveType presolveType;
    2170                               if (preSolve)
    2171                                    presolveType = ClpSolve::presolveOn;
    2172                               else
    2173                                    presolveType = ClpSolve::presolveOff;
    2174                               solveOptions.setPresolveType(presolveType, 5);
    2175                               if (doSprint >= 0 || doIdiot >= 0) {
    2176                                    if (doSprint > 0) {
    2177                                         // sprint overrides idiot
    2178                                         solveOptions.setSpecialOption(1, 3, doSprint); // sprint
    2179                                    } else if (doIdiot > 0) {
    2180                                         solveOptions.setSpecialOption(1, 2, doIdiot); // idiot
    2181                                    } else {
    2182                                         if (doIdiot == 0) {
    2183                                              if (doSprint == 0)
    2184                                                   solveOptions.setSpecialOption(1, 4); // all slack
    2185                                              else
    2186                                                   solveOptions.setSpecialOption(1, 9); // all slack or sprint
    2187                                         } else {
    2188                                              if (doSprint == 0)
    2189                                                   solveOptions.setSpecialOption(1, 8); // all slack or idiot
    2190                                              else
    2191                                                   solveOptions.setSpecialOption(1, 7); // initiative
    2192                                         }
    2193                                    }
    2194                               }
     2013          models[iModel].allSlackBasis();
     2014#endif
     2015          break;
     2016        case CLP_PARAM_ACTION_REVERSE:
     2017          if (goodModels[iModel]) {
     2018            int iColumn;
     2019            int numberColumns = models[iModel].numberColumns();
     2020            double *dualColumnSolution = models[iModel].dualColumnSolution();
     2021            ClpObjective *obj = models[iModel].objectiveAsObject();
     2022            assert(dynamic_cast< ClpLinearObjective * >(obj));
     2023            double offset;
     2024            double *objective = obj->gradient(NULL, NULL, offset, true);
     2025            for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     2026              dualColumnSolution[iColumn] = -dualColumnSolution[iColumn];
     2027              objective[iColumn] = -objective[iColumn];
     2028            }
     2029            int iRow;
     2030            int numberRows = models[iModel].numberRows();
     2031            double *dualRowSolution = models[iModel].dualRowSolution();
     2032            for (iRow = 0; iRow < numberRows; iRow++) {
     2033              dualRowSolution[iRow] = -dualRowSolution[iRow];
     2034            }
     2035            models[iModel].setObjectiveOffset(-models[iModel].objectiveOffset());
     2036          }
     2037          break;
     2038        case CLP_PARAM_ACTION_DIRECTORY: {
     2039          std::string name = CoinReadGetString(argc, argv);
     2040          if (name != "EOL") {
     2041            size_t length = name.length();
     2042            if (length > 0 && name[length - 1] == dirsep) {
     2043              directory = name;
     2044            } else {
     2045              directory = name + dirsep;
     2046            }
     2047            parameters[iParam].setStringValue(directory);
     2048          } else {
     2049            parameters[iParam].printString();
     2050          }
     2051        } break;
     2052        case CLP_PARAM_ACTION_DIRSAMPLE: {
     2053          std::string name = CoinReadGetString(argc, argv);
     2054          if (name != "EOL") {
     2055            size_t length = name.length();
     2056            if (length > 0 && name[length - 1] == dirsep) {
     2057              dirSample = name;
     2058            } else {
     2059              dirSample = name + dirsep;
     2060            }
     2061            parameters[iParam].setStringValue(dirSample);
     2062          } else {
     2063            parameters[iParam].printString();
     2064          }
     2065        } break;
     2066        case CLP_PARAM_ACTION_DIRNETLIB: {
     2067          std::string name = CoinReadGetString(argc, argv);
     2068          if (name != "EOL") {
     2069            size_t length = name.length();
     2070            if (length > 0 && name[length - 1] == dirsep) {
     2071              dirNetlib = name;
     2072            } else {
     2073              dirNetlib = name + dirsep;
     2074            }
     2075            parameters[iParam].setStringValue(dirNetlib);
     2076          } else {
     2077            parameters[iParam].printString();
     2078          }
     2079        } break;
     2080        case CBC_PARAM_ACTION_DIRMIPLIB: {
     2081          std::string name = CoinReadGetString(argc, argv);
     2082          if (name != "EOL") {
     2083            size_t length = name.length();
     2084            if (length > 0 && name[length - 1] == dirsep) {
     2085              dirMiplib = name;
     2086            } else {
     2087              dirMiplib = name + dirsep;
     2088            }
     2089            parameters[iParam].setStringValue(dirMiplib);
     2090          } else {
     2091            parameters[iParam].printString();
     2092          }
     2093        } break;
     2094        case CLP_PARAM_ACTION_STDIN:
     2095          CbcOrClpRead_mode = -1;
     2096          break;
     2097        case CLP_PARAM_ACTION_NETLIB_DUAL:
     2098        case CLP_PARAM_ACTION_NETLIB_EITHER:
     2099        case CLP_PARAM_ACTION_NETLIB_BARRIER:
     2100        case CLP_PARAM_ACTION_NETLIB_PRIMAL:
     2101        case CLP_PARAM_ACTION_NETLIB_TUNE: {
     2102          // create fields for unitTest
     2103          const char *fields[4];
     2104          int nFields = 4;
     2105          fields[0] = "fake main from unitTest";
     2106          std::string mpsfield = "-dirSample=";
     2107          mpsfield += dirSample.c_str();
     2108          fields[1] = mpsfield.c_str();
     2109          std::string netfield = "-dirNetlib=";
     2110          netfield += dirNetlib.c_str();
     2111          fields[2] = netfield.c_str();
     2112          fields[3] = "-netlib";
     2113          int algorithm;
     2114          if (type == CLP_PARAM_ACTION_NETLIB_DUAL) {
     2115            std::cerr << "Doing netlib with dual algorithm" << std::endl;
     2116            algorithm = 0;
     2117            models[iModel].setMoreSpecialOptions(models[iModel].moreSpecialOptions() | 32768);
     2118          } else if (type == CLP_PARAM_ACTION_NETLIB_BARRIER) {
     2119            std::cerr << "Doing netlib with barrier algorithm" << std::endl;
     2120            algorithm = 2;
     2121          } else if (type == CLP_PARAM_ACTION_NETLIB_EITHER) {
     2122            std::cerr << "Doing netlib with dual or primal algorithm" << std::endl;
     2123            algorithm = 3;
     2124          } else if (type == CLP_PARAM_ACTION_NETLIB_TUNE) {
     2125            std::cerr << "Doing netlib with best algorithm!" << std::endl;
     2126            algorithm = 5;
     2127            // uncomment next to get active tuning
     2128            // algorithm=6;
     2129          } else {
     2130            std::cerr << "Doing netlib with primal algorithm" << std::endl;
     2131            algorithm = 1;
     2132          }
     2133          //int specialOptions = models[iModel].specialOptions();
     2134          models[iModel].setSpecialOptions(0);
     2135          ClpSolve solveOptions;
     2136          ClpSolve::PresolveType presolveType;
     2137          if (preSolve)
     2138            presolveType = ClpSolve::presolveOn;
     2139          else
     2140            presolveType = ClpSolve::presolveOff;
     2141          solveOptions.setPresolveType(presolveType, 5);
     2142          if (doSprint >= 0 || doIdiot >= 0) {
     2143            if (doSprint > 0) {
     2144              // sprint overrides idiot
     2145              solveOptions.setSpecialOption(1, 3, doSprint); // sprint
     2146            } else if (doIdiot > 0) {
     2147              solveOptions.setSpecialOption(1, 2, doIdiot); // idiot
     2148            } else {
     2149              if (doIdiot == 0) {
     2150                if (doSprint == 0)
     2151                  solveOptions.setSpecialOption(1, 4); // all slack
     2152                else
     2153                  solveOptions.setSpecialOption(1, 9); // all slack or sprint
     2154              } else {
     2155                if (doSprint == 0)
     2156                  solveOptions.setSpecialOption(1, 8); // all slack or idiot
     2157                else
     2158                  solveOptions.setSpecialOption(1, 7); // initiative
     2159              }
     2160            }
     2161          }
    21952162#if FACTORIZATION_STATISTICS
    2196                               {
    2197                                 extern int loSizeX;
    2198                                 extern int hiSizeX;
    2199                                 for (int i=0;i<argc;i++) {
    2200                                   if (!strcmp(argv[i],"-losize")) {
    2201                                     int size=atoi(argv[i+1]);
    2202                                     if (size>0)
    2203                                       loSizeX=size;
    2204                                   }
    2205                                   if (!strcmp(argv[i],"-hisize")) {
    2206                                     int size=atoi(argv[i+1]);
    2207                                     if (size>loSizeX)
    2208                                       hiSizeX=size;
    2209                                   }
    2210                                 }
    2211                                 if (loSizeX!=-1||hiSizeX!=1000000)
    2212                                   printf("Solving problems %d<= and <%d\n",loSizeX,hiSizeX);
    2213                               }
    2214 #endif
    2215                               // for moment then back to models[iModel]
     2163          {
     2164            extern int loSizeX;
     2165            extern int hiSizeX;
     2166            for (int i = 0; i < argc; i++) {
     2167              if (!strcmp(argv[i], "-losize")) {
     2168                int size = atoi(argv[i + 1]);
     2169                if (size > 0)
     2170                  loSizeX = size;
     2171              }
     2172              if (!strcmp(argv[i], "-hisize")) {
     2173                int size = atoi(argv[i + 1]);
     2174                if (size > loSizeX)
     2175                  hiSizeX = size;
     2176              }
     2177            }
     2178            if (loSizeX != -1 || hiSizeX != 1000000)
     2179              printf("Solving problems %d<= and <%d\n", loSizeX, hiSizeX);
     2180          }
     2181#endif
     2182          // for moment then back to models[iModel]
    22162183#ifndef ABC_INHERIT
    2217                               int specialOptions = models[iModel].specialOptions();
    2218                               mainTest(nFields, fields, algorithm, *thisModel,
    2219                                        solveOptions, specialOptions, doVector != 0);
     2184          int specialOptions = models[iModel].specialOptions();
     2185          mainTest(nFields, fields, algorithm, *thisModel,
     2186            solveOptions, specialOptions, doVector != 0);
    22202187#else
    2221                               //if (!processTune) {
    2222                               //specialOptions=0;
    2223                               //models->setSpecialOptions(models->specialOptions()&~65536);
    2224                               // }
    2225                               mainTest(nFields, fields, algorithm, *models,
    2226                                        solveOptions, 0, doVector != 0);
    2227 #endif
    2228                          }
    2229                          break;
    2230                          case CLP_PARAM_ACTION_UNITTEST: {
    2231                               // create fields for unitTest
    2232                               const char * fields[2];
    2233                               int nFields = 2;
    2234                               fields[0] = "fake main from unitTest";
    2235                               std::string dirfield = "-dirSample=";
    2236                               dirfield += dirSample.c_str();
    2237                               fields[1] = dirfield.c_str();
    2238                               int specialOptions = models[iModel].specialOptions();
    2239                               models[iModel].setSpecialOptions(0);
    2240                               int algorithm = -1;
    2241                               if (models[iModel].numberRows())
    2242                                    algorithm = 7;
    2243                               ClpSolve solveOptions;
    2244                               ClpSolve::PresolveType presolveType;
    2245                               if (preSolve)
    2246                                    presolveType = ClpSolve::presolveOn;
    2247                               else
    2248                                    presolveType = ClpSolve::presolveOff;
    2249                               solveOptions.setPresolveType(presolveType, 5);
     2188          //if (!processTune) {
     2189          //specialOptions=0;
     2190          //models->setSpecialOptions(models->specialOptions()&~65536);
     2191          // }
     2192          mainTest(nFields, fields, algorithm, *models,
     2193            solveOptions, 0, doVector != 0);
     2194#endif
     2195        } break;
     2196        case CLP_PARAM_ACTION_UNITTEST: {
     2197          // create fields for unitTest
     2198          const char *fields[2];
     2199          int nFields = 2;
     2200          fields[0] = "fake main from unitTest";
     2201          std::string dirfield = "-dirSample=";
     2202          dirfield += dirSample.c_str();
     2203          fields[1] = dirfield.c_str();
     2204          int specialOptions = models[iModel].specialOptions();
     2205          models[iModel].setSpecialOptions(0);
     2206          int algorithm = -1;
     2207          if (models[iModel].numberRows())
     2208            algorithm = 7;
     2209          ClpSolve solveOptions;
     2210          ClpSolve::PresolveType presolveType;
     2211          if (preSolve)
     2212            presolveType = ClpSolve::presolveOn;
     2213          else
     2214            presolveType = ClpSolve::presolveOff;
     2215          solveOptions.setPresolveType(presolveType, 5);
    22502216#ifndef ABC_INHERIT
    2251                               mainTest(nFields, fields, algorithm, *thisModel,
    2252                                        solveOptions, specialOptions, doVector != 0);
     2217          mainTest(nFields, fields, algorithm, *thisModel,
     2218            solveOptions, specialOptions, doVector != 0);
    22532219#else
    2254                               mainTest(nFields, fields, algorithm, *models,
    2255                                        solveOptions, specialOptions, doVector != 0);
    2256 #endif
    2257                          }
    2258                          break;
    2259                          case CLP_PARAM_ACTION_FAKEBOUND:
    2260                               if (goodModels[iModel]) {
    2261                                    // get bound
    2262                                    double value = CoinReadGetDoubleField(argc, argv, &valid);
    2263                                    if (!valid) {
    2264                                         std::cout << "Setting " << parameters[iParam].name() <<
    2265                                                   " to DEBUG " << value << std::endl;
    2266                                         int iRow;
    2267                                         int numberRows = models[iModel].numberRows();
    2268                                         double * rowLower = models[iModel].rowLower();
    2269                                         double * rowUpper = models[iModel].rowUpper();
    2270                                         for (iRow = 0; iRow < numberRows; iRow++) {
    2271                                              // leave free ones for now
    2272                                              if (rowLower[iRow] > -1.0e20 || rowUpper[iRow] < 1.0e20) {
    2273                                                   rowLower[iRow] = CoinMax(rowLower[iRow], -value);
    2274                                                   rowUpper[iRow] = CoinMin(rowUpper[iRow], value);
    2275                                              }
    2276                                         }
    2277                                         int iColumn;
    2278                                         int numberColumns = models[iModel].numberColumns();
    2279                                         double * columnLower = models[iModel].columnLower();
    2280                                         double * columnUpper = models[iModel].columnUpper();
    2281                                         for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    2282                                              // leave free ones for now
    2283                                              if (columnLower[iColumn] > -1.0e20 ||
    2284                                                        columnUpper[iColumn] < 1.0e20) {
    2285                                                   columnLower[iColumn] = CoinMax(columnLower[iColumn], -value);
    2286                                                   columnUpper[iColumn] = CoinMin(columnUpper[iColumn], value);
    2287                                              }
    2288                                         }
    2289                                    } else if (valid == 1) {
    2290                                         abort();
    2291                                    } else {
    2292                                         std::cout << "enter value for " << parameters[iParam].name() <<
    2293                                                   std::endl;
    2294                                    }
    2295                               }
    2296                               break;
    2297                          case CLP_PARAM_ACTION_REALLY_SCALE:
    2298                               if (goodModels[iModel]) {
    2299                                    ClpSimplex newModel(models[iModel],
    2300                                                        models[iModel].scalingFlag());
    2301                                    printf("model really really scaled\n");
    2302                                    models[iModel] = newModel;
    2303                               }
    2304                               break;
    2305                          case CLP_PARAM_ACTION_USERCLP:
    2306                               // Replace the sample code by whatever you want
    2307                               if (goodModels[iModel]) {
    2308                                    ClpSimplex * thisModel = &models[iModel];
    2309                                    printf("Dummy user code - model has %d rows and %d columns\n",
    2310                                           thisModel->numberRows(), thisModel->numberColumns());
    2311                               }
    2312                               break;
    2313                          case CLP_PARAM_ACTION_HELP:
    2314                               std::cout << "Coin LP version " << CLP_VERSION
    2315                                         << ", build " << __DATE__ << std::endl;
    2316                               std::cout << "Non default values:-" << std::endl;
    2317                               std::cout << "Perturbation " << models[0].perturbation() << " (default 100)"
    2318                                         << std::endl;
    2319                               CoinReadPrintit(
    2320                                    "Presolve being done with 5 passes\n\
     2220          mainTest(nFields, fields, algorithm, *models,
     2221            solveOptions, specialOptions, doVector != 0);
     2222#endif
     2223        } break;
     2224        case CLP_PARAM_ACTION_FAKEBOUND:
     2225          if (goodModels[iModel]) {
     2226            // get bound
     2227            double value = CoinReadGetDoubleField(argc, argv, &valid);
     2228            if (!valid) {
     2229              std::cout << "Setting " << parameters[iParam].name() << " to DEBUG " << value << std::endl;
     2230              int iRow;
     2231              int numberRows = models[iModel].numberRows();
     2232              double *rowLower = models[iModel].rowLower();
     2233              double *rowUpper = models[iModel].rowUpper();
     2234              for (iRow = 0; iRow < numberRows; iRow++) {
     2235                // leave free ones for now
     2236                if (rowLower[iRow] > -1.0e20 || rowUpper[iRow] < 1.0e20) {
     2237                  rowLower[iRow] = CoinMax(rowLower[iRow], -value);
     2238                  rowUpper[iRow] = CoinMin(rowUpper[iRow], value);
     2239                }
     2240              }
     2241              int iColumn;
     2242              int numberColumns = models[iModel].numberColumns();
     2243              double *columnLower = models[iModel].columnLower();
     2244              double *columnUpper = models[iModel].columnUpper();
     2245              for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     2246                // leave free ones for now
     2247                if (columnLower[iColumn] > -1.0e20 || columnUpper[iColumn] < 1.0e20) {
     2248                  columnLower[iColumn] = CoinMax(columnLower[iColumn], -value);
     2249                  columnUpper[iColumn] = CoinMin(columnUpper[iColumn], value);
     2250                }
     2251              }
     2252            } else if (valid == 1) {
     2253              abort();
     2254            } else {
     2255              std::cout << "enter value for " << parameters[iParam].name() << std::endl;
     2256            }
     2257          }
     2258          break;
     2259        case CLP_PARAM_ACTION_REALLY_SCALE:
     2260          if (goodModels[iModel]) {
     2261            ClpSimplex newModel(models[iModel],
     2262              models[iModel].scalingFlag());
     2263            printf("model really really scaled\n");
     2264            models[iModel] = newModel;
     2265          }
     2266          break;
     2267        case CLP_PARAM_ACTION_USERCLP:
     2268          // Replace the sample code by whatever you want
     2269          if (goodModels[iModel]) {
     2270            ClpSimplex *thisModel = &models[iModel];
     2271            printf("Dummy user code - model has %d rows and %d columns\n",
     2272              thisModel->numberRows(), thisModel->numberColumns());
     2273          }
     2274          break;
     2275        case CLP_PARAM_ACTION_HELP:
     2276          std::cout << "Coin LP version " << CLP_VERSION
     2277                    << ", build " << __DATE__ << std::endl;
     2278          std::cout << "Non default values:-" << std::endl;
     2279          std::cout << "Perturbation " << models[0].perturbation() << " (default 100)"
     2280                    << std::endl;
     2281          CoinReadPrintit(
     2282            "Presolve being done with 5 passes\n\
    23212283Dual steepest edge steep/partial on matrix shape and factorization density\n\
    23222284Clpnnnn taken out of messages\n\
     
    23252287You can switch to interactive mode at any time so\n\
    23262288clp watson.mps -scaling off -primalsimplex\nis the same as\n\
    2327 clp watson.mps -\nscaling off\nprimalsimplex"
    2328                               );
    2329                               break;
    2330                          case CLP_PARAM_ACTION_SOLUTION:
    2331                          case CLP_PARAM_ACTION_GMPL_SOLUTION:
    2332                               if (goodModels[iModel]) {
    2333                                    // get next field
    2334                                    field = CoinReadGetString(argc, argv);
    2335                                    bool append = false;
    2336                                    if (field == "append$") {
    2337                                      field = "$";
    2338                                      append = true;
    2339                                    }
    2340                                    if (field == "$") {
    2341                                         field = parameters[iParam].stringValue();
    2342                                    } else if (field == "EOL") {
    2343                                         parameters[iParam].printString();
    2344                                         break;
    2345                                    } else {
    2346                                         parameters[iParam].setStringValue(field);
    2347                                    }
    2348                                    std::string fileName;
    2349                                    FILE *fp = NULL;
    2350                                    if (field == "-" || field == "EOL" || field == "stdout") {
    2351                                         // stdout
    2352                                         fp = stdout;
    2353                                         fprintf(fp, "\n");
    2354                                    } else if (field == "stderr") {
    2355                                         // stderr
    2356                                         fp = stderr;
    2357                                         fprintf(fp, "\n");
    2358                                    } else {
    2359                                         if (field[0] == '/' || field[0] == '\\') {
    2360                                              fileName = field;
    2361                                         } else if (field[0] == '~') {
    2362                                              char * environVar = getenv("HOME");
    2363                                              if (environVar) {
    2364                                                   std::string home(environVar);
    2365                                                   field = field.erase(0, 1);
    2366                                                   fileName = home + field;
    2367                                              } else {
    2368                                                   fileName = field;
    2369                                              }
    2370                                         } else {
    2371                                              fileName = directory + field;
    2372                                         }
    2373                                         if (!append)
    2374                                           fp = fopen(fileName.c_str(), "w");
    2375                                         else
    2376                                           fp = fopen(fileName.c_str(), "a");
    2377                                    }
    2378                                    if (fp) {
    2379                                      // See if Glpk
    2380                                      if (type == CLP_PARAM_ACTION_GMPL_SOLUTION) {
    2381                                        int numberRows = models[iModel].getNumRows();
    2382                                        int numberColumns = models[iModel].getNumCols();
    2383                                        int numberGlpkRows=numberRows+1;
     2289clp watson.mps -\nscaling off\nprimalsimplex");
     2290          break;
     2291        case CLP_PARAM_ACTION_SOLUTION:
     2292        case CLP_PARAM_ACTION_GMPL_SOLUTION:
     2293          if (goodModels[iModel]) {
     2294            // get next field
     2295            field = CoinReadGetString(argc, argv);
     2296            bool append = false;
     2297            if (field == "append$") {
     2298              field = "$";
     2299              append = true;
     2300            }
     2301            if (field == "$") {
     2302              field = parameters[iParam].stringValue();
     2303            } else if (field == "EOL") {
     2304              parameters[iParam].printString();
     2305              break;
     2306            } else {
     2307              parameters[iParam].setStringValue(field);
     2308            }
     2309            std::string fileName;
     2310            FILE *fp = NULL;
     2311            if (field == "-" || field == "EOL" || field == "stdout") {
     2312              // stdout
     2313              fp = stdout;
     2314              fprintf(fp, "\n");
     2315            } else if (field == "stderr") {
     2316              // stderr
     2317              fp = stderr;
     2318              fprintf(fp, "\n");
     2319            } else {
     2320              if (field[0] == '/' || field[0] == '\\') {
     2321                fileName = field;
     2322              } else if (field[0] == '~') {
     2323                char *environVar = getenv("HOME");
     2324                if (environVar) {
     2325                  std::string home(environVar);
     2326                  field = field.erase(0, 1);
     2327                  fileName = home + field;
     2328                } else {
     2329                  fileName = field;
     2330                }
     2331              } else {
     2332                fileName = directory + field;
     2333              }
     2334              if (!append)
     2335                fp = fopen(fileName.c_str(), "w");
     2336              else
     2337                fp = fopen(fileName.c_str(), "a");
     2338            }
     2339            if (fp) {
     2340              // See if Glpk
     2341              if (type == CLP_PARAM_ACTION_GMPL_SOLUTION) {
     2342                int numberRows = models[iModel].getNumRows();
     2343                int numberColumns = models[iModel].getNumCols();
     2344                int numberGlpkRows = numberRows + 1;
    23842345#ifdef COIN_HAS_GLPK
    2385                                        if (cbc_glp_prob) {
    2386                                          // from gmpl
    2387                                          numberGlpkRows=glp_get_num_rows(cbc_glp_prob);
    2388                                          if (numberGlpkRows!=numberRows)
    2389                                            printf("Mismatch - cbc %d rows, glpk %d\n",
    2390                                                   numberRows,numberGlpkRows);
    2391                                        }
    2392 #endif
    2393                                        fprintf(fp,"%d %d\n",numberGlpkRows,
    2394                                                numberColumns);
    2395                                        int iStat = models[iModel].status();
    2396                                        int iStat2 = GLP_UNDEF;
    2397                                        if (iStat == 0) {
    2398                                          // optimal
    2399                                          iStat2 = GLP_FEAS;
    2400                                        } else if (iStat == 1) {
    2401                                          // infeasible
    2402                                          iStat2 = GLP_NOFEAS;
    2403                                        } else if (iStat == 2) {
    2404                                          // unbounded
    2405                                          // leave as 1
    2406                                        } else if (iStat >= 3 && iStat <= 5) {
    2407                                          iStat2 = GLP_FEAS;
    2408                                        }
    2409                                        double objValue = models[iModel].getObjValue()
    2410                                          * models[iModel].getObjSense();
    2411                                        fprintf(fp,"%d 2 %g\n",iStat2,objValue);
    2412                                        if (numberGlpkRows > numberRows) {
    2413                                          // objective as row
    2414                                          fprintf(fp,"4 %g 1.0\n",objValue);
    2415                                        }
    2416                                        int lookup[6]=
    2417                                          {4,1,3,2,4,5};
    2418                                        const double * primalRowSolution =
    2419                                          models[iModel].primalRowSolution();
    2420                                        const double * dualRowSolution =
    2421                                          models[iModel].dualRowSolution();
    2422                                        for (int i=0;i<numberRows;i++) {
    2423                                          fprintf(fp,"%d %g %g\n",lookup[models[iModel].getRowStatus(i)],
    2424                                                  primalRowSolution[i],dualRowSolution[i]);
    2425                                        }
    2426                                        const double * primalColumnSolution =
    2427                                          models[iModel].primalColumnSolution();
    2428                                        const double * dualColumnSolution =
    2429                                          models[iModel].dualColumnSolution();
    2430                                        for (int i=0;i<numberColumns;i++) {
    2431                                          fprintf(fp,"%d %g %g\n",lookup[models[iModel].getColumnStatus(i)],
    2432                                                  primalColumnSolution[i],dualColumnSolution[i]);
    2433                                        }
    2434                                        fclose(fp);
     2346                if (cbc_glp_prob) {
     2347                  // from gmpl
     2348                  numberGlpkRows = glp_get_num_rows(cbc_glp_prob);
     2349                  if (numberGlpkRows != numberRows)
     2350                    printf("Mismatch - cbc %d rows, glpk %d\n",
     2351                      numberRows, numberGlpkRows);
     2352                }
     2353#endif
     2354                fprintf(fp, "%d %d\n", numberGlpkRows,
     2355                  numberColumns);
     2356                int iStat = models[iModel].status();
     2357                int iStat2 = GLP_UNDEF;
     2358                if (iStat == 0) {
     2359                  // optimal
     2360                  iStat2 = GLP_FEAS;
     2361                } else if (iStat == 1) {
     2362                  // infeasible
     2363                  iStat2 = GLP_NOFEAS;
     2364                } else if (iStat == 2) {
     2365                  // unbounded
     2366                  // leave as 1
     2367                } else if (iStat >= 3 && iStat <= 5) {
     2368                  iStat2 = GLP_FEAS;
     2369                }
     2370                double objValue = models[iModel].getObjValue()
     2371                  * models[iModel].getObjSense();
     2372                fprintf(fp, "%d 2 %g\n", iStat2, objValue);
     2373                if (numberGlpkRows > numberRows) {
     2374                  // objective as row
     2375                  fprintf(fp, "4 %g 1.0\n", objValue);
     2376                }
     2377                int lookup[6] = { 4, 1, 3, 2, 4, 5 };
     2378                const double *primalRowSolution = models[iModel].primalRowSolution();
     2379                const double *dualRowSolution = models[iModel].dualRowSolution();
     2380                for (int i = 0; i < numberRows; i++) {
     2381                  fprintf(fp, "%d %g %g\n", lookup[models[iModel].getRowStatus(i)],
     2382                    primalRowSolution[i], dualRowSolution[i]);
     2383                }
     2384                const double *primalColumnSolution = models[iModel].primalColumnSolution();
     2385                const double *dualColumnSolution = models[iModel].dualColumnSolution();
     2386                for (int i = 0; i < numberColumns; i++) {
     2387                  fprintf(fp, "%d %g %g\n", lookup[models[iModel].getColumnStatus(i)],
     2388                    primalColumnSolution[i], dualColumnSolution[i]);
     2389                }
     2390                fclose(fp);
    24352391#ifdef COIN_HAS_GLPK
    2436                                        if (cbc_glp_prob) {
    2437                                          glp_read_sol(cbc_glp_prob,fileName.c_str());
    2438                                          glp_mpl_postsolve(cbc_glp_tran,
    2439                                                            cbc_glp_prob,
    2440                                                            GLP_SOL);
    2441                                          // free up as much as possible
    2442                                          glp_free(cbc_glp_prob);
    2443                                          glp_mpl_free_wksp(cbc_glp_tran);
    2444                                          cbc_glp_prob = NULL;
    2445                                          cbc_glp_tran = NULL;
    2446                                          //gmp_free_mem();
    2447                                          /* check that no memory blocks are still allocated */
    2448                                          glp_free_env();
    2449                                        }
    2450 #endif
    2451                                        break;
    2452                                      }
    2453                                         // Write solution header (suggested by Luigi Poderico)
    2454                                         double objValue = models[iModel].getObjValue() * models[iModel].getObjSense();
    2455                                         int iStat = models[iModel].status();
    2456                                         if (iStat == 0) {
    2457                                              fprintf(fp, "optimal\n" );
    2458                                         } else if (iStat == 1) {
    2459                                              // infeasible
    2460                                              fprintf(fp, "infeasible\n" );
    2461                                         } else if (iStat == 2) {
    2462                                              // unbounded
    2463                                              fprintf(fp, "unbounded\n" );
    2464                                         } else if (iStat == 3) {
    2465                                              fprintf(fp, "stopped on iterations or time\n" );
    2466                                         } else if (iStat == 4) {
    2467                                              fprintf(fp, "stopped on difficulties\n" );
    2468                                         } else if (iStat == 5) {
    2469                                              fprintf(fp, "stopped on ctrl-c\n" );
    2470                                         } else {
    2471                                              fprintf(fp, "status unknown\n" );
    2472                                         }
    2473                                         char printFormat[50];
    2474                                         sprintf(printFormat,"Objective value %s\n",
    2475                                                 CLP_QUOTE(CLP_OUTPUT_FORMAT));
    2476                                         fprintf(fp, printFormat, objValue);
    2477                                         if (printMode==9) {
    2478                                           // just statistics
    2479                                           int numberRows = models[iModel].numberRows();
    2480                                           double * dualRowSolution = models[iModel].dualRowSolution();
    2481                                           double * primalRowSolution =
    2482                                             models[iModel].primalRowSolution();
    2483                                           double * rowLower = models[iModel].rowLower();
    2484                                           double * rowUpper = models[iModel].rowUpper();
    2485                                           double highestPrimal;
    2486                                           double lowestPrimal;
    2487                                           double highestDual;
    2488                                           double lowestDual;
    2489                                           double largestAway;
    2490                                           int numberAtLower;
    2491                                           int numberAtUpper;
    2492                                           int numberBetween;
    2493                                           highestPrimal=-COIN_DBL_MAX;
    2494                                           lowestPrimal=COIN_DBL_MAX;
    2495                                           highestDual=-COIN_DBL_MAX;
    2496                                           lowestDual=COIN_DBL_MAX;
    2497                                           largestAway=0.0;;
    2498                                           numberAtLower=0;
    2499                                           numberAtUpper=0;
    2500                                           numberBetween=0;
    2501                                           for (int iRow=0;iRow<numberRows;iRow++) {
    2502                                             double primal=primalRowSolution[iRow];
    2503                                             double lower=rowLower[iRow];
    2504                                             double upper=rowUpper[iRow];
    2505                                             double dual=dualRowSolution[iRow];
    2506                                             highestPrimal=CoinMax(highestPrimal,primal);
    2507                                             lowestPrimal=CoinMin(lowestPrimal,primal);
    2508                                             highestDual=CoinMax(highestDual,dual);
    2509                                             lowestDual=CoinMin(lowestDual,dual);
    2510                                             if (primal<lower+1.0e-6) {
    2511                                               numberAtLower++;
    2512                                             } else if (primal>upper-1.0e-6) {
    2513                                               numberAtUpper++;
    2514                                             } else {
    2515                                               numberBetween++;
    2516                                               largestAway=CoinMax(largestAway,
    2517                                                                   CoinMin(primal-lower,upper-primal));
    2518                                             }
    2519                                           }
    2520                                           printf("For rows %d at lower, %d between, %d at upper - lowest %g, highest %g most away %g - highest dual %g lowest %g\n",
    2521                                                  numberAtLower,numberBetween,numberAtUpper,
    2522                                                  lowestPrimal,highestPrimal,largestAway,
    2523                                                  lowestDual,highestDual);
    2524                                           int numberColumns = models[iModel].numberColumns();
    2525                                           double * dualColumnSolution = models[iModel].dualColumnSolution();
    2526                                           double * primalColumnSolution =
    2527                                             models[iModel].primalColumnSolution();
    2528                                           double * columnLower = models[iModel].columnLower();
    2529                                           double * columnUpper = models[iModel].columnUpper();
    2530                                           highestPrimal=-COIN_DBL_MAX;
    2531                                           lowestPrimal=COIN_DBL_MAX;
    2532                                           highestDual=-COIN_DBL_MAX;
    2533                                           lowestDual=COIN_DBL_MAX;
    2534                                           largestAway=0.0;;
    2535                                           numberAtLower=0;
    2536                                           numberAtUpper=0;
    2537                                           numberBetween=0;
    2538                                           for (int iColumn=0;iColumn<numberColumns;iColumn++) {
    2539                                             double primal=primalColumnSolution[iColumn];
    2540                                             double lower=columnLower[iColumn];
    2541                                             double upper=columnUpper[iColumn];
    2542                                             double dual=dualColumnSolution[iColumn];
    2543                                             highestPrimal=CoinMax(highestPrimal,primal);
    2544                                             lowestPrimal=CoinMin(lowestPrimal,primal);
    2545                                             highestDual=CoinMax(highestDual,dual);
    2546                                             lowestDual=CoinMin(lowestDual,dual);
    2547                                             if (primal<lower+1.0e-6) {
    2548                                               numberAtLower++;
    2549                                             } else if (primal>upper-1.0e-6) {
    2550                                               numberAtUpper++;
    2551                                             } else {
    2552                                               numberBetween++;
    2553                                               largestAway=CoinMax(largestAway,
    2554                                                                   CoinMin(primal-lower,upper-primal));
    2555                                             }
    2556                                           }
    2557                                           printf("For columns %d at lower, %d between, %d at upper - lowest %g, highest %g most away %g - highest dual %g lowest %g\n",
    2558                                                  numberAtLower,numberBetween,numberAtUpper,
    2559                                                  lowestPrimal,highestPrimal,largestAway,
    2560                                                  lowestDual,highestDual);
    2561                                           break;
    2562                                         }
    2563                                         // make fancy later on
    2564                                         int iRow;
    2565                                         int numberRows = models[iModel].numberRows();
    2566                                         int lengthName = models[iModel].lengthNames(); // 0 if no names
    2567                                         int lengthPrint = CoinMax(lengthName, 8);
    2568                                         // in general I don't want to pass around massive
    2569                                         // amounts of data but seems simpler here
    2570                                         std::vector<std::string> rowNames =
    2571                                              *(models[iModel].rowNames());
    2572                                         std::vector<std::string> columnNames =
    2573                                              *(models[iModel].columnNames());
     2392                if (cbc_glp_prob) {
     2393                  glp_read_sol(cbc_glp_prob, fileName.c_str());
     2394                  glp_mpl_postsolve(cbc_glp_tran,
     2395                    cbc_glp_prob,
     2396                    GLP_SOL);
     2397                  // free up as much as possible
     2398                  glp_free(cbc_glp_prob);
     2399                  glp_mpl_free_wksp(cbc_glp_tran);
     2400                  cbc_glp_prob = NULL;
     2401                  cbc_glp_tran = NULL;
     2402                  //gmp_free_mem();
     2403                  /* check that no memory blocks are still allocated */
     2404                  glp_free_env();
     2405                }
     2406#endif
     2407                break;
     2408              }
     2409              // Write solution header (suggested by Luigi Poderico)
     2410              double objValue = models[iModel].getObjValue() * models[iModel].getObjSense();
     2411              int iStat = models[iModel].status();
     2412              if (iStat == 0) {
     2413                fprintf(fp, "optimal\n");
     2414              } else if (iStat == 1) {
     2415                // infeasible
     2416                fprintf(fp, "infeasible\n");
     2417              } else if (iStat == 2) {
     2418                // unbounded
     2419                fprintf(fp, "unbounded\n");
     2420              } else if (iStat == 3) {
     2421                fprintf(fp, "stopped on iterations or time\n");
     2422              } else if (iStat == 4) {
     2423                fprintf(fp, "stopped on difficulties\n");
     2424              } else if (iStat == 5) {
     2425                fprintf(fp, "stopped on ctrl-c\n");
     2426              } else {
     2427                fprintf(fp, "status unknown\n");
     2428              }
     2429              char printFormat[50];
     2430              sprintf(printFormat, "Objective value %s\n",
     2431                CLP_QUOTE(CLP_OUTPUT_FORMAT));
     2432              fprintf(fp, printFormat, objValue);
     2433              if (printMode == 9) {
     2434                // just statistics
     2435                int numberRows = models[iModel].numberRows();
     2436                double *dualRowSolution = models[iModel].dualRowSolution();
     2437                double *primalRowSolution = models[iModel].primalRowSolution();
     2438                double *rowLower = models[iModel].rowLower();
     2439                double *rowUpper = models[iModel].rowUpper();
     2440                double highestPrimal;
     2441                double lowestPrimal;
     2442                double highestDual;
     2443                double lowestDual;
     2444                double largestAway;
     2445                int numberAtLower;
     2446                int numberAtUpper;
     2447                int numberBetween;
     2448                highestPrimal = -COIN_DBL_MAX;
     2449                lowestPrimal = COIN_DBL_MAX;
     2450                highestDual = -COIN_DBL_MAX;
     2451                lowestDual = COIN_DBL_MAX;
     2452                largestAway = 0.0;
     2453                ;
     2454                numberAtLower = 0;
     2455                numberAtUpper = 0;
     2456                numberBetween = 0;
     2457                for (int iRow = 0; iRow < numberRows; iRow++) {
     2458                  double primal = primalRowSolution[iRow];
     2459                  double lower = rowLower[iRow];
     2460                  double upper = rowUpper[iRow];
     2461                  double dual = dualRowSolution[iRow];
     2462                  highestPrimal = CoinMax(highestPrimal, primal);
     2463                  lowestPrimal = CoinMin(lowestPrimal, primal);
     2464                  highestDual = CoinMax(highestDual, dual);
     2465                  lowestDual = CoinMin(lowestDual, dual);
     2466                  if (primal < lower + 1.0e-6) {
     2467                    numberAtLower++;
     2468                  } else if (primal > upper - 1.0e-6) {
     2469                    numberAtUpper++;
     2470                  } else {
     2471                    numberBetween++;
     2472                    largestAway = CoinMax(largestAway,
     2473                      CoinMin(primal - lower, upper - primal));
     2474                &nb