Changeset 1753 for stable/1.14/Clp/src


Ignore:
Timestamp:
Jun 19, 2011 12:27:26 PM (9 years ago)
Author:
stefan
Message:

sync with trunk rev1751

Location:
stable/1.14
Files:
62 edited
4 copied

Legend:

Unmodified
Added
Removed
  • stable/1.14

    • Property svn:externals
      •  

        old new  
        1 BuildTools  https://projects.coin-or.org/svn/BuildTools/stable/0.7
        2 ThirdParty/Blas  https://projects.coin-or.org/svn/BuildTools/ThirdParty/Blas/stable/1.2
        3 ThirdParty/Lapack  https://projects.coin-or.org/svn/BuildTools/ThirdParty/Lapack/stable/1.3
        4 Data/Sample  https://projects.coin-or.org/svn/Data/Sample/stable/1.2
        5 CoinUtils  https://projects.coin-or.org/svn/CoinUtils/stable/2.8/CoinUtils
        6 Osi  https://projects.coin-or.org/svn/Osi/stable/0.105/Osi
         1BuildTools        https://projects.coin-or.org/svn/BuildTools/stable/0.7
         2ThirdParty/Blas   https://projects.coin-or.org/svn/BuildTools/ThirdParty/Blas/stable/1.2
         3ThirdParty/Lapack https://projects.coin-or.org/svn/BuildTools/ThirdParty/Lapack/stable/1.3
         4ThirdParty/Metis  https://projects.coin-or.org/svn/BuildTools/ThirdParty/Metis/stable/1.2
         5ThirdParty/Mumps  https://projects.coin-or.org/svn/BuildTools/ThirdParty/Mumps/stable/1.4
         6ThirdParty/Glpk   https://projects.coin-or.org/svn/BuildTools/ThirdParty/Glpk/stable/1.8
         7Data/Netlib       https://projects.coin-or.org/svn/Data/Netlib/stable/1.2
         8Data/Sample       https://projects.coin-or.org/svn/Data/Sample/stable/1.2
         9CoinUtils         https://projects.coin-or.org/svn/CoinUtils/stable/2.8/CoinUtils
         10Osi               https://projects.coin-or.org/svn/Osi/stable/0.105/Osi
    • Property svn:mergeinfo changed
      /trunk (added)merged: 1670-1671,​1675-1685,​1687-1711,​1716-1727,​1729-1735,​1737-1748,​1750-1752
  • stable/1.14/Clp/src/CbcOrClpParam.cpp

    r1665 r1753  
    44// This code is licensed under the terms of the Eclipse Public License (EPL).
    55
    6 #if defined(_MSC_VER)
    7 // Turn off compiler warning about long names
    8 #  pragma warning(disable:4786)
    9 #endif
    10 
     6#include "CoinPragma.hpp"
    117#include "CbcOrClpParam.hpp"
    128
     
    4238#endif
    4339#endif
    44 #if WSSMP_BARRIER>=2
     40#if defined(COIN_HAS_WSMP) && ! defined(USE_EKKWSSMP)
    4541#ifndef CBC_THREAD
    4642#define CBC_THREAD
     
    494490               model->setPrimalTolerance(value);
    495491               break;
     492          case CLP_PARAM_DBL_ZEROTOLERANCE:
     493               model->setSmallElementValue(value);
     494               break;
    496495          case CLP_PARAM_DBL_DUALBOUND:
    497496               model->setDualBound(value);
     
    533532          break;
    534533#endif
     534     case CLP_PARAM_DBL_ZEROTOLERANCE:
     535          value = model->getSmallElementValue();
     536          break;
    535537     case CLP_PARAM_DBL_DUALBOUND:
    536538          value = model->dualBound();
     
    10141016extern int CbcOrClpRead_mode;
    10151017int CbcOrClpEnvironmentIndex = -1;
    1016 static int fillEnv()
     1018static size_t fillEnv()
    10171019{
    10181020#if defined(_MSC_VER) || defined(__MSVCRT__)
     
    10211023     // Don't think it will work on Windows
    10221024     char * environ = getenv("CBC_CLP_ENVIRONMENT");
    1023      int length = 0;
     1025     size_t length = 0;
    10241026     if (environ) {
    10251027          length = strlen(environ);
    1026           if (CbcOrClpEnvironmentIndex < length) {
     1028          if (CbcOrClpEnvironmentIndex < static_cast<int>(length)) {
    10271029               // find next non blank
    10281030               char * whereEnv = environ + CbcOrClpEnvironmentIndex;
     
    10411043                    whereEnv++;
    10421044               }
    1043                CbcOrClpEnvironmentIndex = whereEnv - environ;
     1045               CbcOrClpEnvironmentIndex = static_cast<int>(whereEnv - environ);
    10441046               *put = '\0';
    10451047               length = strlen(line);
     
    12301232          afterEquals = "";
    12311233     }
    1232      int value = 0;
     1234     long int value = 0;
    12331235     //std::cout<<field<<std::endl;
    12341236     if (field != "EOL") {
     
    12461248          *valid = 2;
    12471249     }
    1248      return value;
     1250     return static_cast<int>(value);
    12491251}
    12501252double
     
    14301432     parameters[numberParameters-1].append("dense");
    14311433     //#ifdef FOREIGN_BARRIER
    1432 #ifdef WSSMP_BARRIER
     1434#ifdef COIN_HAS_WSMP
    14331435     parameters[numberParameters-1].append("fudge!Long");
    14341436     parameters[numberParameters-1].append("wssmp");
     
    14371439     parameters[numberParameters-1].append("wssmp_dummy");
    14381440#endif
    1439 #ifdef UFL_BARRIER
     1441#if defined(COIN_HAS_AMD) || defined(COIN_HAS_CHOLMOD) || defined(COIN_HAS_GLPK)
    14401442     parameters[numberParameters-1].append("Uni!versityOfFlorida");
    14411443#else
     
    14471449     parameters[numberParameters-1].append("Taucs_dummy");
    14481450#endif
    1449 #ifdef MUMPS_BARRIER
     1451#ifdef COIN_HAS_MUMPS
    14501452     parameters[numberParameters-1].append("Mumps");
    14511453#else
     
    15481550     parameters[numberParameters-1].append("on");
    15491551     parameters[numberParameters-1].append("so!low_halim");
    1550      parameters[numberParameters-1].append("ha!lim_solow(JJF mods)");
     1552     parameters[numberParameters-1].append("lots");
    15511553     //  parameters[numberParameters-1].append("4");
    15521554     //  parameters[numberParameters-1].append("5");
     
    18341836     parameters[numberParameters++] =
    18351837          CbcOrClpParam("dualize", "Solves dual reformulation",
    1836                         0, 3, CLP_PARAM_INT_DUALIZE, 1);
     1838                        0, 4, CLP_PARAM_INT_DUALIZE, 1);
    18371839     parameters[numberParameters-1].setLonghelp
    18381840     (
     
    20492051     parameters[numberParameters-1].append("deltastrong");
    20502052#endif
     2053     parameters[numberParameters++] =
     2054          CbcOrClpParam("gsolu!tion", "Puts glpk solution to file",
     2055                        CLP_PARAM_ACTION_GMPL_SOLUTION);
     2056     parameters[numberParameters-1].setLonghelp
     2057     (
     2058          "Will write a glpk solution file to the given file name.  It will use the default\
     2059 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
     2060 is initialized to 'stdout' (this defaults to ordinary solution if stdout). \
     2061If problem created from gmpl model - will do any reports."
     2062     );
    20512063#ifdef COIN_HAS_CBC
    20522064     parameters[numberParameters++] =
     
    22072219          "This switches on knapsack cuts (either at root or in entire tree) \
    22082220See branchAndCut for information on options."
     2221     );
     2222     parameters[numberParameters++] =
     2223          CbcOrClpParam("lagomory!Cuts", "Whether to use Lagrangean Gomory cuts",
     2224                        "off", CBC_PARAM_STR_LAGOMORYCUTS);
     2225     parameters[numberParameters-1].append("endonlyroot");
     2226     parameters[numberParameters-1].append("endcleanroot");
     2227     parameters[numberParameters-1].append("endbothroot");
     2228     parameters[numberParameters-1].append("endonly");
     2229     parameters[numberParameters-1].append("endclean");
     2230     parameters[numberParameters-1].append("endboth");
     2231     parameters[numberParameters-1].append("onlyaswell");
     2232     parameters[numberParameters-1].append("cleanaswell");
     2233     parameters[numberParameters-1].append("bothaswell");
     2234     parameters[numberParameters-1].append("onlyinstead");
     2235     parameters[numberParameters-1].append("cleaninstead");
     2236     parameters[numberParameters-1].append("bothinstead");
     2237     parameters[numberParameters-1].setLonghelp
     2238     (
     2239          "This is a gross simplification of 'A Relax-and-Cut Framework for Gomory's Mixed-Integer Cuts' \
     2240by Matteo Fischetti & Domenico Salvagnin.  This simplification \
     2241just uses original constraints while modifying objective using other cuts. \
     2242So you don't use messy constraints generated by Gomory etc. \
     2243A variant is to allow non messy cuts e.g. clique cuts. \
     2244So 'only' does this while clean also allows integral valued cuts.  \
     2245'End' is recommended which waits until other cuts have finished and then \
     2246does a few passes. \
     2247The length options for gomory cuts are used."
    22092248     );
    22102249     parameters[numberParameters++] =
     
    31913230                        CLP_PARAM_ACTION_TIGHTEN, 7, 0);
    31923231#endif
     3232     parameters[numberParameters++] =
     3233          CbcOrClpParam("timeM!ode", "Whether to use CPU or elapsed time",
     3234                        "cpu", CLP_PARAM_STR_TIME_MODE);
     3235     parameters[numberParameters-1].append("elapsed");
     3236     parameters[numberParameters-1].setLonghelp
     3237     (
     3238          "cpu uses CPU time for stopping, while elapsed uses elapsed time. \
     3239(On Windows, elapsed time is always used)."
     3240     );
    31933241#ifdef COIN_HAS_CBC
    31943242     parameters[numberParameters++] =
    31953243          CbcOrClpParam("trust!PseudoCosts", "Number of branches before we trust pseudocosts",
    3196                         -3, 2000000, CBC_PARAM_INT_NUMBERBEFORE);
     3244                        -3, 2000000000, CBC_PARAM_INT_NUMBERBEFORE);
    31973245     parameters[numberParameters-1].setLonghelp
    31983246     (
     
    33093357#endif
    33103358#endif
     3359     parameters[numberParameters++] =
     3360          CbcOrClpParam("zeroT!olerance", "Kill all coefficients \
     3361whose absolute value is less than this value",
     3362                        1.0e-100, 1.0e-5, CLP_PARAM_DBL_ZEROTOLERANCE);
     3363     parameters[numberParameters-1].setLonghelp
     3364     (
     3365          "This applies to reading mps files (and also lp files \
     3366if KILL_ZERO_READLP defined)"
     3367     );
     3368     parameters[numberParameters-1].setDoubleValue(1.0e-20);
    33113369     assert(numberParameters < CBCMAXPARAMETERS);
    33123370}
     
    33703428               if (numberRows == numberRowsFile && numberColumns == numberColumnsFile) {
    33713429                    nRead = fread(primalRowSolution, sizeof(double), numberRows, fp);
    3372                     if (nRead != numberRows)
     3430                    if (nRead != static_cast<size_t>(numberRows))
    33733431                         throw("Error in fread");
    33743432                    nRead = fread(dualRowSolution, sizeof(double), numberRows, fp);
    3375                     if (nRead != numberRows)
     3433                    if (nRead != static_cast<size_t>(numberRows))
    33763434                         throw("Error in fread");
    33773435                    nRead = fread(primalColumnSolution, sizeof(double), numberColumns, fp);
    3378                     if (nRead != numberColumns)
     3436                    if (nRead != static_cast<size_t>(numberColumns))
    33793437                         throw("Error in fread");
    33803438                    nRead = fread(dualColumnSolution, sizeof(double), numberColumns, fp);
    3381                     if (nRead != numberColumns)
     3439                    if (nRead != static_cast<size_t>(numberColumns))
    33823440                         throw("Error in fread");
    33833441               } else {
     
    33853443                    double * temp = new double [CoinMax(numberRowsFile, numberColumnsFile)];
    33863444                    nRead = fread(temp, sizeof(double), numberRowsFile, fp);
    3387                     if (nRead != numberRowsFile)
     3445                    if (nRead != static_cast<size_t>(numberRowsFile))
    33883446                         throw("Error in fread");
    33893447                    CoinMemcpyN(temp, numberRows, primalRowSolution);
    33903448                    nRead = fread(temp, sizeof(double), numberRowsFile, fp);
    3391                     if (nRead != numberRowsFile)
     3449                    if (nRead != static_cast<size_t>(numberRowsFile))
    33923450                         throw("Error in fread");
    33933451                    CoinMemcpyN(temp, numberRows, dualRowSolution);
    33943452                    nRead = fread(temp, sizeof(double), numberColumnsFile, fp);
    3395                     if (nRead != numberColumnsFile)
     3453                    if (nRead != static_cast<size_t>(numberColumnsFile))
    33963454                         throw("Error in fread");
    33973455                    CoinMemcpyN(temp, numberColumns, primalColumnSolution);
    33983456                    nRead = fread(temp, sizeof(double), numberColumnsFile, fp);
    3399                     if (nRead != numberColumnsFile)
     3457                    if (nRead != static_cast<size_t>(numberColumnsFile))
    34003458                         throw("Error in fread");
    34013459                    CoinMemcpyN(temp, numberColumns, dualColumnSolution);
     
    34723530          double * primalRowSolution = lpSolver->primalRowSolution();
    34733531          nWrite = fwrite(primalRowSolution, sizeof(double), numberRows, fp);
    3474           if (nWrite != numberRows)
     3532          if (nWrite != static_cast<size_t>(numberRows))
    34753533               throw("Error in fwrite");
    34763534          nWrite = fwrite(dualRowSolution, sizeof(double), numberRows, fp);
    3477           if (nWrite != numberRows)
     3535          if (nWrite != static_cast<size_t>(numberRows))
    34783536               throw("Error in fwrite");
    34793537          double * dualColumnSolution = lpSolver->dualColumnSolution();
    34803538          double * primalColumnSolution = lpSolver->primalColumnSolution();
    34813539          nWrite = fwrite(primalColumnSolution, sizeof(double), numberColumns, fp);
    3482           if (nWrite != numberColumns)
     3540          if (nWrite != static_cast<size_t>(numberColumns))
    34833541               throw("Error in fwrite");
    34843542          nWrite = fwrite(dualColumnSolution, sizeof(double), numberColumns, fp);
    3485           if (nWrite != numberColumns)
     3543          if (nWrite != static_cast<size_t>(numberColumns))
    34863544               throw("Error in fwrite");
    34873545          fclose(fp);
  • stable/1.14/Clp/src/CbcOrClpParam.hpp

    r1665 r1753  
    5858     CLP_PARAM_DBL_OBJSCALE,
    5959     CLP_PARAM_DBL_RHSSCALE,
     60     CLP_PARAM_DBL_ZEROTOLERANCE,
    6061
    6162     CBC_PARAM_DBL_INFEASIBILITYWEIGHT = 51,
     
    157158     CLP_PARAM_STR_FACTORIZATION,
    158159     CLP_PARAM_STR_ALLCOMMANDS,
     160     CLP_PARAM_STR_TIME_MODE,
    159161
    160162     CBC_PARAM_STR_NODESTRATEGY = 251,
     
    199201     CBC_PARAM_STR_PIVOTANDCOMPLEMENT,
    200202     CBC_PARAM_STR_VND,
     203     CBC_PARAM_STR_LAGOMORYCUTS,
    201204
    202205     CLP_PARAM_ACTION_DIRECTORY = 301,
     
    248251     CLP_PARAM_ACTION_ENVIRONMENT,
    249252     CLP_PARAM_ACTION_PARAMETRICS,
     253     CLP_PARAM_ACTION_GMPL_SOLUTION,
    250254
    251255     CBC_PARAM_ACTION_BAB = 351,
  • stable/1.14/Clp/src/ClpCholeskyBase.cpp

    r1665 r1753  
    274274          for (iRow = 0; iRow < numberTotal; iRow++) {
    275275               if (rowsDropped_[iRow] && CoinAbs(array[iRow]) > 1.0e-8) {
    276                     printf("row region1 %d dropped %g\n", iRow, array[iRow]);
     276                 COIN_DETAIL_PRINT(printf("row region1 %d dropped %g\n", iRow, array[iRow]));
    277277               }
    278278          }
    279279          for (; iRow < numberRows_; iRow++) {
    280280               if (rowsDropped_[iRow] && CoinAbs(array[iRow]) > 1.0e-8) {
    281                     printf("row region2 %d dropped %g\n", iRow, array[iRow]);
     281                 COIN_DETAIL_PRINT(printf("row region2 %d dropped %g\n", iRow, array[iRow]));
    282282               }
    283283          }
     
    337337               for (iRow = numberRows_; iRow >= stop; iRow--) {
    338338                    if (used[iRow])
    339                          printf("%d columns are of length %d\n", used[iRow], iRow);
     339                      COIN_DETAIL_PRINT(printf("%d columns are of length %d\n", used[iRow], iRow));
    340340                    nLong += used[iRow];
    341341                    if (nLong > 50 || nLong > (numberColumns >> 2))
     
    363363                    dense_ = new ClpCholeskyDense();
    364364                    dense_->reserveSpace(NULL, numberDense);
    365                     printf("Taking %d columns as dense\n", numberDense);
     365                    COIN_DETAIL_PRINT(printf("Taking %d columns as dense\n", numberDense));
    366366               }
    367367          }
     
    703703               for (iRow = numberRows_; iRow >= stop; iRow--) {
    704704                    if (used[iRow])
    705                          printf("%d columns are of length %d\n", used[iRow], iRow);
     705                      COIN_DETAIL_PRINT(printf("%d columns are of length %d\n", used[iRow], iRow));
    706706                    nLong += used[iRow];
    707707                    if (nLong > 50 || nLong > (numberColumns >> 2))
     
    729729                    dense_ = new ClpCholeskyDense();
    730730                    dense_->reserveSpace(NULL, numberDense);
    731                     printf("Taking %d columns as dense\n", numberDense);
     731                    COIN_DETAIL_PRINT(printf("Taking %d columns as dense\n", numberDense));
    732732               }
    733733          }
     
    10511051               permuteInverse_[iRow] = done++;
    10521052     }
    1053      printf("%d compressions, %d expansions\n",
    1054             numberCompressions, numberExpansions);
     1053     COIN_DETAIL_PRINT(printf("%d compressions, %d expansions\n",
     1054                              numberCompressions, numberExpansions));
    10551055     assert (done == numberRows_);
    10561056     delete [] sort;
     
    26032603     // don't do if dense columns
    26042604     if (nDense >= DENSE_THRESHOLD && !dense_) {
    2605           printf("Going dense for last %d rows\n", nDense);
     2605       COIN_DETAIL_PRINT(printf("Going dense for last %d rows\n", nDense));
    26062606          // make sure we don't disturb any indices
    26072607          CoinBigIndex k = 0;
     
    32763276     CoinWorkDouble largest = doubleParameters_[3];
    32773277     CoinWorkDouble smallest = doubleParameters_[4];
    3278      int numberDropped = integerParameters_[20];
    32793278     // probably done before
    32803279     largest = 0.0;
    32813280     smallest = COIN_DBL_MAX;
    3282      numberDropped = 0;
    32833281     double dropValue = doubleParameters_[10];
    32843282     int firstPositive = integerParameters_[34];
     
    33023300     bool endClique = false;
    33033301     int lastRow = 0;
    3304      int cliqueSize = 0;
    33053302     CoinBigIndex cliquePointer = 0;
    33063303     int nextRow2 = -1;
     
    34003397               lastRow = iRow;
    34013398               cliquePointer = choleskyStart_[iRow];
    3402                cliqueSize = choleskyStart_[iRow+1] - cliquePointer + 1;
    34033399          }
    34043400          // for each column L[*,kRow] that affects L[*,iRow]
  • stable/1.14/Clp/src/ClpCholeskyBase.hpp

    r1665 r1753  
    88
    99#include "CoinPragma.hpp"
    10 #include "CoinFinite.hpp"
     10#include "CoinTypes.hpp"
    1111//#define CLP_LONG_CHOLESKY 0
    1212#ifndef CLP_LONG_CHOLESKY
  • stable/1.14/Clp/src/ClpCholeskyDense.cpp

    r1665 r1753  
    386386          smallest = doubleParameters_[4];
    387387          if (model_->messageHandler()->logLevel() > 1)
    388                std::cout << "Cholesky - largest " << largest << " smallest " << smallest << std::endl;
     388            COIN_DETAIL_PRINT(std::cout << "Cholesky - largest " << largest << " smallest " << smallest << std::endl);
    389389          choleskyCondition_ = largest / smallest;
    390390          /* Should save adjustments in ..R_*/
     
    806806     double dropValue = thisStruct->doubleParameters_[0];
    807807     int firstPositive = thisStruct->integerParameters_[0];
    808      int rowOffset = diagonal - thisStruct->diagonal_;
     808     int rowOffset = static_cast<int>(diagonal - thisStruct->diagonal_);
    809809     int i, j, k;
    810810     CoinWorkDouble t00, temp1;
  • stable/1.14/Clp/src/ClpCholeskyMumps.cpp

    r1665 r1753  
    11/* $Id$ */
    2 #ifdef MUMPS_BARRIER
    32// Copyright (C) 2004, International Business Machines
    43// Corporation and others.  All Rights Reserved.
     
    76
    87#include "CoinPragma.hpp"
    9 #include "ClpCholeskyMumps.hpp"
    10 extern "C"
    11 {
    12      //#include "mpi.h"
    13 #include "/home/jjforre/cbc-trunk/ThirdParty/Mumps/MUMPS/libseq/mpi.h"
    14 }
     8
     9#include "ClpConfig.h"
     10
     11#define MPI_COMM_WORLD CLP_MPI_COMM_WORLD
    1512#define JOB_INIT -1
    1613#define JOB_END -2
    1714#define USE_COMM_WORLD -987654
     15extern "C" {
     16#include "dmumps_c.h"
     17#include "mpi.h"
     18}
     19
     20#include "ClpCholeskyMumps.hpp"
    1821#include "ClpMessage.hpp"
    1922#include "ClpInterior.hpp"
     
    3033     : ClpCholeskyBase(denseThreshold)
    3134{
     35     mumps_ = (DMUMPS_STRUC_C*)malloc(sizeof(DMUMPS_STRUC_C));
    3236     type_ = 16;
    33      mumps_.n = 0;
    34      mumps_.nz = 0;
    35      mumps_.a = NULL;
    36      mumps_.jcn = NULL;
    37      mumps_.irn = NULL;
    38      mumps_.job = JOB_INIT;//initialize mumps
    39      mumps_.par = 1;//working host for sequential version
    40      mumps_.sym = 2;//general symmetric matrix
    41      mumps_.comm_fortran = USE_COMM_WORLD;
     37     mumps_->n = 0;
     38     mumps_->nz = 0;
     39     mumps_->a = NULL;
     40     mumps_->jcn = NULL;
     41     mumps_->irn = NULL;
     42     mumps_->job = JOB_INIT;//initialize mumps
     43     mumps_->par = 1;//working host for sequential version
     44     mumps_->sym = 2;//general symmetric matrix
     45     mumps_->comm_fortran = USE_COMM_WORLD;
    4246     int myid, ierr;
    4347     int justName;
     
    4549     ierr = MPI_Comm_rank(MPI_COMM_WORLD, &myid);
    4650     assert (!ierr);
    47      dmumps_c(&mumps_);
     51     dmumps_c(mumps_);
    4852#define ICNTL(I) icntl[(I)-1] /* macro s.t. indices match documentation */
    4953#define CNTL(I) cntl[(I)-1] /* macro s.t. indices match documentation */
    50      mumps_.ICNTL(5) = 1; // say compressed format
    51      mumps_.ICNTL(4) = 2; // log messages
    52      mumps_.ICNTL(24) = 1; // Deal with zeros on diagonal
    53      mumps_.CNTL(3) = 1.0e-20; // drop if diagonal less than this
     54     mumps_->ICNTL(5) = 1; // say compressed format
     55     mumps_->ICNTL(4) = 2; // log messages
     56     mumps_->ICNTL(24) = 1; // Deal with zeros on diagonal
     57     mumps_->CNTL(3) = 1.0e-20; // drop if diagonal less than this
    5458     // output off
    55      mumps_.ICNTL(1) = -1;
    56      mumps_.ICNTL(2) = -1;
    57      mumps_.ICNTL(3) = -1;
    58      mumps_.ICNTL(4) = 0;
     59     mumps_->ICNTL(1) = -1;
     60     mumps_->ICNTL(2) = -1;
     61     mumps_->ICNTL(3) = -1;
     62     mumps_->ICNTL(4) = 0;
    5963}
    6064
     
    7478ClpCholeskyMumps::~ClpCholeskyMumps ()
    7579{
    76      mumps_.job = JOB_END;
    77      dmumps_c(&mumps_); /* Terminate instance */
     80     mumps_->job = JOB_END;
     81     dmumps_c(mumps_); /* Terminate instance */
    7882     MPI_Finalize();
     83     free(mumps_);
    7984}
    8085
     
    155160     delete [] which;
    156161     // NOT COMPRESSED FOR NOW ??? - Space for starts
    157      mumps_.ICNTL(5) = 0; // say NOT compressed format
     162     mumps_->ICNTL(5) = 0; // say NOT compressed format
    158163     try {
    159164          choleskyStart_ = new CoinBigIndex[numberRows_+1+sizeFactor_];
     
    231236          choleskyStart_[iRow]++;
    232237     }
    233      mumps_.nz = sizeFactor_;
    234      mumps_.irn = choleskyStart_ + numberRows_ + 1;
    235      mumps_.jcn = choleskyRow_;
    236      mumps_.a = NULL;
     238     mumps_->nz = sizeFactor_;
     239     mumps_->irn = choleskyStart_ + numberRows_ + 1;
     240     mumps_->jcn = choleskyRow_;
     241     mumps_->a = NULL;
    237242     for (CoinBigIndex i = 0; i < sizeFactor_; i++) {
    238243          choleskyRow_[i]++;
    239244#ifndef NDEBUG
    240           assert (mumps_.irn[i] >= 1 && mumps_.irn[i] <= numberRows_);
    241           assert (mumps_.jcn[i] >= 1 && mumps_.jcn[i] <= numberRows_);
     245          assert (mumps_->irn[i] >= 1 && mumps_->irn[i] <= numberRows_);
     246          assert (mumps_->jcn[i] >= 1 && mumps_->jcn[i] <= numberRows_);
    242247#endif
    243248     }
    244249     // validate
    245250     //mumps code here
    246      mumps_.n = numberRows_;
    247      mumps_.nelt = numberRows_;
    248      mumps_.eltptr = choleskyStart_;
    249      mumps_.eltvar = choleskyRow_;
    250      mumps_.a_elt = NULL;
    251      mumps_.rhs = NULL;
    252      mumps_.job = 1; // order
    253      dmumps_c(&mumps_);
    254      mumps_.a = sparseFactor_;
    255      if (mumps_.infog[0]) {
    256           printf("MUMPS ordering failed -error %d %d\n",
    257                  mumps_.infog[0], mumps_.infog[1]);
     251     mumps_->n = numberRows_;
     252     mumps_->nelt = numberRows_;
     253     mumps_->eltptr = choleskyStart_;
     254     mumps_->eltvar = choleskyRow_;
     255     mumps_->a_elt = NULL;
     256     mumps_->rhs = NULL;
     257     mumps_->job = 1; // order
     258     dmumps_c(mumps_);
     259     mumps_->a = sparseFactor_;
     260     if (mumps_->infog[0]) {
     261          COIN_DETAIL_PRINT(printf("MUMPS ordering failed -error %d %d\n",
     262                                   mumps_->infog[0], mumps_->infog[1]));
    258263          return 1;
    259264     } else {
    260           double size = mumps_.infog[19];
     265          double size = mumps_->infog[19];
    261266          if (size < 0)
    262267               size *= -1000000;
    263           printf("%g nonzeros, flop count %g\n", size, mumps_.rinfog[0]);
     268          COIN_DETAIL_PRINT(printf("%g nonzeros, flop count %g\n", size, mumps_->rinfog[0]));
    264269     }
    265270     for (iRow = 0; iRow < numberRows_; iRow++) {
     
    375380     delete [] work;
    376381     // code here
    377      mumps_.a_elt = sparseFactor_;
    378      mumps_.rhs = NULL;
    379      mumps_.job = 2; // factorize
    380      dmumps_c(&mumps_);
    381      if (mumps_.infog[0]) {
    382           printf("MUMPS factorization failed -error %d %d\n",
    383                  mumps_.infog[0], mumps_.infog[1]);
     382     mumps_->a_elt = sparseFactor_;
     383     mumps_->rhs = NULL;
     384     mumps_->job = 2; // factorize
     385     dmumps_c(mumps_);
     386     if (mumps_->infog[0]) {
     387          COIN_DETAIL_PRINT(printf("MUMPS factorization failed -error %d %d\n",
     388                                   mumps_->infog[0], mumps_->infog[1]));
    384389     }
    385390     choleskyCondition_ = 1.0;
     
    400405               newDropped = 0;
    401406               for (int i = 0; i < numberRows_; i++) {
    402                     char dropped = rowsDropped[i];
    403                     rowsDropped_[i] = dropped;
     407                    int dropped = rowsDropped[i];
     408                    rowsDropped_[i] = (char)dropped;
    404409                    if (dropped == 2) {
    405410                         //dropped this time
     
    415420               newDropped = 0;
    416421               for (int i = 0; i < numberRows_; i++) {
    417                     char dropped = rowsDropped[i];
    418                     rowsDropped_[i] = dropped;
     422                    int dropped = rowsDropped[i];
     423                    rowsDropped_[i] = (char)dropped;
    419424                    if (dropped == 2) {
    420425                         //dropped this time
     
    441446ClpCholeskyMumps::solve (double * region)
    442447{
    443      mumps_.rhs = region;
    444      mumps_.job = 3; // solve
    445      dmumps_c(&mumps_);
    446 }
    447 #endif
     448     mumps_->rhs = region;
     449     mumps_->job = 3; // solve
     450     dmumps_c(mumps_);
     451}
  • stable/1.14/Clp/src/ClpCholeskyMumps.hpp

    r1665 r1753  
    77#define ClpCholeskyMumps_H
    88#include "ClpCholeskyBase.hpp"
    9 #ifdef __cplusplus
    10 extern "C" {
    11 #endif
    12 #include "amd.h"
    13 #include "dmumps_c.h"
    14      //#include "mpi.h"
    15      //#include "/home/jjforre/cbc-trunk/ThirdParty/Mumps/MUMPS/libseq/mpi.h"
    16 #ifdef __cplusplus
    17 }
    18 #endif
    199class ClpMatrixBase;
    2010class ClpCholeskyDense;
     11
     12// unfortunately, DMUMPS_STRUC_C is an anonymous struct in MUMPS, so we define it to void for everyone outside ClpCholeskyMumps
     13// if this file is included by ClpCholeskyMumps.cpp, then after dmumps_c.h has been included, which defines MUMPS_VERSION
     14#ifndef MUMPS_VERSION
     15typedef void DMUMPS_STRUC_C;
     16#endif
    2117
    2218/** Mumps class for Clp Cholesky factorization
     
    5147     /** Destructor  */
    5248     virtual ~ClpCholeskyMumps();
    53      // Copy
    54      ClpCholeskyMumps(const ClpCholeskyMumps&);
    55      // Assignment
    56      ClpCholeskyMumps& operator=(const ClpCholeskyMumps&);
    5749     /// Clone
    5850     virtual ClpCholeskyBase * clone() const ;
    5951     //@}
    6052
    61 
    6253private:
    6354     // Mumps structure
    64      DMUMPS_STRUC_C mumps_;
     55     DMUMPS_STRUC_C* mumps_;
     56     
     57          // Copy
     58     ClpCholeskyMumps(const ClpCholeskyMumps&);
     59     // Assignment
     60     ClpCholeskyMumps& operator=(const ClpCholeskyMumps&);
    6561};
    6662
  • stable/1.14/Clp/src/ClpCholeskyUfl.cpp

    r1665 r1753  
    11/* $Id$ */
    2 #ifdef UFL_BARRIER
    32// Copyright (C) 2004, International Business Machines
    43// Corporation and others.  All Rights Reserved.
    54// This code is licensed under the terms of the Eclipse Public License (EPL).
    65
     6#include "ClpConfig.h"
     7
     8extern "C" {
     9#ifndef COIN_HAS_CHOLMOD
     10#ifndef COIN_HAS_AMD
     11#error "Need to have AMD or CHOLMOD to compile ClpCholeskyUfl."
     12#else
     13#include "amd.h"
     14#endif
     15#else
     16#include "cholmod.h"
     17#endif
     18}
    719
    820#include "CoinPragma.hpp"
     
    2335{
    2436     type_ = 14;
    25 #ifdef CLP_USE_CHOLMOD
    2637     L_ = NULL;
    27      cholmod_start (&c_) ;
     38     c_ = NULL;
     39     
     40#ifdef COIN_HAS_CHOLMOD
     41     c_ = (cholmod_common*) malloc(sizeof(cholmod_common));
     42     cholmod_start (c_) ;
    2843     // Can't use supernodal as may not be positive definite
    29      c_.supernodal = 0;
     44     c_->supernodal = 0;
    3045#endif
    3146}
     
    4661ClpCholeskyUfl::~ClpCholeskyUfl ()
    4762{
    48 #ifdef CLP_USE_CHOLMOD
    49      cholmod_free_factor (&L_, &c_) ;
    50      cholmod_finish (&c_) ;
     63#ifdef COIN_HAS_CHOLMOD
     64     cholmod_free_factor (&L_, c_) ;
     65     cholmod_finish (c_) ;
     66     free(c_);
    5167#endif
    5268}
     
    6480     return *this;
    6581}
     82
    6683//-------------------------------------------------------------------
    6784// Clone
     
    7188     return new ClpCholeskyUfl(*this);
    7289}
    73 #ifndef CLP_USE_CHOLMOD
     90
     91#ifndef COIN_HAS_CHOLMOD
    7492/* Orders rows and saves pointer to matrix.and model */
    7593int
     
    236254     A.sorted = 1;
    237255     A.packed = 1;
    238      c_.nmethods = 9;
    239      c_.postorder = true;
    240      //c_.dbound=1.0e-20;
    241      L_ = cholmod_analyze (&A, &c_) ;
    242      if (c_.status) {
    243           std::cout << "CHOLMOD ordering failed" << std::endl;
     256     c_->nmethods = 9;
     257     c_->postorder = true;
     258     //c_->dbound=1.0e-20;
     259     L_ = cholmod_analyze (&A, c_) ;
     260     if (c_->status) {
     261       COIN_DETAIL_PRINT(std::cout << "CHOLMOD ordering failed" << std::endl);
    244262          return 1;
    245263     } else {
    246           printf("%g nonzeros, flop count %g\n", c_.lnz, c_.fl);
     264       COIN_DETAIL_PRINT(printf("%g nonzeros, flop count %g\n", c_->lnz, c_->fl));
    247265     }
    248266     for (iRow = 0; iRow < numberRows_; iRow++) {
     
    252270     return 0;
    253271}
     272#endif
     273
    254274/* Does Symbolic factorization given permutation.
    255275   This is called immediately after order.  If user provides this then
     
    259279ClpCholeskyUfl::symbolic()
    260280{
     281#ifdef COIN_HAS_CHOLMOD
    261282     return 0;
    262 }
     283#else
     284     return ClpCholeskyBase::symbolic();
     285#endif
     286}
     287
     288#ifdef COIN_HAS_CHOLMOD
    263289/* Factorize - filling in rowsDropped and returning number dropped */
    264290int
     
    370396     A.sorted = 1;
    371397     A.packed = 1;
    372      cholmod_factorize (&A, L_, &c_) ;              /* factorize */
     398     cholmod_factorize (&A, L_, c_) ;               /* factorize */
    373399     choleskyCondition_ = 1.0;
    374400     bool cleanCholesky;
     
    388414               newDropped = 0;
    389415               for (int i = 0; i < numberRows_; i++) {
    390                     char dropped = rowsDropped[i];
    391                     rowsDropped_[i] = dropped;
     416                    int dropped = rowsDropped[i];
     417                    rowsDropped_[i] = (char)dropped;
    392418                    if (dropped == 2) {
    393419                         //dropped this time
     
    403429               newDropped = 0;
    404430               for (int i = 0; i < numberRows_; i++) {
    405                     char dropped = rowsDropped[i];
    406                     rowsDropped_[i] = dropped;
     431                    int dropped = rowsDropped[i];
     432                    rowsDropped_[i] = (char)dropped;
    407433                    if (dropped == 2) {
    408434                         //dropped this time
     
    425451     return newDropped;
    426452}
     453#else
     454/* Factorize - filling in rowsDropped and returning number dropped */
     455int
     456ClpCholeskyUfl::factorize(const double * diagonal, int * rowsDropped)
     457{
     458  return ClpCholeskyBase::factorize(diagonal, rowsDropped);
     459}
     460#endif
     461
     462#ifdef COIN_HAS_CHOLMOD
    427463/* Uses factorization to solve. */
    428464void
     
    430466{
    431467     cholmod_dense *x, *b;
    432      b = cholmod_allocate_dense (numberRows_, 1, numberRows_, CHOLMOD_REAL, &c_) ;
     468     b = cholmod_allocate_dense (numberRows_, 1, numberRows_, CHOLMOD_REAL, c_) ;
    433469     CoinMemcpyN(region, numberRows_, (double *) b->x);
    434      x = cholmod_solve (CHOLMOD_A, L_, b, &c_) ;
     470     x = cholmod_solve (CHOLMOD_A, L_, b, c_) ;
    435471     CoinMemcpyN((double *) x->x, numberRows_, region);
    436      cholmod_free_dense (&x, &c_) ;
    437      cholmod_free_dense (&b, &c_) ;
    438 }
    439 #endif
    440 #endif
     472     cholmod_free_dense (&x, c_) ;
     473     cholmod_free_dense (&b, c_) ;
     474}
     475#else
     476void
     477ClpCholeskyUfl::solve (double * region)
     478{
     479  ClpCholeskyBase::solve(region);
     480}
     481#endif
  • stable/1.14/Clp/src/ClpCholeskyUfl.hpp

    r1665 r1753  
    66#ifndef ClpCholeskyUfl_H
    77#define ClpCholeskyUfl_H
     8
    89#include "ClpCholeskyBase.hpp"
    9 #ifdef __cplusplus
    10 extern "C" {
    11 #endif
    12 #ifndef CLP_USE_CHOLMOD
    13 #include "amd.h"
    14 #else
    15 #include "cholmod.h"
    16 #endif
    17 #ifdef __cplusplus
    18 }
    19 #endif
     10
    2011class ClpMatrixBase;
    2112class ClpCholeskyDense;
     13
     14typedef struct cholmod_factor_struct cholmod_factor;
     15typedef struct cholmod_common_struct cholmod_common;
    2216
    2317/** Ufl class for Clp Cholesky factorization
     
    4438      Returns non-zero if not enough memory */
    4539     virtual int order(ClpInterior * model) ;
    46 #ifdef CLP_USE_CHOLMOD
    47      /** Does Symbolic factorization given permutation.
     40     /** Does Symbolic factorization given permutation using CHOLMOD (if available).
    4841         This is called immediately after order.  If user provides this then
    4942         user must provide factorize and solve.  Otherwise the default factorization is used
    50          returns non-zero if not enough memory */
     43         returns non-zero if not enough memory. */
    5144     virtual int symbolic();
    52      /** Factorize - filling in rowsDropped and returning number dropped.
     45     /** Factorize - filling in rowsDropped and returning number dropped using CHOLMOD (if available).
    5346         If return code negative then out of memory */
    5447     virtual int factorize(const double * diagonal, int * rowsDropped) ;
    55      /** Uses factorization to solve. */
     48     /** Uses factorization to solve. Uses CHOLMOD (if available). */
    5649     virtual void solve (double * region) ;
    57 #endif
    5850     //@}
    5951
     
    6658     /** Destructor  */
    6759     virtual ~ClpCholeskyUfl();
    68      // Copy
    69      ClpCholeskyUfl(const ClpCholeskyUfl&);
    70      // Assignment
    71      ClpCholeskyUfl& operator=(const ClpCholeskyUfl&);
    7260     /// Clone
    7361     virtual ClpCholeskyBase * clone() const ;
     
    7664
    7765private:
    78 #ifdef CLP_USE_CHOLMOD
    7966     cholmod_factor * L_ ;
    80      cholmod_common c_ ;
    81 #endif
     67     cholmod_common * c_ ;
     68
     69     // Copy
     70     ClpCholeskyUfl(const ClpCholeskyUfl&);
     71     // Assignment
     72     ClpCholeskyUfl& operator=(const ClpCholeskyUfl&);
    8273};
    8374
  • stable/1.14/Clp/src/ClpCholeskyWssmp.cpp

    r1665 r1753  
    11/* $Id$ */
    2 #ifdef WSSMP_BARRIER
    32// Copyright (C) 2003, International Business Machines
    43// Corporation and others.  All Rights Reserved.
     
    6463// At present I can't get wssmp to work as my libraries seem to be out of sync
    6564// so I have linked in ekkwssmp which is an older version
    66 #if WSSMP_BARRIER==2
    67 extern "C" void wssmp(int * n,
    68                       int * columnStart , int * rowIndex , double * element,
    69                       double * diagonal , int * perm , int * invp ,
    70                       double * rhs , int * ldb , int * nrhs ,
    71                       double * aux , int * naux ,
    72                       int   * mrp , int * iparm , double * dparm);
    73 extern "C" void wsetmaxthrds(int *);
    74 #elif WSSMP_BARRIER==3
    75 extern "C" void wssmp_(int * n,
    76                        int * columnStart , int * rowIndex , double * element,
    77                        double * diagonal , int * perm , int * invp ,
    78                        double * rhs , int * ldb , int * nrhs ,
    79                        double * aux , int * naux ,
    80                        int   * mrp , int * iparm , double * dparm);
    81 extern "C" void wsetmaxthrds_(int *);
    82 static void wssmp( int *n, int *ia, int *ja,
    83                    double *avals, double *diag, int *perm, int *invp,
    84                    double *b, int *ldb, int *nrhs, double *aux, int *
    85                    naux, int *mrp, int *iparm, double *dparm)
    86 {
    87      wssmp_(n, ia, ja,
    88             avals, diag, perm, invp,
    89             b, ldb, nrhs, aux,
    90             naux, mrp, iparm, dparm);
    91 }
    92 static void wsetmaxthrds(int * n)
    93 {
    94      wsetmaxthrds_(n);
     65#ifndef USE_EKKWSSMP
     66extern "C" {
     67void F77_FUNC(wsetmaxthrds,WSETMAXTHRDS)(const int* NTHREADS);
     68
     69void F77_FUNC(wssmp,WSSMP)(const int* N, const int* IA,
     70                           const int* JA, const double* AVALS,
     71                           double* DIAG,  int* PERM,
     72                           int* INVP,  double* B,   
     73                           const int* LDB, const int* NRHS,
     74                           double* AUX, const int* NAUX,
     75                           int* MRP, int* IPARM,
     76                           double* DPARM);
     77void F77_FUNC_(wsmp_clear,WSMP_CLEAR)(void);
    9578}
    9679#else
     
    11497                         double * aux , int * naux ,
    11598                         int   * mrp , int * iparm , double * dparm);
    116 static void wssmp( int *n, int *ia, int *ja,
     99static void F77_FUNC(wssmp,WSSMP)( int *n, int *ia, int *ja,
    117100                   double *avals, double *diag, int *perm, int *invp,
    118101                   double *b, int *ldb, int *nrhs, double *aux, int *
     
    173156          for (iRow = numberRows_; iRow >= stop; iRow--) {
    174157               if (used[iRow])
    175                     printf("%d columns are of length %d\n", used[iRow], iRow);
     158                 COIN_DETAIL_PRINT(printf("%d columns are of length %d\n", used[iRow], iRow));
    176159               nLong += used[iRow];
    177160               if (nLong > 50 || nLong > (numberColumns >> 2))
     
    199182               dense_ = new ClpCholeskyDense();
    200183               dense_->reserveSpace(NULL, numberDense);
    201                printf("Taking %d columns as dense\n", numberDense);
     184               COIN_DETAIL_PRINT(printf("Taking %d columns as dense\n", numberDense));
    202185          }
    203186     }
     
    297280     int i0 = 0;
    298281     int i1 = 1;
    299 #if WSSMP_BARRIER>=2
     282#ifndef USE_EKKWSSMP
    300283     int i2 = 1;
    301284     if (model->numberThreads() <= 0)
     
    303286     else
    304287          i2 = model->numberThreads();
    305      wsetmaxthrds(&i2);
     288     F77_FUNC(wsetmaxthrds,WSETMAXTHRDS)(&i2);
    306289#endif
    307      wssmp(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
     290     F77_FUNC(wssmp,WSSMP)(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
    308291           NULL, permute_, permuteInverse_, 0, &numberRows_, &i1,
    309292           NULL, &i0, NULL, integerParameters_, doubleParameters_);
     
    320303     doubleParameters_[10] = 1.0e-20;
    321304     doubleParameters_[11] = 1.0e-15;
    322      wssmp(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
     305     F77_FUNC(wssmp,WSSMP)(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
    323306           NULL, permute_, permuteInverse_, NULL, &numberRows_, &i1,
    324307           NULL, &i0, NULL, integerParameters_, doubleParameters_);
     
    343326          integerParameters_[2] = 2;
    344327          integerParameters_[7] = 1; // no permute
    345           wssmp(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
     328          F77_FUNC(wssmp,WSSMP)(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
    346329                NULL, permute_, permuteInverse_, NULL, &numberRows_, &i1,
    347330                NULL, &i0, NULL, integerParameters_, doubleParameters_);
     
    486469     else
    487470          integerParameters_[9] = 0;
    488      wssmp(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
     471     F77_FUNC(wssmp,WSSMP)(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
    489472           NULL, permute_, permuteInverse_, NULL, &numberRows_, &i1,
    490473           NULL, &i0, rowsDropped, integerParameters_, doubleParameters_);
     
    519502          integerParameters_[1] = 4;
    520503          integerParameters_[2] = 4;
    521           wssmp(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
     504          F77_FUNC(wssmp,WSSMP)(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
    522505                NULL, permute_, permuteInverse_, denseColumn_, &numberRows_, &numberDense,
    523506                NULL, &i0, NULL, integerParameters_, doubleParameters_);
     
    617600#endif
    618601     if (!whichDense_) {
    619           wssmp(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
     602          F77_FUNC(wssmp,WSSMP)(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
    620603                NULL, permute_, permuteInverse_, region, &numberRows_, &i1,
    621604                NULL, &i0, NULL, integerParameters_, doubleParameters_);
     
    623606          // dense columns
    624607          integerParameters_[29] = 1;
    625           wssmp(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
     608          F77_FUNC(wssmp,WSSMP)(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
    626609                NULL, permute_, permuteInverse_, region, &numberRows_, &i1,
    627610                NULL, &i0, NULL, integerParameters_, doubleParameters_);
     
    649632          integerParameters_[29] = 2;
    650633          integerParameters_[1] = 4;
    651           wssmp(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
     634          F77_FUNC(wssmp,WSSMP)(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
    652635                NULL, permute_, permuteInverse_, region, &numberRows_, &i1,
    653636                NULL, &i0, NULL, integerParameters_, doubleParameters_);
     
    661644#endif
    662645}
    663 #endif
  • stable/1.14/Clp/src/ClpCholeskyWssmpKKT.cpp

    r1665 r1753  
    11/* $Id$ */
    2 #ifdef WSSMP_BARRIER
    32// Copyright (C) 2004, International Business Machines
    43// Corporation and others.  All Rights Reserved.
     
    6463// At present I can't get wssmp to work as my libraries seem to be out of sync
    6564// so I have linked in ekkwssmp which is an older version
    66 #if WSSMP_BARRIER==2
    67 extern "C" void wssmp(int * n,
    68                       int * columnStart , int * rowIndex , double * element,
    69                       double * diagonal , int * perm , int * invp ,
    70                       double * rhs , int * ldb , int * nrhs ,
    71                       double * aux , int * naux ,
    72                       int   * mrp , int * iparm , double * dparm);
    73 extern "C" void wsetmaxthrds(int *);
    74 #elif WSSMP_BARRIER==3
    75 extern "C" void wssmp_(int * n,
    76                        int * columnStart , int * rowIndex , double * element,
    77                        double * diagonal , int * perm , int * invp ,
    78                        double * rhs , int * ldb , int * nrhs ,
    79                        double * aux , int * naux ,
    80                        int   * mrp , int * iparm , double * dparm);
    81 extern "C" void wsetmaxthrds_(int *);
    82 static void wssmp( int *n, int *ia, int *ja,
    83                    double *avals, double *diag, int *perm, int *invp,
    84                    double *b, int *ldb, int *nrhs, double *aux, int *
    85                    naux, int *mrp, int *iparm, double *dparm)
    86 {
    87      wssmp_(n, ia, ja,
    88             avals, diag, perm, invp,
    89             b, ldb, nrhs, aux,
    90             naux, mrp, iparm, dparm);
    91 }
    92 static void wsetmaxthrds(int * n)
    93 {
    94      wsetmaxthrds_(n);
     65#ifndef USE_EKKWSSMP
     66extern "C" {
     67void F77_FUNC(wsetmaxthrds,WSETMAXTHRDS)(const int* NTHREADS);
     68
     69void F77_FUNC(wssmp,WSSMP)(const int* N, const int* IA,
     70                           const int* JA, const double* AVALS,
     71                           double* DIAG,  int* PERM,
     72                           int* INVP,  double* B,   
     73                           const int* LDB, const int* NRHS,
     74                           double* AUX, const int* NAUX,
     75                           int* MRP, int* IPARM,
     76                           double* DPARM);
     77void F77_FUNC_(wsmp_clear,WSMP_CLEAR)(void);
    9578}
    9679#else
     
    11497                         double * aux , int * naux ,
    11598                         int   * mrp , int * iparm , double * dparm);
    116 static void wssmp( int *n, int *ia, int *ja,
     99static void F77_FUNC(wssmp,WSSMP)( int *n, int *ia, int *ja,
    117100                   double *avals, double *diag, int *perm, int *invp,
    118101                   double *b, int *ldb, int *nrhs, double *aux, int *
     
    132115}
    133116#endif
     117
    134118/* Orders rows and saves pointer to model */
    135119int
     
    232216     int i0 = 0;
    233217     int i1 = 1;
    234 #if WSSMP_BARRIER>=2
     218#ifndef USE_EKKWSSMP
    235219     int i2 = 1;
    236220     if (model->numberThreads() <= 0)
     
    238222     else
    239223          i2 = model->numberThreads();
    240      wsetmaxthrds(&i2);
    241 #endif
    242      wssmp(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
     224     F77_FUNC(wsetmaxthrds,WSETMAXTHRDS)(&i2);
     225#endif
     226     F77_FUNC(wssmp,WSSMP)(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
    243227           NULL, permute_, permuteInverse_, 0, &numberRows_, &i1,
    244228           NULL, &i0, NULL, integerParameters_, doubleParameters_);
     
    262246     }
    263247#endif
    264      wssmp(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
     248     F77_FUNC(wssmp,WSSMP)(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
    265249           NULL, permute_, permuteInverse_, NULL, &numberRows_, &i1,
    266250           NULL, &i0, NULL, integerParameters_, doubleParameters_);
     
    280264          integerParameters_[2] = 2;
    281265          integerParameters_[7] = 1; // no permute
    282           wssmp(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
     266          F77_FUNC(wssmp,WSSMP)(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
    283267                NULL, permute_, permuteInverse_, NULL, &numberRows_, &i1,
    284268                NULL, &i0, NULL, integerParameters_, doubleParameters_);
     
    444428     int * rowsDropped2 = new int[numberRows_];
    445429     CoinZeroN(rowsDropped2, numberRows_);
    446      wssmp(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
     430     F77_FUNC(wssmp,WSSMP)(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
    447431           NULL, permute_, permuteInverse_, NULL, &numberRows_, &i1,
    448432           NULL, &i0, rowsDropped2, integerParameters_, doubleParameters_);
     
    522506     integerParameters_[6] = 6;
    523507#endif
    524      wssmp(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
     508     F77_FUNC(wssmp,WSSMP)(&numberRows_, choleskyStart_, choleskyRow_, sparseFactor_,
    525509           NULL, permute_, permuteInverse_, array, &numberRows_, &i1,
    526510           NULL, &i0, NULL, integerParameters_, doubleParameters_);
    527 #if 1
     511#if 0
    528512     int iRow;
    529513     for (iRow = 0; iRow < numberTotal; iRow++) {
     
    556540#endif
    557541}
    558 #endif
  • stable/1.14/Clp/src/ClpConfig.h

    r1668 r1753  
    1 /* $Id$ */
    2 /*
     1/* Copyright (C) 2011
     2 * All Rights Reserved.
     3 * This code is published under the Eclipse Public License.
     4 *
     5 * $Id$
     6 *
    37 * Include file for the configuration of Clp.
    48 *
    59 * On systems where the code is configured with the configure script
    610 * (i.e., compilation is always done with HAVE_CONFIG_H defined), this
    7  * header file includes the automatically generated header file, and
    8  * undefines macros that might configure with other Config.h files.
     11 * header file includes the automatically generated header file.
    912 *
    1013 * On systems that are compiled in other ways (e.g., with the
     
    1215 * macros that depend on the operating system and the compiler.  The
    1316 * macros that define the configuration of the particular user setting
    14  * (e.g., presence of other COIN packages or third party code) are set
    15  * here.  The project maintainer needs to remember to update this file
    16  * and choose reasonable defines.  A user can modify the default
    17  * setting by editing this file here.
    18  *
     17 * (e.g., presence of other COIN-OR packages or third party code) are set
     18 * by the files config_*default.h. The project maintainer needs to remember
     19 * to update these file and choose reasonable defines.
     20 * A user can modify the default setting by editing the config_*default.h files.
    1921 */
    2022
     
    2325
    2426#ifdef HAVE_CONFIG_H
     27#ifdef CLP_BUILD
     28#include "config.h"
     29#else
    2530#include "config_clp.h"
    26 
    27 /* undefine macros that could conflict with those in other config.h
    28    files */
    29 #undef PACKAGE
    30 #undef PACKAGE_BUGREPORT
    31 #undef PACKAGE_NAME
    32 #undef PACKAGE_STRING
    33 #undef PACKAGE_TARNAME
    34 #undef PACKAGE_VERSION
    35 #undef VERSION
     31#endif
    3632
    3733#else /* HAVE_CONFIG_H */
    3834
    39 /* include the COIN-wide system specific configure header */
    40 #include "configall_system.h"
    41 
    42 /***************************************************************************/
    43 /*             HERE DEFINE THE CONFIGURATION SPECIFIC MACROS               */
    44 /***************************************************************************/
    45 
    46 /* Define to the debug sanity check level (0 is no test) */
    47 #define COIN_CLP_CHECKLEVEL 0
    48 
    49 /* Define to the debug verbosity level (0 is no output) */
    50 #define COIN_CLP_VERBOSITY 0
    51 
    52 /* Define to 1 if the Clp package is used */
    53 #define COIN_HAS_CLP 1
    54 
    55 /* Define to 1 if the CoinUtils package is used */
    56 #define COIN_HAS_COINUTILS 1
    57 
    58 /* Define to 1 if readline is available */
    59 /* #undef COIN_HAS_READLINE */
    60 
    61 /* Clp version */
    62 #define CLP_VERSION "1.14"
     35#ifdef CLP_BUILD
     36#include "config_default.h"
     37#else
     38#include "config_clp_default.h"
     39#endif
    6340
    6441#endif /* HAVE_CONFIG_H */
    6542
    66 #endif /*__CLPCONFIG_H__ */
     43#endif /*__CLPCONFIG_H__*/
  • stable/1.14/Clp/src/ClpDualRowDantzig.cpp

    r1665 r1753  
    1010#include "CoinIndexedVector.hpp"
    1111#include "CoinHelperFunctions.hpp"
     12#ifndef CLP_DUAL_COLUMN_MULTIPLIER
     13#define CLP_DUAL_COLUMN_MULTIPLIER 1.01
     14#endif
    1215
    1316//#############################################################################
     
    6063     int iRow;
    6164     const int * pivotVariable = model_->pivotVariable();
    62      double largest = model_->currentPrimalTolerance();
     65     double tolerance = model_->currentPrimalTolerance();
    6366     // we can't really trust infeasibilities if there is primal error
    6467     if (model_->largestPrimalError() > 1.0e-8)
    65           largest *= model_->largestPrimalError() / 1.0e-8;
     68          tolerance *= model_->largestPrimalError() / 1.0e-8;
     69     double largest = 0.0;
    6670     int chosenRow = -1;
    67      for (iRow = 0; iRow < model_->numberRows(); iRow++) {
    68           int iPivot = pivotVariable[iRow];
    69           double value = model_->solution(iPivot);
    70           double lower = model_->lower(iPivot);
    71           double upper = model_->upper(iPivot);
    72           if (CoinMax(value - upper, lower - value) > largest) {
    73                int iSequence = pivotVariable[iRow];
    74                if (!model_->flagged(iSequence)) {
    75                     chosenRow = iRow;
    76                     largest = CoinMax(value - upper, lower - value);
    77                }
     71     int numberRows = model_->numberRows();
     72#ifdef CLP_DUAL_COLUMN_MULTIPLIER
     73     int numberColumns = model_->numberColumns();
     74#endif
     75     for (iRow = 0; iRow < numberRows; iRow++) {
     76          int iSequence = pivotVariable[iRow];
     77          double value = model_->solution(iSequence);
     78          double lower = model_->lower(iSequence);
     79          double upper = model_->upper(iSequence);
     80          double infeas = CoinMax(value - upper , lower - value);
     81          if (infeas > tolerance) {
     82#ifdef CLP_DUAL_COLUMN_MULTIPLIER
     83              if (iSequence < numberColumns)
     84                infeas *= CLP_DUAL_COLUMN_MULTIPLIER;
     85#endif
     86              if (infeas > largest) {
     87                if (!model_->flagged(iSequence)) {
     88                  chosenRow = iRow;
     89                  largest = infeas;
     90                }
     91              }
    7892          }
    7993     }
  • stable/1.14/Clp/src/ClpDualRowPivot.hpp

    r1665 r1753  
    122122     //@}
    123123};
    124 
     124#ifndef CLP_DUAL_COLUMN_MULTIPLIER
     125//#define CLP_DUAL_COLUMN_MULTIPLIER 0.99999
    125126#endif
     127#endif
  • stable/1.14/Clp/src/ClpDualRowSteepest.cpp

    r1665 r1753  
    236236     double * upper = model_->upperRegion();
    237237     // do last pivot row one here
    238      //#define COLUMN_BIAS 4.0
    239      //#define FIXED_BIAS 10.0
     238     //#define CLP_DUAL_FIXED_COLUMN_MULTIPLIER 10.0
    240239     if (lastPivotRow >= 0 && lastPivotRow < model_->numberRows()) {
    241 #ifdef COLUMN_BIAS
     240#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    242241          int numberColumns = model_->numberColumns();
    243242#endif
     
    249248               value -= upper;
    250249               value *= value;
    251 #ifdef COLUMN_BIAS
     250#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    252251               if (iPivot < numberColumns)
    253                     value *= COLUMN_BIAS; // bias towards columns
    254                k
     252                    value *= CLP_DUAL_COLUMN_MULTIPLIER; // bias towards columns
    255253#endif
    256254               // store square in list
     
    262260               value -= lower;
    263261               value *= value;
    264 #ifdef COLUMN_BIAS
     262#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    265263               if (iPivot < numberColumns)
    266                     value *= COLUMN_BIAS; // bias towards columns
     264                    value *= CLP_DUAL_COLUMN_MULTIPLIER; // bias towards columns
    267265#endif
    268266               // store square in list
     
    685683     const double * COIN_RESTRICT lowerModel = model_->lowerRegion();
    686684     const double * COIN_RESTRICT upperModel = model_->upperRegion();
    687 #ifdef COLUMN_BIAS
     685#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    688686     int numberColumns = model_->numberColumns();
    689687#endif
     
    704702                    value -= lower;
    705703                    value *= value;
    706 #ifdef COLUMN_BIAS
     704#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    707705                    if (iPivot < numberColumns)
    708                          value *= COLUMN_BIAS; // bias towards columns
    709 #endif
    710 #ifdef FIXED_BIAS
     706                         value *= CLP_DUAL_COLUMN_MULTIPLIER; // bias towards columns
     707#endif
     708#ifdef CLP_DUAL_FIXED_COLUMN_MULTIPLIER
    711709                    if (lower == upper)
    712                          value *= FIXED_BIAS; // bias towards taking out fixed variables
     710                         value *= CLP_DUAL_FIXED_COLUMN_MULTIPLIER; // bias towards taking out fixed variables
    713711#endif
    714712                    // store square in list
     
    720718                    value -= upper;
    721719                    value *= value;
    722 #ifdef COLUMN_BIAS
     720#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    723721                    if (iPivot < numberColumns)
    724                          value *= COLUMN_BIAS; // bias towards columns
    725 #endif
    726 #ifdef FIXED_BIAS
     722                         value *= CLP_DUAL_COLUMN_MULTIPLIER; // bias towards columns
     723#endif
     724#ifdef CLP_DUAL_FIXED_COLUMN_MULTIPLIER
    727725                    if (lower == upper)
    728                          value *= FIXED_BIAS; // bias towards taking out fixed variables
     726                         value *= CLP_DUAL_FIXED_COLUMN_MULTIPLIER; // bias towards taking out fixed variables
    729727#endif
    730728                    // store square in list
     
    754752                    value -= lower;
    755753                    value *= value;
    756 #ifdef COLUMN_BIAS
     754#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    757755                    if (iPivot < numberColumns)
    758                          value *= COLUMN_BIAS; // bias towards columns
    759 #endif
    760 #ifdef FIXED_BIAS
     756                         value *= CLP_DUAL_COLUMN_MULTIPLIER; // bias towards columns
     757#endif
     758#ifdef CLP_DUAL_FIXED_COLUMN_MULTIPLIER
    761759                    if (lower == upper)
    762                          value *= FIXED_BIAS; // bias towards taking out fixed variables
     760                         value *= CLP_DUAL_FIXED_COLUMN_MULTIPLIER; // bias towards taking out fixed variables
    763761#endif
    764762                    // store square in list
     
    770768                    value -= upper;
    771769                    value *= value;
    772 #ifdef COLUMN_BIAS
     770#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    773771                    if (iPivot < numberColumns)
    774                          value *= COLUMN_BIAS; // bias towards columns
    775 #endif
    776 #ifdef FIXED_BIAS
     772                         value *= CLP_DUAL_COLUMN_MULTIPLIER; // bias towards columns
     773#endif
     774#ifdef CLP_DUAL_FIXED_COLUMN_MULTIPLIER
    777775                    if (lower == upper)
    778                          value *= FIXED_BIAS; // bias towards taking out fixed variables
     776                         value *= CLP_DUAL_FIXED_COLUMN_MULTIPLIER; // bias towards taking out fixed variables
    779777#endif
    780778                    // store square in list
     
    979977                    value -= lower;
    980978                    value *= value;
    981 #ifdef COLUMN_BIAS
     979#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    982980                    if (iPivot < numberColumns)
    983                          value *= COLUMN_BIAS; // bias towards columns
    984 #endif
    985 #ifdef FIXED_BIAS
     981                         value *= CLP_DUAL_COLUMN_MULTIPLIER; // bias towards columns
     982#endif
     983#ifdef CLP_DUAL_FIXED_COLUMN_MULTIPLIER
    986984                    if (lower == upper)
    987                          value *= FIXED_BIAS; // bias towards taking out fixed variables
     985                         value *= CLP_DUAL_FIXED_COLUMN_MULTIPLIER; // bias towards taking out fixed variables
    988986#endif
    989987                    // store square in list
     
    992990                    value -= upper;
    993991                    value *= value;
    994 #ifdef COLUMN_BIAS
     992#ifdef CLP_DUAL_COLUMN_MULTIPLIER
    995993                    if (iPivot < numberColumns)
    996                          value *= COLUMN_BIAS; // bias towards columns
    997 #endif
    998 #ifdef FIXED_BIAS
     994                         value *= CLP_DUAL_COLUMN_MULTIPLIER; // bias towards columns
     995#endif
     996#ifdef CLP_DUAL_FIXED_COLUMN_MULTIPLIER
    999997                    if (lower == upper)
    1000                          value *= FIXED_BIAS; // bias towards taking out fixed variables
     998                         value *= CLP_DUAL_FIXED_COLUMN_MULTIPLIER; // bias towards taking out fixed variables
    1001999#endif
    10021000                    // store square in list
  • stable/1.14/Clp/src/ClpDynamicExampleMatrix.cpp

    r1665 r1753  
    655655          }
    656656     }
    657      ClpDynamicMatrix::createVariable(model, bestSequence);
     657     ClpDynamicMatrix::createVariable(model, bestSequence/*, bestSequence2*/);
    658658     // clear for next iteration
    659659     savedBestSequence_ = -1;
  • stable/1.14/Clp/src/ClpDynamicMatrix.cpp

    r1665 r1753  
    9494     lowerSet_ = ClpCopyOfArray(rhs.lowerSet_, numberSets_);
    9595     upperSet_ = ClpCopyOfArray(rhs.upperSet_, numberSets_);
    96      status_ = ClpCopyOfArray(rhs.status_, numberSets_);
     96     status_ = ClpCopyOfArray(rhs.status_, static_cast<int>(2*numberSets_+4*sizeof(int)));
    9797     model_ = rhs.model_;
    9898     sumDualInfeasibilities_ = rhs. sumDualInfeasibilities_;
     
    110110     maximumGubColumns_ = rhs.maximumGubColumns_;
    111111     maximumElements_ = rhs.maximumElements_;
    112      startSet_ = ClpCopyOfArray(rhs.startSet_, numberSets_);
     112     startSet_ = ClpCopyOfArray(rhs.startSet_, numberSets_+1);
    113113     next_ = ClpCopyOfArray(rhs.next_, maximumGubColumns_);
    114114     startColumn_ = ClpCopyOfArray(rhs.startColumn_, maximumGubColumns_ + 1);
     
    119119     columnLower_ = ClpCopyOfArray(rhs.columnLower_, maximumGubColumns_);
    120120     columnUpper_ = ClpCopyOfArray(rhs.columnUpper_, maximumGubColumns_);
    121      dynamicStatus_ = ClpCopyOfArray(rhs.dynamicStatus_, maximumGubColumns_);
     121     dynamicStatus_ = ClpCopyOfArray(rhs.dynamicStatus_, 2*maximumGubColumns_);
    122122}
    123123
     
    143143     else
    144144          maximumElements_ = 0;
    145      startSet_ = new int [numberSets_];
     145     startSet_ = new int [numberSets_+1];
    146146     next_ = new int [maximumGubColumns_];
    147147     // fill in startSet and next
     
    157157          }
    158158     }
     159     startSet_[numberSets_] = starts[numberSets_];
    159160     int numberColumns = model->numberColumns();
    160161     int numberRows = model->numberRows();
     
    165166     int frequency = model->factorizationFrequency();
    166167     int numberGubInSmall = numberRows + frequency + CoinMin(frequency, numberSets_) + 4;
     168     // But we may have two per row + one for incoming (make it two)
     169     numberGubInSmall = CoinMax(2*numberRows+2,numberGubInSmall);
    167170     // for small problems this could be too big
    168171     //numberGubInSmall = CoinMin(numberGubInSmall,numberGubColumns_);
     
    174177     startColumn_ = ClpCopyOfArray(startColumn, numberGubColumns_ + 1);
    175178     if (!numberGubColumns_) {
    176           startColumn_ = new CoinBigIndex [1];
    177           startColumn_[0] = 0;
     179       //startColumn_ = new CoinBigIndex [1];
     180       startColumn_[0] = 0;
    178181     }
    179182     CoinBigIndex numberElements = startColumn_[numberGubColumns_];
     
    232235     numberElements_ = CoinMin(numberElements_, numberElements) + originalMatrix->getNumElements();
    233236     matrix_ = originalMatrix;
     237     //delete originalMatrixA;
    234238     flags_ &= ~1;
    235239     // resize model (matrix stays same)
    236      int newRowSize = numberRows + CoinMin(numberSets_, CoinMax(frequency, numberRows)) + 1;
     240     // modify frequency
     241     if (frequency>=50)
     242       frequency = 50+(frequency-50)/2;
     243     int newRowSize = numberRows + CoinMin(numberSets_, frequency+numberRows) + 1;
    237244     model->resize(newRowSize, numberNeeded);
    238245     for (i = numberRows; i < newRowSize; i++)
     
    256263     keyVariable_ = new int[numberSets_];
    257264     if (status) {
    258           status_ = ClpCopyOfArray(status, numberSets_);
     265          status_ = ClpCopyOfArray(status, static_cast<int>(2*numberSets_+4*sizeof(int)));
    259266          assert (dynamicStatus);
    260           dynamicStatus_ = ClpCopyOfArray(dynamicStatus, numberGubColumns_);
     267          dynamicStatus_ = ClpCopyOfArray(dynamicStatus, 2*numberGubColumns_);
    261268     } else {
    262           status_ = new unsigned char [numberSets_];
     269          status_ = new unsigned char [2*numberSets_+4*sizeof(int)];
    263270          memset(status_, 0, numberSets_);
    264271          int i;
     
    267274               setStatus(i, ClpSimplex::basic);
    268275          }
    269           dynamicStatus_ = new unsigned char [numberGubColumns_];
     276          dynamicStatus_ = new unsigned char [2*numberGubColumns_];
    270277          memset(dynamicStatus_, 0, numberGubColumns_); // for clarity
    271278          for (i = 0; i < numberGubColumns_; i++)
     
    353360          lowerSet_ = ClpCopyOfArray(rhs.lowerSet_, numberSets_);
    354361          upperSet_ = ClpCopyOfArray(rhs.upperSet_, numberSets_);
    355           status_ = ClpCopyOfArray(rhs.status_, numberSets_);
     362          status_ = ClpCopyOfArray(rhs.status_, static_cast<int>(2*numberSets_+4*sizeof(int)));
    356363          model_ = rhs.model_;
    357364          sumDualInfeasibilities_ = rhs. sumDualInfeasibilities_;
     
    369376          maximumGubColumns_ = rhs.maximumGubColumns_;
    370377          maximumElements_ = rhs.maximumElements_;
    371           startSet_ = ClpCopyOfArray(rhs.startSet_, numberSets_);
     378          startSet_ = ClpCopyOfArray(rhs.startSet_, numberSets_+1);
    372379          next_ = ClpCopyOfArray(rhs.next_, maximumGubColumns_);
    373380          startColumn_ = ClpCopyOfArray(rhs.startColumn_, maximumGubColumns_ + 1);
     
    378385          columnLower_ = ClpCopyOfArray(rhs.columnLower_, maximumGubColumns_);
    379386          columnUpper_ = ClpCopyOfArray(rhs.columnUpper_, maximumGubColumns_);
    380           dynamicStatus_ = ClpCopyOfArray(rhs.dynamicStatus_, maximumGubColumns_);
     387          dynamicStatus_ = ClpCopyOfArray(rhs.dynamicStatus_, 2*maximumGubColumns_);
    381388     }
    382389     return *this;
     
    533540                                   // check flagged variable and correct dj
    534541                                   if (!flagged(iSequence)) {
     542                                     if (false/*status == atLowerBound
     543                                                &&keyValue(iSet)<1.0e-7*/) {
     544                                       // can't come in because
     545                                       // of ones at ub
     546                                       numberWanted++;
     547                                     } else {
     548                                     
    535549                                        bestDj = value;
    536550                                        bestSequence = structuralOffset + iSequence;
    537551                                        bestDjMod = djMod;
    538552                                        bestSet = iSet;
     553                                     }
    539554                                   } else {
    540555                                        // just to make sure we don't exit before got something
     
    576591                           )
    577592{
    578      //forceRefresh=true;
     593     // forceRefresh=true;printf("take out forceRefresh\n");
    579594     if (!model_->numberIterations())
    580595          forceRefresh = true;
     
    735750                                   } else if (getDynamicStatus(j) == atUpperBound) {
    736751                                        value = columnUpper_[j];
     752                                        assert (value<1.0e30);
    737753                                   } else if (getDynamicStatus(j) == soloKey) {
    738754                                        value = keyValue(iSet);
    739                                    }
     755                                   }
    740756                                   objectiveOffset += value * cost_[j];
    741757                              }
     
    753769                    for (iSet = 0; iSet < numberSets_; iSet++) {
    754770                         int kRow = toIndex_[iSet];
    755                          if (kRow >= 0)
    756                               kRow += numberStaticRows_;
    757                          int j = startSet_[iSet];
    758                          while (j >= 0) {
    759                               double value = solution[j];
    760                               if (value) {
    761                                    for (CoinBigIndex k = startColumn_[j]; k < startColumn_[j+1]; k++) {
    762                                         int iRow = row_[k];
    763                                         rhsOffset_[iRow] -= element_[k] * value;
    764                                    }
    765                                    if (kRow >= 0)
    766                                         rhsOffset_[kRow] -= value;
    767                               }
    768                               j = next_[j]; //onto next in set
    769                          }
     771                         if (kRow >= 0)
     772                           kRow += numberStaticRows_;
     773                         int j = startSet_[iSet];
     774                         while (j >= 0) {
     775                           //? use DynamicStatus status = getDynamicStatus(j);
     776                           double value = solution[j];
     777                           if (value) {
     778                             for (CoinBigIndex k = startColumn_[j]; k < startColumn_[j+1]; k++) {
     779                               int iRow = row_[k];
     780                               rhsOffset_[iRow] -= element_[k] * value;
     781                             }
     782                             if (kRow >= 0)
     783                               rhsOffset_[kRow] -= value;
     784                           }
     785                           j = next_[j]; //onto next in set
     786                         }
    770787                    }
    771788                    delete [] solution;
     
    852869          if (lowerSet_[iSet] == upperSet_[iSet])
    853870               setStatus(iSet, ClpSimplex::isFixed);
     871#if 0
    854872          if (getStatus(iSet) != model->getStatus(sequenceOut))
    855873               printf("** set %d status %d, var status %d\n", iSet,
    856874                      getStatus(iSet), model->getStatus(sequenceOut));
     875#endif
    857876     }
    858877     ClpMatrixBase::updatePivot(model, oldInValue, oldOutValue);
     
    888907#endif
    889908#endif
    890      return 0;
     909     if (numberStaticRows_+numberActiveSets_<model->numberRows())
     910       return 0;
     911     else
     912       return 1;
    891913}
    892914/*
     
    10311053{
    10321054     int returnCode = 0;
     1055#if 0 //ndef NDEBUG
     1056     {
     1057       int numberColumns = model->numberColumns();
     1058       int numberRows = model->numberRows();
     1059       int * pivotVariable = model->pivotVariable();
     1060       if (pivotVariable&&model->numberIterations()) {
     1061         for (int i=numberStaticRows_+numberActiveSets_;i<numberRows;i++) {
     1062           assert (pivotVariable[i]==i+numberColumns);
     1063         }
     1064       }
     1065     }
     1066#endif
    10331067     switch (mode) {
    10341068          // Fill in pivotVariable
     
    10731107     // save status
    10741108     case 5: {
     1109       memcpy(status_+numberSets_,status_,numberSets_);
     1110       memcpy(status_+2*numberSets_,&numberActiveSets_,sizeof(int));
     1111       memcpy(dynamicStatus_+maximumGubColumns_,
     1112              dynamicStatus_,maximumGubColumns_);
    10751113     }
    10761114     break;
    10771115     // restore status
    10781116     case 6: {
    1079           // maybe mismatch - redo all in small model
    1080           //for (int i=firstDynamic_;i<firstAvailable_;i++) {
    1081           //int jColumn = id_[i-firstDynamic_];
    1082           //setDynamicStatus(jColumn,inSmall);
    1083           //}
     1117       memcpy(status_,status_+numberSets_,numberSets_);
     1118       memcpy(&numberActiveSets_,status_+2*numberSets_,sizeof(int));
     1119       memcpy(dynamicStatus_,dynamicStatus_+maximumGubColumns_,
     1120              maximumGubColumns_);
     1121       initialProblem();
    10841122     }
    10851123     break;
     
    11721210          // first flag
    11731211          if (number >= firstDynamic_ && number < lastDynamic_) {
    1174                assert (number == model->sequenceIn());
    1175                // id will be sitting at firstAvailable
    1176                int sequence = id_[firstAvailable_-firstDynamic_];
    1177                setFlagged(sequence);
    1178                model->clearFlagged(firstAvailable_);
    1179           }
     1212            int sequence = id_[number-firstDynamic_];
     1213            setFlagged(sequence);
     1214            //model->clearFlagged(number);
     1215          } else if (number>=model_->numberColumns()+numberStaticRows_) {
     1216            // slack
     1217            int iSet = fromIndex_[number-model_->numberColumns()-
     1218                                  numberStaticRows_];
     1219            setFlaggedSlack(iSet);
     1220            //model->clearFlagged(number);
     1221          }
    11801222     }
    11811223     case 11: {
    1182           int sequenceIn = model->sequenceIn();
    1183           if (sequenceIn >= firstDynamic_ && sequenceIn < lastDynamic_) {
    1184                assert (number == model->sequenceIn());
     1224          //int sequenceIn = model->sequenceIn();
     1225          if (number >= firstDynamic_ && number < lastDynamic_) {
     1226            //assert (number == model->sequenceIn());
    11851227               // take out variable (but leave key)
    11861228               double * cost = model->costRegion();
     
    11901232               int * length = matrix_->getMutableVectorLengths();
    11911233#ifndef NDEBUG
    1192                if (length[sequenceIn]) {
     1234               if (length[number]) {
    11931235                    int * row = matrix_->getMutableIndices();
    11941236                    CoinBigIndex * startColumn = matrix_->getMutableVectorStarts();
    1195                     int iRow = row[startColumn[sequenceIn] + length[sequenceIn] - 1];
     1237                    int iRow = row[startColumn[number] + length[number] - 1];
    11961238                    int which = iRow - numberStaticRows_;
    11971239                    assert (which >= 0);
     
    12101252
    12111253               // not really in small problem
    1212                int iBig = id_[sequenceIn-firstDynamic_];
    1213                if (model->getStatus(sequenceIn) == ClpSimplex::atLowerBound) {
     1254               int iBig = id_[number-firstDynamic_];
     1255               if (model->getStatus(number) == ClpSimplex::atLowerBound) {
    12141256                    setDynamicStatus(iBig, atLowerBound);
    12151257                    if (columnLower_)
    1216                          modifyOffset(sequenceIn, columnLower_[iBig]);
     1258                         modifyOffset(number, columnLower_[iBig]);
    12171259               } else {
    12181260                    setDynamicStatus(iBig, atUpperBound);
    1219                     modifyOffset(sequenceIn, columnUpper_[iBig]);
    1220                }
     1261                    modifyOffset(number, columnUpper_[iBig]);
     1262               }
     1263          } else if (number>=model_->numberColumns()+numberStaticRows_) {
     1264            // slack
     1265            int iSet = fromIndex_[number-model_->numberColumns()-
     1266                                  numberStaticRows_];
     1267            printf("what now - set %d\n",iSet);
    12211268          }
    12221269     }
     
    12421289          return 1;
    12431290     }
     1291#ifndef NDEBUG
     1292     {
     1293       int numberColumns = model->numberColumns();
     1294       int numberRows = model->numberRows();
     1295       int * pivotVariable = model->pivotVariable();
     1296       for (int i=numberStaticRows_+numberActiveSets_;i<numberRows;i++) {
     1297         assert (pivotVariable[i]==i+numberColumns);
     1298       }
     1299     }
     1300#endif
    12441301     // lookup array
    12451302     int * active = new int [numberActiveSets_];
     
    13021359               double value = solution[iColumn];
    13031360               bool toLowerBound = true;
     1361               assert (jColumn>=0);assert (iColumn>=0);
    13041362               if (columnUpper_) {
    13051363                    if (!columnLower_) {
    13061364                         if (fabs(value - columnUpper_[jColumn]) < fabs(value))
    13071365                              toLowerBound = false;
    1308                     } else if (fabs(value - columnUpper_[jColumn]) < fabs(value - columnLower_[iColumn])) {
     1366                    } else if (fabs(value - columnUpper_[jColumn]) < fabs(value - columnLower_[jColumn])) {
    13091367                         toLowerBound = false;
    13101368                    }
     
    14541512               }
    14551513          }
     1514          if (iPut<numberStaticRows_+numberActiveSets_) {
     1515            printf("lost %d sets\n",
     1516                   numberStaticRows_+numberActiveSets_-iPut);
     1517            iPut = numberStaticRows_+numberActiveSets_;
     1518          }
    14561519          for (i = numberActiveSets_; i < currentNumberActiveSets; i++) {
    14571520               pivotVariable[iPut++] = i + base3;
    14581521          }
    1459           assert (iPut == numberRows);
     1522          //assert (iPut == numberRows);
    14601523     }
    14611524#ifdef CLP_DEBUG
     
    15091572               n++;
    15101573          }
     1574          int k=0;
     1575          for (int j=startSet_[i];j<startSet_[i+1];j++) {
     1576            if (getDynamicStatus(j)==soloKey)
     1577              k++;
     1578          }
     1579          assert (k<2);
    15111580     }
    15121581     assert (n == numberSets_);
     
    15971666                    j = next_[j]; //onto next in set
    15981667               }
    1599           }
     1668#if 0
     1669               // slack must be feasible
     1670               double oldValue=value;
     1671               value = CoinMax(value,lowerSet_[iSet]);
     1672               value = CoinMin(value,upperSet_[iSet]);
     1673               if (value!=oldValue)
     1674                 printf("using %g (not %g) for slack on set %d (%g,%g)\n",
     1675                        value,oldValue,iSet,lowerSet_[iSet],upperSet_[iSet]);
     1676#endif
     1677            }
    16001678     }
    16011679     return value;
     
    16761754                    model->setStatus(iSequence, getStatus(savedBestSet_));
    16771755                    model->djRegion()[iSequence] = savedBestGubDual_;
    1678                     if (getStatus(savedBestSet_) == ClpSimplex::atUpperBound)
    1679                          solution[iSequence] = columnUpper[iSequence];
    1680                     else
    1681                          solution[iSequence] = columnLower[iSequence];
    1682                     // create variable and pivot in
     1756                    solution[iSequence] = valueOfKey;
     1757                    // create variable and pivot in
    16831758                    int key = keyVariable_[savedBestSet_];
    16841759                    setDynamicStatus(key, inSmall);
     
    17701845                    model->setStatus(iSequence, ClpSimplex::basic);
    17711846                    model->djRegion()[iSequence] = 0.0;
    1772                     solution[iSequence] = shift;
     1847                    solution[iSequence] = valueOfKey+shift;
    17731848                    rhsOffset_[newRow] = -shift; // sign?
    17741849               }
     
    18161891               //printf("best %d\n",bestSequence2);
    18171892               model->solutionRegion()[firstAvailable_] = 0.0;
     1893               model->clearFlagged(firstAvailable_);
    18181894               if (!columnLower_ && !columnUpper_) {
    18191895                    model->setStatus(firstAvailable_, ClpSimplex::atLowerBound);
     
    19452021                              double dj = cost[i] - dual;
    19462022                              double improvement = 0.0;
    1947                               double distance = 0.0;
    19482023                              if (iphase || i < numberInSet)
    19492024                                   assert (solution[i] >= lower[i] && solution[i] <= upper[i]);
     
    19572032                                   if (dj < 0.0) {
    19582033                                        way = 1;
    1959                                         distance = upper[i] - solution[i];
    19602034                                   } else {
    19612035                                        way = -1;
    1962                                         distance = solution[i] - lower[i];
    19632036                                   }
    19642037                              }
     
    21092182          int numberActive = 0;
    21102183          int whichKey = -1;
    2111           if (getStatus(iSet) == ClpSimplex::basic)
     2184          if (getStatus(iSet) == ClpSimplex::basic) {
    21122185               whichKey = maximumGubColumns_ + iSet;
    2113           else
     2186               numberActive = 1;
     2187          } else {
    21142188               whichKey = -1;
     2189          }
    21152190          int j = startSet_[iSet];
    21162191          while (j >= 0) {
    21172192               assert (getDynamicStatus(j) != soloKey || whichKey == -1);
    2118                if (getDynamicStatus(j) == inSmall)
     2193               if (getDynamicStatus(j) == inSmall) {
    21192194                    numberActive++;
    2120                else if (getDynamicStatus(j) == soloKey)
     2195               } else if (getDynamicStatus(j) == soloKey) {
    21212196                    whichKey = j;
     2197                    numberActive++;
     2198               }
    21222199               j = next_[j]; //onto next in set
    21232200          }
    2124           if (getStatus(iSet) == ClpSimplex::basic && numberActive)
    2125                numberActive++;
    2126           if (numberActive) {
    2127                assert (numberActive > 1);
     2201          if (numberActive > 1) {
    21282202               int iRow = numberActiveSets_ + numberStaticRows_;
    21292203               rowSolution[iRow] = 0.0;
     
    21892263                              else
    21902264                                   columnUpper[firstAvailable_] = COIN_DBL_MAX;
    2191                               if (status == atLowerBound) {
     2265                              if (status != atUpperBound) {
    21922266                                   solution[firstAvailable_] = columnLower[firstAvailable_];
    21932267                              } else {
     
    22032277               toIndex_[iSet] = numberActiveSets_;
    22042278               fromIndex_[numberActiveSets_++] = iSet;
     2279          } else {
     2280            // solo key
     2281            bool needKey=false;
     2282            if (numberActive) {
     2283              if (whichKey<maximumGubColumns_) {
     2284                // structural - assume ok
     2285                needKey = false;
     2286              } else {
     2287                // slack
     2288                keyVariable_[iSet] = maximumGubColumns_ + iSet;
     2289                double value = keyValue(iSet);
     2290                if (value<lowerSet_[iSet]-1.0e-8||
     2291                    value>upperSet_[iSet]+1.0e-8)
     2292                  needKey=true;
     2293              }
     2294            } else {
     2295              needKey = true;
     2296            }
     2297            if (needKey) {
     2298              // all to lb then up some (slack/null if possible)
     2299              int length=99999999;
     2300              int which=-1;
     2301              double sum=0.0;
     2302              for (int iColumn=startSet_[iSet];iColumn<startSet_[iSet+1];iColumn++) {
     2303                setDynamicStatus(iColumn,atLowerBound);
     2304                sum += columnLower_[iColumn];
     2305                if (length>startColumn_[iColumn+1]-startColumn_[iColumn]) {
     2306                  which=iColumn;
     2307                  length=startColumn_[iColumn+1]-startColumn_[iColumn];
     2308                }
     2309              }
     2310              if (sum>lowerSet_[iSet]-1.0e-8) {
     2311                // slack can be basic
     2312                setStatus(iSet,ClpSimplex::basic);
     2313                keyVariable_[iSet] = maximumGubColumns_ + iSet;
     2314              } else {
     2315                // use shortest
     2316                setDynamicStatus(which,soloKey);
     2317                keyVariable_[iSet] = which;
     2318                setStatus(iSet,ClpSimplex::atLowerBound);
     2319              }
     2320            }
    22052321          }
    22062322          assert (toIndex_[iSet] >= 0 || whichKey >= 0);
    22072323          keyVariable_[iSet] = whichKey;
    22082324     }
     2325     // clean up pivotVariable
     2326     int numberColumns = model_->numberColumns();
     2327     int numberRows = model_->numberRows();
     2328     int * pivotVariable = model_->pivotVariable();
     2329     if (pivotVariable) {
     2330       for (int i=0; i<numberStaticRows_+numberActiveSets_;i++) {
     2331         if (model_->getRowStatus(i)!=ClpSimplex::basic)
     2332           pivotVariable[i]=-1;
     2333         else
     2334           pivotVariable[i]=numberColumns+i;
     2335       }
     2336       for (int i=numberStaticRows_+numberActiveSets_;i<numberRows;i++) {
     2337         pivotVariable[i]=i+numberColumns;
     2338       }
     2339       int put=-1;
     2340       for (int i=0;i<numberColumns;i++) {
     2341         if (model_->getColumnStatus(i)==ClpSimplex::basic) {
     2342           while(put<numberRows) {
     2343             put++;
     2344             if (pivotVariable[put]==-1) {
     2345               pivotVariable[put]=i;
     2346               break;
     2347             }
     2348           }
     2349         }
     2350       }
     2351       for (int i=CoinMax(put,0);i<numberRows;i++) {
     2352         if (pivotVariable[i]==-1)
     2353           pivotVariable[i]=i+numberColumns;
     2354       }
     2355     }
     2356     if (rhsOffset_) {
     2357       double * cost = model_->costRegion();
     2358       double * columnLower = model_->lowerRegion();
     2359       double * columnUpper = model_->upperRegion();
     2360       double * solution = model_->solutionRegion();
     2361       int numberRows = model_->numberRows();
     2362       for (int i = numberActiveSets_; i < numberRows-numberStaticRows_; i++) {
     2363         int iSequence = i + numberStaticRows_ + numberColumns;
     2364         solution[iSequence] = 0.0;
     2365         columnLower[iSequence] = -COIN_DBL_MAX;
     2366         columnUpper[iSequence] = COIN_DBL_MAX;
     2367         cost[iSequence] = 0.0;
     2368         model_->nonLinearCost()->setOne(iSequence, solution[iSequence],
     2369                                        columnLower[iSequence],
     2370                                        columnUpper[iSequence], 0.0);
     2371         model_->setStatus(iSequence, ClpSimplex::basic);
     2372         rhsOffset_[i+numberStaticRows_] = 0.0;
     2373       }
     2374#if 0
     2375       for (int i=0;i<numberStaticRows_;i++)
     2376         printf("%d offset %g\n",
     2377                i,rhsOffset_[i]);
     2378#endif
     2379     }
     2380     numberActiveColumns_ = firstAvailable_;
     2381#if 0
     2382     for (iSet = 0; iSet < numberSets_; iSet++) {
     2383       for (int j=startSet_[iSet];j<startSet_[iSet+1];j++) {
     2384         if (getDynamicStatus(j)==soloKey)
     2385           printf("%d in set %d is solo key\n",j,iSet);
     2386         else if (getDynamicStatus(j)==inSmall)
     2387           printf("%d in set %d is in small\n",j,iSet);
     2388       }
     2389     }
     2390#endif
    22092391     return;
     2392}
     2393// Writes out model (without names)
     2394void
     2395ClpDynamicMatrix::writeMps(const char * name)
     2396{
     2397  int numberTotalRows = numberStaticRows_+numberSets_;
     2398  int numberTotalColumns = firstDynamic_+numberGubColumns_;
     2399  // over estimate
     2400  int numberElements = getNumElements()+startColumn_[numberGubColumns_]
     2401    + numberGubColumns_;
     2402  double * columnLower = new double [numberTotalColumns];
     2403  double * columnUpper = new double [numberTotalColumns];
     2404  double * cost = new double [numberTotalColumns];
     2405  double * rowLower = new double [numberTotalRows];
     2406  double * rowUpper = new double [numberTotalRows];
     2407  CoinBigIndex * start = new CoinBigIndex[numberTotalColumns+1];
     2408  int * row = new int [numberElements];
     2409  double * element = new double [numberElements];
     2410  // Fill in
     2411  const CoinBigIndex * startA = getVectorStarts();
     2412  const int * lengthA = getVectorLengths();
     2413  const int * rowA = getIndices();
     2414  const double * elementA = getElements();
     2415  const double * columnLowerA = model_->columnLower();
     2416  const double * columnUpperA = model_->columnUpper();
     2417  const double * costA = model_->objective();
     2418  const double * rowLowerA = model_->rowLower();
     2419  const double * rowUpperA = model_->rowUpper();
     2420  start[0]=0;
     2421  numberElements=0;
     2422  for (int i=0;i<firstDynamic_;i++) {
     2423    columnLower[i] = columnLowerA[i];
     2424    columnUpper[i] = columnUpperA[i];
     2425    cost[i] = costA[i];
     2426    for (CoinBigIndex j = startA[i];j<startA[i]+lengthA[i];j++) {
     2427      row[numberElements] = rowA[j];
     2428      element[numberElements++]=elementA[j];
     2429    }
     2430    start[i+1]=numberElements;
     2431  }
     2432  for (int i=0;i<numberStaticRows_;i++) {
     2433    rowLower[i] = rowLowerA[i];
     2434    rowUpper[i] = rowUpperA[i];
     2435  }
     2436  int putC=firstDynamic_;
     2437  int putR=numberStaticRows_;
     2438  for (int i=0;i<numberSets_;i++) {
     2439    rowLower[putR]=lowerSet_[i];
     2440    rowUpper[putR]=upperSet_[i];
     2441    for (CoinBigIndex k=startSet_[i];k<startSet_[i+1];k++) {
     2442      columnLower[putC]=columnLower_[k];
     2443      columnUpper[putC]=columnUpper_[k];
     2444      cost[putC]=cost_[k];
     2445      putC++;
     2446      for (CoinBigIndex j = startColumn_[k];j<startColumn_[k+1];j++) {
     2447        row[numberElements] = row_[j];
     2448        element[numberElements++]=element_[j];
     2449      }
     2450      row[numberElements] = putR;
     2451      element[numberElements++]=1.0;
     2452      start[putC]=numberElements;
     2453    }
     2454    putR++;
     2455  }
     2456
     2457  assert (putR==numberTotalRows);
     2458  assert (putC==numberTotalColumns);
     2459  ClpSimplex modelOut;
     2460  modelOut.loadProblem(numberTotalColumns,numberTotalRows,
     2461                       start,row,element,
     2462                       columnLower,columnUpper,cost,
     2463                       rowLower,rowUpper);
     2464  modelOut.writeMps(name);
     2465  delete [] columnLower;
     2466  delete [] columnUpper;
     2467  delete [] cost;
     2468  delete [] rowLower;
     2469  delete [] rowUpper;
     2470  delete [] start;
     2471  delete [] row;
     2472  delete [] element;
    22102473}
    22112474// Adds in a column to gub structure (called from descendant)
     
    22362499                    if (columnUpper_ && upper != columnUpper_[j])
    22372500                         odd = true;
    2238                     if (odd)
     2501                    if (odd) {
    22392502                         printf("seems odd - same els but cost,lo,up are %g,%g,%g and %g,%g,%g\n",
    22402503                                cost, lower, upper, cost_[j],
    22412504                                columnLower_ ? columnLower_[j] : 0.0,
    22422505                                columnUpper_ ? columnUpper_[j] : 1.0e100);
    2243                     else
     2506                    } else {
     2507                         setDynamicStatus(j, status);
    22442508                         return j;
     2509                    }
    22452510               }
    22462511          }
     
    22592524          for (i = 0; i < numberGubColumns_; i++) {
    22602525               CoinBigIndex end = startColumn_[i+1];
     2526               // what about ubs if column generation?
    22612527               if (getDynamicStatus(i) != atLowerBound) {
    22622528                    // keep in
  • stable/1.14/Clp/src/ClpDynamicMatrix.hpp

    r1665 r1753  
    9595     /// Does gub crash
    9696     void gubCrash();
     97     /// Writes out model (without names)
     98     void writeMps(const char * name);
    9799     /// Populates initial matrix from dynamic status
    98100     void initialProblem();
     
    166168          st_byte = static_cast<unsigned char>(st_byte | status);
    167169     }
     170     /// Whether flagged slack
     171     inline bool flaggedSlack(int i) const {
     172          return (status_[i] & 8) != 0;
     173     }
     174     inline void setFlaggedSlack(int i) {
     175          status_[i] = static_cast<unsigned char>(status_[i] | 8);
     176     }
     177     inline void unsetFlaggedSlack(int i) {
     178          status_[i] = static_cast<unsigned char>(status_[i] & ~8);
     179     }
    168180     /// Number of sets (dynamic rows)
    169181     inline int numberSets() const {
    170182          return numberSets_;
    171183     }
     184     /// Number of possible gub variables
     185     inline int numberGubEntries() const
     186     { return startSet_[numberSets_];}
     187     /// Sets
     188     inline int * startSets() const
     189     { return startSet_;}
    172190     /// Whether flagged
    173191     inline bool flagged(int i) const {
  • stable/1.14/Clp/src/ClpFactorization.cpp

    r1665 r1753  
    13991399     } else if (!coinFactorizationA_) {
    14001400          coinFactorizationA_ = new CoinFactorization();
     1401          goOslThreshold_ = -1;
     1402          goDenseThreshold_ = -1;
     1403          goSmallThreshold_ = -1;
    14011404     }
    14021405}
     
    28202823                                     double pivotValue)
    28212824{
     2825     double newValue;
    28222826     // better to have small tolerance even if slower
     2827     if (zeroValue > 0.0)
     2828          newValue = zeroValue;
     2829     else
     2830          newValue = -zeroTolerance() * zeroValue;
    28232831     zeroTolerance(CoinMin(zeroTolerance(), zeroValue));
    28242832     // better to have large tolerance even if slower
    2825      double newValue;
    28262833     if (pivotValue > 0.0)
    28272834          newValue = pivotValue;
  • stable/1.14/Clp/src/ClpGubDynamicMatrix.cpp

    r1665 r1753  
    12291229                                   double dj = cost[i] - dual;
    12301230                                   double improvement = 0.0;
    1231                                    double distance = 0.0;
    12321231                                   if (iphase || i < numberInSet)
    12331232                                        assert (solution[i] >= lower[i] && solution[i] <= upper[i]);
     
    12411240                                        if (dj < 0.0) {
    12421241                                             way = 1;
    1243                                              distance = upper[i] - solution[i];
    12441242                                        } else {
    12451243                                             way = -1;
    1246                                              distance = solution[i] - lower[i];
    12471244                                        }
    12481245                                   }
  • stable/1.14/Clp/src/ClpGubMatrix.cpp

    r1665 r1753  
    32103210                                        double dj = cost[i] - dual;
    32113211                                        double improvement = 0.0;
    3212                                         double distance = 0.0;
    32133212                                        if (iphase || i < numberInSet)
    32143213                                             assert (solution[i] >= lower[i] && solution[i] <= upper[i]);
     
    32223221                                             if (dj < 0.0) {
    32233222                                                  way = 1;
    3224                                                   distance = upper[i] - solution[i];
    32253223                                             } else {
    32263224                                                  way = -1;
    3227                                                   distance = solution[i] - lower[i];
    32283225                                             }
    32293226                                        }
  • stable/1.14/Clp/src/ClpHelperFunctions.cpp

    r1665 r1753  
    1515#include <cmath>
    1616#include "CoinHelperFunctions.hpp"
    17 #include "CoinFinite.hpp"
     17#include "CoinTypes.hpp"
     18
    1819double
    1920maximumAbsElement(const double * region, int size)
  • stable/1.14/Clp/src/ClpHelperFunctions.hpp

    r1665 r1753  
    66#ifndef ClpHelperFunctions_H
    77#define ClpHelperFunctions_H
     8
     9#include "ClpConfig.h"
     10#ifdef HAVE_CMATH
     11# include <cmath>
     12#else
     13# ifdef HAVE_MATH_H
     14#  include <math.h>
     15# else
     16#  error "don't have header file for math"
     17# endif
     18#endif
    819
    920/**
  • stable/1.14/Clp/src/ClpMain.cpp

    r1665 r1753  
    2525#include "CoinMpsIO.hpp"
    2626#include "CoinFileIO.hpp"
     27#ifdef COIN_HAS_GLPK
     28#include "glpk.h"
     29extern glp_tran* cbc_glp_tran;
     30extern glp_prob* cbc_glp_prob;
     31#else
     32#define GLP_UNDEF 1
     33#define GLP_FEAS 2
     34#define GLP_INFEAS 3
     35#define GLP_NOFEAS 4
     36#define GLP_OPT 5
     37#endif
    2738
    2839#include "ClpFactorization.hpp"
     
    4556#include "dmalloc.h"
    4657#endif
    47 #ifdef WSSMP_BARRIER
    48 #define FOREIGN_BARRIER
    49 #endif
    50 #ifdef UFL_BARRIER
    51 #define FOREIGN_BARRIER
    52 #endif
    53 #ifdef TAUCS_BARRIER
    54 #define FOREIGN_BARRIER
    55 #endif
    56 #ifdef MUMPS_BARRIER
     58#if defined(COIN_HAS_WSMP) || defined(COIN_HAS_AMD) || defined(COIN_HAS_CHOLMOD) || defined(TAUCS_BARRIER) || defined(COIN_HAS_MUMPS)
    5759#define FOREIGN_BARRIER
    5860#endif
     
    284286               int numberQuery = 0;
    285287               if (field != "?" && field != "???") {
    286                     int length = field.length();
    287                     int i;
     288                    size_t length = field.length();
     289                    size_t i;
    288290                    for (i = length - 1; i > 0; i--) {
    289291                         if (field[i] == '?')
     
    647649                                   ClpSolve::PresolveType presolveType;
    648650                                   ClpSimplex * model2 = models + iModel;
     651                                   ClpSolve solveOptions;
     652                                   if (dualize==4) {
     653                                     solveOptions.setSpecialOption(4, 77);
     654                                     dualize=0;
     655                                   }
    649656                                   if (dualize) {
    650657                                        bool tryIt = true;
     
    671678                                                  model2 = models + iModel;
    672679                                                  dualize = 0;
    673                                              }
     680                                             }
    674681                                        } else {
    675682                                             dualize = 0;
    676683                                        }
    677684                                   }
    678                                    ClpSolve solveOptions;
     685                                   if (preSolveFile)
     686                                        presolveOptions |= 0x40000000;
    679687                                   solveOptions.setPresolveActions(presolveOptions);
    680688                                   solveOptions.setSubstitution(substitution);
     
    722730                                   }
    723731                                   solveOptions.setSolveType(method);
    724                                    if (preSolveFile)
    725                                         presolveOptions |= 0x40000000;
    726                                    solveOptions.setSpecialOption(4, presolveOptions);
    727732                                   solveOptions.setSpecialOption(5, printOptions & 1);
    728733                                   if (doVector) {
     
    944949                                   {
    945950                                        const char * c_name = field.c_str();
    946                                         int length = strlen(c_name);
     951                                        size_t length = strlen(c_name);
    947952                                        if (length > 3 && !strncmp(c_name + length - 3, ".lp", 3))
    948953                                             gmpl = -1; // .lp
     
    961966                                   if (absolutePath) {
    962967                                        fileName = field;
     968                                        size_t length = field.size();
     969                                        size_t percent = field.find('%');
     970                                        if (percent < length && percent > 0) {
     971                                             gmpl = 1;
     972                                             fileName = field.substr(0, percent);
     973                                             gmplData = field.substr(percent + 1);
     974                                             if (percent < length - 1)
     975                                                  gmpl = 2; // two files
     976                                             printf("GMPL model file %s and data file %s\n",
     977                                                    fileName.c_str(), gmplData.c_str());
     978                                        }
    963979                                   } else if (field[0] == '~') {
    964980                                        char * environVar = getenv("HOME");
     
    973989                                        fileName = directory + field;
    974990                                        // See if gmpl (model & data) - or even lp file
    975                                         int length = field.size();
    976                                         int percent = field.find('%');
     991                                        size_t length = field.size();
     992                                        size_t percent = field.find('%');
    977993                                        if (percent < length && percent > 0) {
    978994                                             gmpl = 1;
     
    10141030                                                                         keepImportNames != 0);
    10151031                                   else
    1016                                         status = models[iModel].readLp(fileName.c_str(), 1.0e-12);
     1032#ifdef KILL_ZERO_READLP
     1033                                     status = models[iModel].readLp(fileName.c_str(), models[iModel].getSmallElementValue());
     1034#else
     1035                                     status = models[iModel].readLp(fileName.c_str(), 1.0e-12);
     1036#endif
    10171037                                   if (!status || (status > 0 && allowImportErrors)) {
    10181038                                        goodModels[iModel] = true;
     
    15321552                              std::string name = CoinReadGetString(argc, argv);
    15331553                              if (name != "EOL") {
    1534                                    int length = name.length();
    1535                                    if (name[length-1] == dirsep) {
     1554                                   size_t length = name.length();
     1555                                   if (length > 0 && name[length-1] == dirsep) {
    15361556                                        directory = name;
    15371557                                   } else {
     
    15471567                              std::string name = CoinReadGetString(argc, argv);
    15481568                              if (name != "EOL") {
    1549                                    int length = name.length();
    1550                                    if (name[length-1] == dirsep) {
     1569                                   size_t length = name.length();
     1570                                   if (length > 0 && name[length-1] == dirsep) {
    15511571                                        dirSample = name;
    15521572                                   } else {
     
    15621582                              std::string name = CoinReadGetString(argc, argv);
    15631583                              if (name != "EOL") {
    1564                                    int length = name.length();
    1565                                    if (name[length-1] == dirsep) {
     1584                                   size_t length = name.length();
     1585                                   if (length > 0 && name[length-1] == dirsep) {
    15661586                                        dirNetlib = name;
    15671587                                   } else {
     
    15771597                              std::string name = CoinReadGetString(argc, argv);
    15781598                              if (name != "EOL") {
    1579                                    int length = name.length();
    1580                                    if (name[length-1] == dirsep) {
     1599                                   size_t length = name.length();
     1600                                   if (length > 0 && name[length-1] == dirsep) {
    15811601                                        dirMiplib = name;
    15821602                                   } else {
     
    17561776                              break;
    17571777                         case CLP_PARAM_ACTION_SOLUTION:
     1778                         case CLP_PARAM_ACTION_GMPL_SOLUTION:
    17581779                              if (goodModels[iModel]) {
    17591780                                   // get next field
     
    18031824                                   }
    18041825                                   if (fp) {
     1826                                     // See if Glpk
     1827                                     if (type == CLP_PARAM_ACTION_GMPL_SOLUTION) {
     1828                                       int numberRows = models[iModel].getNumRows();
     1829                                       int numberColumns = models[iModel].getNumCols();
     1830                                       int numberGlpkRows=numberRows+1;
     1831#ifdef COIN_HAS_GLPK
     1832                                       if (cbc_glp_prob) {
     1833                                         // from gmpl
     1834                                         numberGlpkRows=glp_get_num_rows(cbc_glp_prob);
     1835                                         if (numberGlpkRows!=numberRows)
     1836                                           printf("Mismatch - cbc %d rows, glpk %d\n",
     1837                                                  numberRows,numberGlpkRows);
     1838                                       }
     1839#endif
     1840                                       fprintf(fp,"%d %d\n",numberGlpkRows,
     1841                                               numberColumns);
     1842                                       int iStat = models[iModel].status();
     1843                                       int iStat2 = GLP_UNDEF;
     1844                                       if (iStat == 0) {
     1845                                         // optimal
     1846                                         iStat2 = GLP_FEAS;
     1847                                       } else if (iStat == 1) {
     1848                                         // infeasible
     1849                                         iStat2 = GLP_NOFEAS;
     1850                                       } else if (iStat == 2) {
     1851                                         // unbounded
     1852                                         // leave as 1
     1853                                       } else if (iStat >= 3 && iStat <= 5) {
     1854                                         iStat2 = GLP_FEAS;
     1855                                       }
     1856                                       double objValue = models[iModel].getObjValue()
     1857                                         * models[iModel].getObjSense();
     1858                                       fprintf(fp,"%d 2 %g\n",iStat2,objValue);
     1859                                       if (numberGlpkRows > numberRows) {
     1860                                         // objective as row
     1861                                         fprintf(fp,"4 %g 1.0\n",objValue);
     1862                                       }
     1863                                       int lookup[6]=
     1864                                         {4,1,3,2,4,5};
     1865                                       const double * primalRowSolution =
     1866                                         models[iModel].primalRowSolution();
     1867                                       const double * dualRowSolution =
     1868                                         models[iModel].dualRowSolution();
     1869                                       for (int i=0;i<numberRows;i++) {
     1870                                         fprintf(fp,"%d %g %g\n",lookup[models[iModel].getRowStatus(i)],
     1871                                                 primalRowSolution[i],dualRowSolution[i]);
     1872                                       }
     1873                                       const double * primalColumnSolution =
     1874                                         models[iModel].primalColumnSolution();
     1875                                       const double * dualColumnSolution =
     1876                                         models[iModel].dualColumnSolution();
     1877                                       for (int i=0;i<numberColumns;i++) {
     1878                                         fprintf(fp,"%d %g %g\n",lookup[models[iModel].getColumnStatus(i)],
     1879                                                 primalColumnSolution[i],dualColumnSolution[i]);
     1880                                       }
     1881                                       fclose(fp);
     1882#ifdef COIN_HAS_GLPK
     1883                                       if (cbc_glp_prob) {
     1884                                         glp_read_sol(cbc_glp_prob,fileName.c_str());
     1885                                         glp_mpl_postsolve(cbc_glp_tran,
     1886                                                           cbc_glp_prob,
     1887                                                           GLP_SOL);
     1888                                         // free up as much as possible
     1889                                         glp_free(cbc_glp_prob);
     1890                                         glp_mpl_free_wksp(cbc_glp_tran);
     1891                                         cbc_glp_prob = NULL;
     1892                                         cbc_glp_tran = NULL;
     1893                                         //gmp_free_mem();
     1894                                         /* check that no memory blocks are still allocated */
     1895                                         glp_free_env();
     1896                                       }
     1897#endif
     1898                                       break;
     1899                                     }
    18051900                                        // Write solution header (suggested by Luigi Poderico)
    18061901                                        double objValue = models[iModel].getObjValue() * models[iModel].getObjSense();
     
    18501945                                             const char * pMask2 = printMask.c_str();
    18511946                                             char pMask[100];
    1852                                              int iChar;
    1853                                              int lengthMask = strlen(pMask2);
     1947                                             size_t lengthMask = strlen(pMask2);
    18541948                                             assert (lengthMask < 100);
    18551949                                             if (*pMask2 == '"') {
     
    18721966                                                  strcpy(pMask, pMask2);
    18731967                                             }
    1874                                              if (lengthMask > lengthName) {
     1968                                             if (lengthMask > static_cast<size_t>(lengthName)) {
    18751969                                                  printf("mask %s too long - skipping\n", pMask);
    18761970                                                  break;
    18771971                                             }
    18781972                                             maxMasks = 1;
    1879                                              for (iChar = 0; iChar < lengthMask; iChar++) {
     1973                                             for (size_t iChar = 0; iChar < lengthMask; iChar++) {
    18801974                                                  if (pMask[iChar] == '*') {
    18811975                                                       nAst++;
     
    19001994                                                       char * ast = strchr(oldMask, '*');
    19011995                                                       assert (ast);
    1902                                                        int length = strlen(oldMask) - 1;
    1903                                                        int nBefore = ast - oldMask;
    1904                                                        int nAfter = length - nBefore;
     1996                                                       size_t length = strlen(oldMask) - 1;
     1997                                                       size_t nBefore = ast - oldMask;
     1998                                                       size_t nAfter = length - nBefore;
    19051999                                                       // and add null
    19062000                                                       nAfter++;
    1907                                                        for (int i = 0; i <= lengthName - length; i++) {
     2001                                                       for (size_t i = 0; i <= lengthName - length; i++) {
    19082002                                                            char * maskOut = newMasks[nEntries];
    1909                                                             CoinMemcpyN(oldMask, nBefore, maskOut);
    1910                                                             for (int k = 0; k < i; k++)
     2003                                                            CoinMemcpyN(oldMask, static_cast<int>(nBefore), maskOut);
     2004                                                            for (size_t k = 0; k < i; k++)
    19112005                                                                 maskOut[k+nBefore] = '?';
    1912                                                             CoinMemcpyN(ast + 1, nAfter, maskOut + nBefore + i);
     2006                                                            CoinMemcpyN(ast + 1, static_cast<int>(nAfter), maskOut + nBefore + i);
    19132007                                                            nEntries++;
    19142008                                                            assert (nEntries <= maxMasks);
     
    19232017                                             for (i = 0; i < nEntries; i++) {
    19242018                                                  char * maskThis = masks[i];
    1925                                                   int length = strlen(maskThis);
    1926                                                   while (maskThis[length-1] == ' ')
     2019                                                  size_t length = strlen(maskThis);
     2020                                                  while (length > 0 && maskThis[length-1] == ' ')
    19272021                                                       length--;
    19282022                                                  maskThis[length] = '\0';
    1929                                                   sort[i] = length;
     2023                                                  sort[i] = static_cast<int>(length);
    19302024                                             }
    19312025                                             CoinSort_2(sort, sort + nEntries, masks);
     
    20992193                                                       if (lengthName) {
    21002194                                                            const char * name = rowNames[iRow].c_str();
    2101                                                             int n = strlen(name);
    2102                                                             int i;
     2195                                                            size_t n = strlen(name);
     2196                                                            size_t i;
    21032197                                                            for (i = 0; i < n; i++)
    21042198                                                                 fprintf(fp, "%c", name[i]);
    2105                                                             for (; i < lengthPrint; i++)
     2199                                                            for (; i < static_cast<size_t>(lengthPrint); i++)
    21062200                                                                 fprintf(fp, " ");
    21072201                                                       }
     
    21372231                                                  if (lengthName) {
    21382232                                                       const char * name = columnNames[iColumn].c_str();
    2139                                                        int n = strlen(name);
    2140                                                        int i;
     2233                                                       size_t n = strlen(name);
     2234                                                       size_t i;
    21412235                                                       for (i = 0; i < n; i++)
    21422236                                                            fprintf(fp, "%c", name[i]);
    2143                                                        for (; i < lengthPrint; i++)
     2237                                                       for (; i < static_cast<size_t>(lengthPrint); i++)
    21442238                                                            fprintf(fp, " ");
    21452239                                                  }
     
    22392333          delete [] goodModels;
    22402334     }
     2335#ifdef COIN_HAS_GLPK
     2336     if (cbc_glp_prob) {
     2337       // free up as much as possible
     2338       glp_free(cbc_glp_prob);
     2339       glp_mpl_free_wksp(cbc_glp_tran);
     2340       glp_free_env();
     2341       cbc_glp_prob = NULL;
     2342       cbc_glp_tran = NULL;
     2343     }
     2344#endif
    22412345     // By now all memory should be freed
    22422346#ifdef DMALLOC
     
    24962600     if ((k % 3) != 0)
    24972601          printf("\n");
    2498 #define SYM
     2602     //#define SYM
    24992603#ifndef SYM
    25002604     if (model->logLevel() < 2)
     
    31853289     // back to char as I am old fashioned
    31863290     const char * checkC = check.c_str();
    3187      int length = strlen(checkC);
     3291     size_t length = strlen(checkC);
    31883292     while (checkC[length-1] == ' ')
    31893293          length--;
    31903294     for (int i = starts[length]; i < starts[length+1]; i++) {
    31913295          char * thisMask = masks[i];
    3192           int k;
     3296          size_t k;
    31933297          for ( k = 0; k < length; k++) {
    31943298               if (thisMask[k] != '?' && thisMask[k] != checkC[k])
  • stable/1.14/Clp/src/ClpMatrixBase.hpp

    r1665 r1753  
    88
    99#include "CoinPragma.hpp"
    10 #include "CoinFinite.hpp"
     10#include "CoinTypes.hpp"
    1111
    1212#include "CoinPackedMatrix.hpp"
  • stable/1.14/Clp/src/ClpMessage.cpp

    r1665 r1753  
    103103     {CLP_PARAMETRICS_STATS, 62, 1, "Theta %g - objective %g"},
    104104     {CLP_PARAMETRICS_STATS2, 63, 2, "Theta %g - objective %g, %s in, %s out"},
     105#ifndef NO_FATHOM_PRINT
     106     {CLP_FATHOM_STATUS, 63, 2, "Fathoming node %d - %d nodes (%d iterations) - current depth %d"},
     107     {CLP_FATHOM_SOLUTION, 64, 1, "Fathoming node %d - solution of %g after %d nodes at depth %d"},
     108     {CLP_FATHOM_FINISH, 65, 1, "Fathoming node %d (depth %d) took %d nodes (%d iterations) - maximum depth %d"},
     109#endif
    105110     {CLP_GENERAL, 1000, 1, "%s"},
     111     {CLP_GENERAL2, 1001, 2, "%s"},
    106112     {CLP_DUMMY_END, 999999, 0, ""}
    107113};
  • stable/1.14/Clp/src/ClpMessage.hpp

    r1665 r1753  
    105105     CLP_PARAMETRICS_STATS2,
    106106     CLP_GENERAL,
     107     CLP_GENERAL2,
     108#ifndef NO_FATHOM_PRINT
     109     CLP_FATHOM_STATUS,
     110     CLP_FATHOM_SOLUTION,
     111     CLP_FATHOM_FINISH,
     112#endif
    107113     CLP_DUMMY_END
    108114};
  • stable/1.14/Clp/src/ClpModel.cpp

    r1665 r1753  
    10211021     columnUpper_ = NULL;
    10221022     matrix_ = NULL;
     1023     if (rowCopy_ != otherModel.rowCopy_)
     1024       delete rowCopy_;
    10231025     rowCopy_ = NULL;
    10241026     delete scaledMatrix_;
     
    13941396     if (maximumRows_ >= 0) {
    13951397          if (numberRows_ > maximumRows_)
    1396                printf("resize %d rows, %d old maximum rows\n",
    1397                       numberRows_, maximumRows_);
     1398               COIN_DETAIL_PRINT(printf("resize %d rows, %d old maximum rows\n",
     1399                                        numberRows_, maximumRows_));
    13981400          maximumRows_ = CoinMax(maximumRows_, numberRows_);
    13991401          maximumColumns_ = CoinMax(maximumColumns_, numberColumns_);
     
    14991501     rowScale_ = NULL;
    15001502     columnScale_ = NULL;
     1503     delete scaledMatrix_;
     1504     scaledMatrix_ = NULL;
    15011505}
    15021506// Deletes columns
     
    32883292     }
    32893293#endif
    3290      int size = rowNames_.size();
     3294     int size = static_cast<int>(rowNames_.size());
    32913295     if (size > iRow) {
    32923296          return rowNames_[iRow];
     
    33083312#endif
    33093313     unsigned int maxLength = lengthNames_;
    3310      int size = rowNames_.size();
     3314     int size = static_cast<int>(rowNames_.size());
    33113315     if (size <= iRow)
    33123316          rowNames_.resize(iRow + 1);
     
    33253329     }
    33263330#endif
    3327      int size = columnNames_.size();
     3331     int size = static_cast<int>(columnNames_.size());
    33283332     if (size > iColumn) {
    33293333          return columnNames_[iColumn];
     
    33453349#endif
    33463350     unsigned int maxLength = lengthNames_;
    3347      int size = columnNames_.size();
     3351     int size = static_cast<int>(columnNames_.size());
    33483352     if (size <= iColumn)
    33493353          columnNames_.resize(iColumn + 1);
     
    33583362{
    33593363     unsigned int maxLength = lengthNames_;
    3360      int size = rowNames_.size();
     3364     int size = static_cast<int>(rowNames_.size());
    33613365     if (size != numberRows_)
    33623366          rowNames_.resize(numberRows_);
     
    33743378{
    33753379     unsigned int maxLength = lengthNames_;
    3376      int size = columnNames_.size();
     3380     int size = static_cast<int>(columnNames_.size());
    33773381     if (size != numberColumns_)
    33783382          columnNames_.resize(numberColumns_);
     
    33903394{
    33913395     unsigned int maxLength = lengthNames_;
    3392      int size = rowNames_.size();
     3396     int size = static_cast<int>(rowNames_.size());
    33933397     if (size != numberRows_)
    33943398          rowNames_.resize(numberRows_);
     
    34133417{
    34143418     unsigned int maxLength = lengthNames_;
    3415      int size = columnNames_.size();
     3419     int size = static_cast<int>(columnNames_.size());
    34163420     if (size != numberColumns_)
    34173421          columnNames_.resize(numberColumns_);
     
    36483652     if (lengthNames()) {
    36493653          rowNames = new char * [numberRows_+1];
    3650           int numberNames = rowNames_.size();
     3654          int numberNames = static_cast<int>(rowNames_.size());
    36513655          numberNames = CoinMin(numberRows_, numberNames);
    36523656          int iRow;
     
    36883692     if (lengthNames()) {
    36893693          columnNames = new char * [numberColumns_];
    3690           int numberNames = columnNames_.size();
     3694          int numberNames = static_cast<int>(columnNames_.size());
    36913695          numberNames = CoinMin(numberColumns_, numberNames);
    36923696          int iColumn;
     
    37433747{
    37443748     // If mode changes then we treat as new matrix (need new row copy)
    3745      if (mode != scalingFlag_)
     3749     if (mode != scalingFlag_) {
    37463750          whatsChanged_ &= ~(2 + 4 + 8);
     3751          // Get rid of scaled matrix
     3752          setClpScaledMatrix(NULL);
     3753     }
    37473754     if (mode > 0 && mode < 6) {
    37483755          scalingFlag_ = mode;
     
    38823889          char temp[30];
    38833890          strcpy(temp, rowName(i).c_str());
    3884           int length = strlen(temp);
    3885           for (int j = 0; j < length; j++) {
     3891          size_t length = strlen(temp);
     3892          for (size_t j = 0; j < length; j++) {
    38863893               if (temp[j] == '-')
    38873894                    temp[j] = '_';
     
    38923899          char temp[30];
    38933900          strcpy(temp, columnName(i).c_str());
    3894           int length = strlen(temp);
    3895           for (int j = 0; j < length; j++) {
     3901          size_t length = strlen(temp);
     3902          for (size_t j = 0; j < length; j++) {
    38963903               if (temp[j] == '-')
    38973904                    temp[j] = '_';
     
    39483955ClpModel::startPermanentArrays()
    39493956{
    3950      printf("startperm a %d rows, %d maximum rows\n",
    3951             numberRows_, maximumRows_);
     3957     COIN_DETAIL_PRINT(printf("startperm a %d rows, %d maximum rows\n",
     3958                              numberRows_, maximumRows_));
    39523959     if ((specialOptions_ & 65536) != 0) {
    39533960          if (numberRows_ > maximumRows_ || numberColumns_ > maximumColumns_) {
     
    39663973               // need to make sure numberRows_ OK and size of matrices
    39673974               resize(maximumRows_, maximumColumns_);
    3968                printf("startperm b %d rows, %d maximum rows\n",
    3969                       numberRows_, maximumRows_);
     3975               COIN_DETAIL_PRINT(printf("startperm b %d rows, %d maximum rows\n",
     3976                                        numberRows_, maximumRows_));
    39703977          } else {
    39713978               return;
     
    39803987          baseRowCopy_.setExtraMajor(0.0);
    39813988          baseRowCopy_.reverseOrderedCopyOf(baseMatrix_);
    3982           printf("startperm c %d rows, %d maximum rows\n",
    3983                  numberRows_, maximumRows_);
     3989          COIN_DETAIL_PRINT(printf("startperm c %d rows, %d maximum rows\n",
     3990                                   numberRows_, maximumRows_));
    39843991     }
    39853992}
  • stable/1.14/Clp/src/ClpModel.hpp

    r1665 r1753  
    2020#include "CoinMessageHandler.hpp"
    2121#include "CoinHelperFunctions.hpp"
     22#include "CoinTypes.hpp"
    2223#include "CoinFinite.hpp"
    2324#include "ClpParameters.hpp"
  • stable/1.14/Clp/src/ClpNetworkBasis.cpp

    r1665 r1753  
    8585     // it pivots on row permuteBack[0]
    8686     // a known root is given by permuteBack[numberRows_-1]
    87      int lastPivot = numberRows_;
    8887     for (i = 0; i < numberRows_; i++) {
    8988          int iPivot = permuteBack[i];
    90           lastPivot = iPivot;
    9189          double sign;
    9290          if (pivotRegion[i] > 0.0)
     
    117115     }
    118116     // do depth
    119      int iPivot = numberRows_;
    120117     int nStack = 1;
    121118     stack_[0] = descendant_[numberRows_];
     
    126123          if (iNext >= 0) {
    127124               depth_[iNext] = nStack;
    128                iPivot = iNext;
    129125               int iRight = rightSibling_[iNext];
    130126               stack_[nStack++] = iRight;
     
    344340{
    345341     // check depth
    346      int iPivot = numberRows_;
    347342     int nStack = 1;
    348343     stack_[0] = descendant_[numberRows_];
     
    354349               //assert (depth_[iNext]==nStack);
    355350               depth_[iNext] = nStack;
    356                iPivot = iNext;
    357351               int iRight = rightSibling_[iNext];
    358352               stack_[nStack++] = iRight;
  • stable/1.14/Clp/src/ClpNetworkBasis.hpp

    r1665 r1753  
    1515class CoinIndexedVector;
    1616class ClpSimplex;
    17 #include "CoinFinite.hpp"
     17#include "CoinTypes.hpp"
    1818#ifndef COIN_FAST_CODE
    1919#define COIN_FAST_CODE
  • stable/1.14/Clp/src/ClpNode.cpp

    r1665 r1753  
    267267     double smallChange = stuff->smallChange_;
    268268#endif
     269#ifndef INFEAS_MULTIPLIER
     270#define INFEAS_MULTIPLIER 1.0
     271#endif
    269272     for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    270273          if (integerType[iColumn]) {
     
    310313                    // Extra for infeasible branches
    311314                    if (nUp) {
    312                          double ratio = 1.0 + static_cast<double>(numberUpInfeasible[iInteger]) /
     315                         double ratio = 1.0 + INFEAS_MULTIPLIER*static_cast<double>(numberUpInfeasible[iInteger]) /
    313316                                        static_cast<double>(nUp);
    314317                         upValue2 *= ratio;
     
    317320                    double downValue2 = (downPseudo[iInteger] / (1.0 + nDown));
    318321                    if (nDown) {
    319                          double ratio = 1.0 + static_cast<double>(numberDownInfeasible[iInteger]) /
     322                         double ratio = 1.0 + INFEAS_MULTIPLIER*static_cast<double>(numberDownInfeasible[iInteger]) /
    320323                                        static_cast<double>(nDown);
    321324                         downValue2 *= ratio;
     
    354357                                     (1.0 + nUp));
    355358                    if (nUp) {
    356                          double ratio = 1.0 + static_cast<double>(numberUpInfeasible[iInteger]) /
     359                         double ratio = 1.0 + INFEAS_MULTIPLIER*static_cast<double>(numberUpInfeasible[iInteger]) /
    357360                                        static_cast<double>(nUp);
    358361                         upValue *= ratio;
     
    361364                                       (1.0 + nDown));
    362365                    if (nDown) {
    363                          double ratio = 1.0 + static_cast<double>(numberDownInfeasible[iInteger]) /
     366                         double ratio = 1.0 + INFEAS_MULTIPLIER*static_cast<double>(numberDownInfeasible[iInteger]) /
    364367                                        static_cast<double>(nDown);
    365368                         downValue *= ratio;
     
    711714     whichRow_(NULL),
    712715     whichColumn_(NULL),
     716#ifndef NO_FATHOM_PRINT
     717     handler_(NULL),
     718#endif
    713719     nBound_(0),
    714720     saveOptions_(0),
     
    722728     numberIterations_(0),
    723729     presolveType_(0)
     730#ifndef NO_FATHOM_PRINT
     731     ,startingDepth_(-1),
     732     nodeCalled_(-1)
     733#endif
    724734{
    725735
     
    745755       whichRow_(NULL),
    746756       whichColumn_(NULL),
     757#ifndef NO_FATHOM_PRINT
     758       handler_(rhs.handler_),
     759#endif
    747760       nBound_(0),
    748761       saveOptions_(rhs.saveOptions_),
     
    756769       numberIterations_(rhs.numberIterations_),
    757770       presolveType_(rhs.presolveType_)
     771#ifndef NO_FATHOM_PRINT
     772     ,startingDepth_(rhs.startingDepth_),
     773       nodeCalled_(rhs.nodeCalled_)
     774#endif
    758775{
    759776}
     
    798815          numberIterations_ = rhs.numberIterations_;
    799816          presolveType_ = rhs.presolveType_;
     817#ifndef NO_FATHOM_PRINT
     818          handler_ = rhs.handler_;
     819          startingDepth_ = rhs.startingDepth_;
     820          nodeCalled_ = rhs.nodeCalled_;
     821#endif
    800822     }
    801823     return *this;
  • stable/1.14/Clp/src/ClpNode.hpp

    r1665 r1753  
    219219     /// Integer increment
    220220     double integerIncrement_;
    221      /// Small chnage in branch
     221     /// Small change in branch
    222222     double smallChange_;
    223223     /// Down pseudo costs
     
    245245     /// Which columns in large model
    246246     int * whichColumn_;
     247#ifndef NO_FATHOM_PRINT
     248     /// Cbc's message handler
     249     CoinMessageHandler * handler_;
     250#endif
    247251     /// Number bounds in large model
    248252     int nBound_;
     
    274278     /// Type of presolve - 0 none, 1 crunch
    275279     int presolveType_;
     280#ifndef NO_FATHOM_PRINT
     281     /// Depth passed in
     282     int startingDepth_;
     283     /// Node at which called
     284     int nodeCalled_;
     285#endif
    276286     //@}
    277287};
  • stable/1.14/Clp/src/ClpNonLinearCost.cpp

    r1665 r1753  
    9191          }
    9292     }
    93      if (allZero)
     93     if (allZero&&model_->clpMatrix()->type()<15)
    9494          model_->setInfeasibilityCost(1.0);
    9595     double infeasibilityCost = model_->infeasibilityCost();
     
    274274
    275275     double whichWay = model_->optimizationDirection();
    276      printf("Direction %g\n", whichWay);
     276     COIN_DETAIL_PRINT(printf("Direction %g\n", whichWay));
    277277
    278278     numberInfeasibilities_ = 0;
     
    608608                    }
    609609               }
     610               //#define PRINT_DETAIL7 2
     611#if PRINT_DETAIL7>1
     612               printf("NL %d sol %g bounds %g %g\n",
     613                      iSequence,solution[iSequence],
     614                      lowerValue,upperValue);
     615#endif
    610616               switch(status) {
    611617
     
    625631                                        printf("nonlincostb %d %g %g %g\n",
    626632                                               iSequence, lowerValue, solution[iSequence], lower_[iRange+2]);
     633#endif
     634#if PRINT_DETAIL7
     635                                   printf("**NL %d sol %g below %g\n",
     636                                          iSequence,solution[iSequence],
     637                                          lowerValue);
    627638#endif
    628639                                   sumInfeasibilities_ += value;
     
    642653                                        printf("nonlincostu %d %g %g %g\n",
    643654                                               iSequence, lower_[iRange-1], solution[iSequence], upperValue);
     655#endif
     656#if PRINT_DETAIL7
     657                                   printf("**NL %d sol %g above %g\n",
     658                                          iSequence,solution[iSequence],
     659                                          upperValue);
    644660#endif
    645661                                   sumInfeasibilities_ += value;
  • stable/1.14/Clp/src/ClpPackedMatrix.cpp

    r1665 r1753  
    2424#ifdef INTEL_MKL
    2525#include "mkl_spblas.h"
     26#endif
     27
     28//=============================================================================
     29#ifdef COIN_PREFETCH
     30#if 1
     31#define coin_prefetch(mem) \
     32         __asm__ __volatile__ ("prefetchnta %0" : : "m" (*(reinterpret_cast<char *>(mem))))
     33#define coin_prefetch_const(mem) \
     34         __asm__ __volatile__ ("prefetchnta %0" : : "m" (*(reinterpret_cast<const char *>(mem))))
     35#else
     36#define coin_prefetch(mem) \
     37         __asm__ __volatile__ ("prefetch %0" : : "m" (*(reinterpret_cast<char *>(mem))))
     38#define coin_prefetch_const(mem) \
     39         __asm__ __volatile__ ("prefetch %0" : : "m" (*(reinterpret_cast<const char *>(mem))))
     40#endif
     41#else
     42// dummy
     43#define coin_prefetch(mem)
     44#define coin_prefetch_const(mem)
    2645#endif
    2746
     
    32643283     int * columnLength = matrix_->getMutableVectorLengths();
    32653284     double * elementByColumn = matrix_->getMutableElements();
    3266      bool deletedElements = false;
     3285     int deletedElements = 0;
    32673286     for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    32683287          CoinBigIndex j;
     
    33013320          usefulColumn[iColumn] = useful;
    33023321          if (deleteSome) {
    3303                deletedElements = true;
    33043322               CoinBigIndex put = start;
    33053323               for (j = start; j < end; j++) {
     
    33103328                    }
    33113329               }
     3330               deletedElements += end - put;
    33123331               columnLength[iColumn] = put - start;
    33133332          }
    33143333     }
     3334     if (deletedElements)
     3335       matrix_->setNumElements(matrix_->getNumElements()-deletedElements);
    33153336     model->messageHandler()->message(CLP_PACKEDSCALE_INITIAL, *model->messagesPointer())
    33163337               << smallest << largest
     
    40134034     // Say no gaps
    40144035     flags_ &= ~2;
     4036     if (type_>=10)
     4037       return true; // gub
    40154038     if (check == 14 || check == 10) {
    40164039          if (matrix_->getNumElements() < columnStart[numberColumns]) {
     
    40484071#ifndef COIN_BIG_INDEX
    40494072                         printf("Out of range %d %d %d %g\n", iColumn, j, row[j], elementByColumn[j]);
     4073#elif COIN_BIG_INDEX==0
     4074                         printf("Out of range %d %d %d %g\n", iColumn, j, row[j], elementByColumn[j]);
    40504075#elif COIN_BIG_INDEX==1
    40514076                         printf("Out of range %d %ld %d %g\n", iColumn, j, row[j], elementByColumn[j]);
     
    40964121                    if (iRow < 0 || iRow >= numberRows) {
    40974122#ifndef COIN_BIG_INDEX
     4123                         printf("Out of range %d %d %d %g\n", iColumn, j, row[j], elementByColumn[j]);
     4124#elif COIN_BIG_INDEX==0
    40984125                         printf("Out of range %d %d %d %g\n", iColumn, j, row[j], elementByColumn[j]);
    40994126#elif COIN_BIG_INDEX==1
     
    49074934               }
    49084935               if (ok)
    4909                     printf("flags_ could be 0\n");
     4936                 COIN_DETAIL_PRINT(printf("flags_ could be 0\n"));
    49104937          }
    49114938     }
  • stable/1.14/Clp/src/ClpPackedMatrix.hpp

    r1665 r1753  
    1010
    1111#include "ClpMatrixBase.hpp"
     12
     13// Compilers can produce better code if they know about __restrict
     14#ifndef COIN_RESTRICT
     15#ifdef COIN_USE_RESTRICT
     16#define COIN_RESTRICT __restrict
     17#else
     18#define COIN_RESTRICT
     19#endif
     20#endif
    1221
    1322/** This implements CoinPackedMatrix as derived from ClpMatrixBase.
  • stable/1.14/Clp/src/ClpPredictorCorrector.cpp

    r1665 r1753  
    141141     int returnCode = cholesky_->order(this);
    142142     if (returnCode || cholesky_->symbolic()) {
    143           printf("Error return from symbolic - probably not enough memory\n");
     143       COIN_DETAIL_PRINT(printf("Error return from symbolic - probably not enough memory\n"));
    144144          problemStatus_ = 4;
    145145          //delete all temporary regions
     
    164164     //initialize solution here
    165165     if(createSolution() < 0) {
    166           printf("Not enough memory\n");
     166       COIN_DETAIL_PRINT(printf("Not enough memory\n"));
    167167          problemStatus_ = 4;
    168168          //delete all temporary regions
     
    318318               if (saveIt) {
    319319#if KEEP_GOING_IF_FIXED<10
    320                     printf("saving\n");
     320                 COIN_DETAIL_PRINT(printf("saving\n"));
    321321#endif
    322322                    saveIteration = numberIterations_;
     
    349349                         bestKilled = numberFixedTotal;
    350350#if KEEP_GOING_IF_FIXED<10
    351                          printf("saving alternate\n");
     351                         COIN_DETAIL_PRINT(printf("saving alternate\n"));
    352352#endif
    353353                         saveIteration2 = numberIterations_;
     
    515515          if (newDropped) {
    516516               if (newDropped == -1) {
    517                     printf("Out of memory\n");
     517                 COIN_DETAIL_PRINT(printf("Out of memory\n"));
    518518                    problemStatus_ = 4;
    519519                    //delete all temporary regions
     
    741741                    //assert (goodMove);
    742742               }
    743                if (nHalve && handler_->logLevel() > 1)
     743               if (nHalve && handler_->logLevel() > 2)
    744744                    printf("halved %d times\n", nHalve);
    745745#endif
     
    818818          CoinWorkDouble nextCenterGap = 0.0;
    819819          int numberGoodTries = 0;
     820#ifdef COIN_DETAIL
    820821          CoinWorkDouble originalDualStep = actualDualStep_;
    821822          CoinWorkDouble originalPrimalStep = actualPrimalStep_;
     823#endif
    822824          if (actualDualStep_ > 0.9 && actualPrimalStep_ > 0.9)
    823825               goodMove = false; // don't bother
     
    882884          }
    883885          if (numberGoodTries && handler_->logLevel() > 1) {
    884                printf("%d centering steps moved from (gap %.18g, dual %.18g, primal %.18g) to (gap %.18g, dual %.18g, primal %.18g)\n",
     886               COIN_DETAIL_PRINT(printf("%d centering steps moved from (gap %.18g, dual %.18g, primal %.18g) to (gap %.18g, dual %.18g, primal %.18g)\n",
    885887                      numberGoodTries, static_cast<double>(nextGap), static_cast<double>(originalDualStep),
    886888                      static_cast<double>(originalPrimalStep),
    887889                      static_cast<double>(nextCenterGap), static_cast<double>(actualDualStep_),
    888                       static_cast<double>(actualPrimalStep_));
     890                                        static_cast<double>(actualPrimalStep_)));
    889891          }
    890892          // save last gap
     
    944946     //#ifdef SOME_DEBUG
    945947     if (handler_->logLevel() > 1)
    946           printf("ENDRUN status %d after %d iterations\n", problemStatus_, numberIterations_);
     948       COIN_DETAIL_PRINT(printf("ENDRUN status %d after %d iterations\n", problemStatus_, numberIterations_));
    947949     //#endif
    948950     //std::cout<<"Absolute primal infeasibility at end "<<sumPrimalInfeasibilities_<<std::endl;
     
    17371739                    CoinFillN(deltaX_, numberTotal, static_cast<CoinWorkDouble>(1.0));
    17381740                    CoinFillN(deltaY_, numberRows_, static_cast<CoinWorkDouble>(1.0));
    1739                     printf("bad cholesky\n");
     1741                    COIN_DETAIL_PRINT(printf("bad cholesky\n"));
    17401742               }
    17411743          }
     
    20132015     int returnCode = cholesky_->factorize(diagonal_, rowsDropped);
    20142016     if (returnCode == -1) {
    2015           printf("Out of memory\n");
     2017       COIN_DETAIL_PRINT(printf("Out of memory\n"));
    20162018          problemStatus_ = 4;
    20172019          return -1;
     
    34253427                                                     (nextMu - complementarity) / lowerSlack_[iColumn]);
    34263428                                        dualInfeasibility -= change;
    3427                                         printf("%d lb locomp %g - dual inf from %g to %g\n",
     3429                                        COIN_DETAIL_PRINT(printf("%d lb locomp %g - dual inf from %g to %g\n",
    34283430                                               iColumn, complementarity, dualInfeasibility + change,
    3429                                                dualInfeasibility);
     3431                                                                 dualInfeasibility));
    34303432                                        zVec_[iColumn] += change;
    34313433                                        zValue = CoinMax(zVec_[iColumn], 1.0e-12);
     
    34393441                                                     (complementarity - nextMu) / upperSlack_[iColumn]);
    34403442                                        dualInfeasibility -= change;
    3441                                         printf("%d ub hicomp %g - dual inf from %g to %g\n",
     3443                                        COIN_DETAIL_PRINT(printf("%d ub hicomp %g - dual inf from %g to %g\n",
    34423444                                               iColumn, complementarity, dualInfeasibility + change,
    3443                                                dualInfeasibility);
     3445                                                                 dualInfeasibility));
    34443446                                        wVec_[iColumn] -= change;
    34453447                                        wValue = CoinMax(wVec_[iColumn], 1.0e-12);
     
    34553457                                                     (nextMu - complementarity) / lowerSlack_[iColumn]);
    34563458                                        dualInfeasibility -= change;
    3457                                         printf("%d lb hicomp %g - dual inf from %g to %g\n",
     3459                                        COIN_DETAIL_PRINT(printf("%d lb hicomp %g - dual inf from %g to %g\n",
    34583460                                               iColumn, complementarity, dualInfeasibility + change,
    3459                                                dualInfeasibility);
     3461                                                                 dualInfeasibility));
    34603462                                        zVec_[iColumn] += change;
    34613463                                        zValue = CoinMax(zVec_[iColumn], 1.0e-12);
     
    34693471                                                     (complementarity - nextMu) / upperSlack_[iColumn]);
    34703472                                        dualInfeasibility -= change;
    3471                                         printf("%d ub locomp %g - dual inf from %g to %g\n",
     3473                                        COIN_DETAIL_PRINT(printf("%d ub locomp %g - dual inf from %g to %g\n",
    34723474                                               iColumn, complementarity, dualInfeasibility + change,
    3473                                                dualInfeasibility);
     3475                                                                 dualInfeasibility));
    34743476                                        wVec_[iColumn] -= change;
    34753477                                        wValue = CoinMax(wVec_[iColumn], 1.0e-12);
     
    35403542                    if (solution_[iColumn] != lower_[iColumn] &&
    35413543                              solution_[iColumn] != upper_[iColumn]) {
    3542                          printf("%d %g %g %g\n", iColumn, static_cast<double>(lower_[iColumn]),
    3543                                 static_cast<double>(solution_[iColumn]), static_cast<double>(upper_[iColumn]));
     3544                         COIN_DETAIL_PRINT(printf("%d %g %g %g\n", iColumn, static_cast<double>(lower_[iColumn]),
     3545                                                  static_cast<double>(solution_[iColumn]), static_cast<double>(upper_[iColumn])));
    35443546                    }
    35453547                    diagonal_[iColumn] = 0.0;
  • stable/1.14/Clp/src/ClpPresolve.cpp

    r1665 r1753  
    148148     return originalModel_;
    149149}
     150// Return presolve status (0,1,2)
     151int
     152ClpPresolve::presolveStatus() const
     153{
     154  if (nelems_>=0) {
     155    // feasible (or not done yet)
     156    return 0;
     157  } else {
     158    int presolveStatus = - nelems_;
     159    // If both infeasible and unbounded - say infeasible
     160    if (presolveStatus>2)
     161      presolveStatus = 1;
     162    return presolveStatus;
     163  }
     164}
    150165void
    151166ClpPresolve::postsolve(bool updateStatus)
     
    424439}
    425440#endif
     441//#define COIN_PRESOLVE_BUG
     442#ifdef COIN_PRESOLVE_BUG
     443static int counter=1000000;
     444static int startEmptyRows=0;
     445static int startEmptyColumns=0;
     446static bool break2(CoinPresolveMatrix *prob)
     447{
     448  int droppedRows = prob->countEmptyRows() - startEmptyRows ;
     449  int droppedColumns =  prob->countEmptyCols() - startEmptyColumns;
     450  startEmptyRows=prob->countEmptyRows();
     451  startEmptyColumns=prob->countEmptyCols();
     452  printf("Dropped %d rows and %d columns - current empty %d, %d\n",droppedRows,
     453         droppedColumns,startEmptyRows,startEmptyColumns);
     454  counter--;
     455  if (!counter) {
     456    printf("skipping next and all\n");
     457  }
     458  return (counter<=0);
     459}
     460#define possibleBreak if (break2(prob)) break
     461#define possibleSkip  if (!break2(prob))
     462#else
     463#define possibleBreak
     464#define possibleSkip
     465#endif
    426466// This is the presolve loop.
    427467// It is a separate virtual function so that it can be easily
     
    432472     CoinMessages messages = CoinMessage(prob->messages().language());
    433473     paction_ = 0;
    434 
     474#ifndef PRESOLVE_DETAIL
     475     if (prob->tuning_) {
     476#endif
     477       int numberEmptyRows=0;
     478       for ( int i=0;i<prob->nrows_;i++) {
     479         if (!prob->hinrow_[i]) {
     480           PRESOLVE_DETAIL_PRINT(printf("pre_empty row %d\n",i));
     481           //printf("pre_empty row %d\n",i);
     482           numberEmptyRows++;
     483         }
     484       }
     485       int numberEmptyCols=0;
     486       for ( int i=0;i<prob->ncols_;i++) {
     487         if (!prob->hincol_[i]) {
     488           PRESOLVE_DETAIL_PRINT(printf("pre_empty col %d\n",i));
     489           //printf("pre_empty col %d\n",i);
     490           numberEmptyCols++;
     491         }
     492       }
     493       printf("CoinPresolve initial state %d empty rows and %d empty columns\n",
     494              numberEmptyRows,numberEmptyCols);
     495#ifndef PRESOLVE_DETAIL
     496     }
     497#endif
    435498     prob->status_ = 0; // say feasible
    436499     paction_ = make_fixed(prob, paction_);
     
    498561               if ((presolveActions_ & 512) != 0)
    499562                    prob->setPresolveOptions(prob->presolveOptions() | 1);
     563               possibleSkip;
    500564               paction_ = dupcol_action::presolve(prob, paction_);
    501565          }
    502566          if (duprow) {
     567            possibleSkip;
    503568               paction_ = duprow_action::presolve(prob, paction_);
    504569          }
    505570          if (doGubrow()) {
     571            possibleSkip;
    506572               paction_ = gubrow_action::presolve(prob, paction_);
    507573          }
     
    530596#if IMPLIED>2&&IMPLIED<11
    531597               fill_level = IMPLIED;
    532                printf("** fill_level == %d !\n", fill_level);
     598               COIN_DETAIL_PRINT(printf("** fill_level == %d !\n", fill_level));
    533599#endif
    534600#if IMPLIED>11&&IMPLIED<21
    535601               fill_level = -(IMPLIED - 10);
    536                printf("** fill_level == %d !\n", fill_level);
     602               COIN_DETAIL_PRINT(printf("** fill_level == %d !\n", fill_level));
    537603#endif
    538604#endif
     
    548614                    if (slackd) {
    549615                         bool notFinished = true;
    550                          while (notFinished)
     616                         while (notFinished) {
     617                           possibleBreak;
    551618                              paction_ = slack_doubleton_action::presolve(prob, paction_,
    552619                                         notFinished);
     620                         }
    553621                         if (prob->status_)
    554622                              break;
     
    556624                    if (dual && whichPass == 1) {
    557625                         // this can also make E rows so do one bit here
     626                      possibleBreak;
    558627                         paction_ = remove_dual_action::presolve(prob, paction_);
    559628                         if (prob->status_)
     
    562631
    563632                    if (doubleton) {
     633                      possibleBreak;
    564634                         paction_ = doubleton_action::presolve(prob, paction_);
    565635                         if (prob->status_)
     
    567637                    }
    568638                    if (tripleton) {
     639                      possibleBreak;
    569640                         paction_ = tripleton_action::presolve(prob, paction_);
    570641                         if (prob->status_)
     
    573644
    574645                    if (zerocost) {
     646                      possibleBreak;
    575647                         paction_ = do_tighten_action::presolve(prob, paction_);
    576648                         if (prob->status_)
     
    579651#ifndef NO_FORCING
    580652                    if (forcing) {
     653                      possibleBreak;
    581654                         paction_ = forcing_constraint_action::presolve(prob, paction_);
    582655                         if (prob->status_)
     
    586659
    587660                    if (ifree && (whichPass % 5) == 1) {
     661                      possibleBreak;
    588662                         paction_ = implied_free_action::presolve(prob, paction_, fill_level);
    589663                         if (prob->status_)
     
    689763                    int itry;
    690764                    for (itry = 0; itry < 5; itry++) {
     765                      possibleBreak;
    691766                         paction_ = remove_dual_action::presolve(prob, paction_);
    692767                         if (prob->status_)
     
    701776#endif
    702777#endif
    703                               if ((itry & 1) == 0)
     778                              if ((itry & 1) == 0) {
     779                                possibleBreak;
    704780                                   paction_ = implied_free_action::presolve(prob, paction_, fill_level);
     781                              }
    705782                              if (prob->status_)
    706783                                   break;
     
    718795#endif
    719796#endif
     797                    possibleBreak;
    720798                    paction_ = implied_free_action::presolve(prob, paction_, fill_level);
    721799                    if (prob->status_)
     
    729807                    if ((presolveActions_ & 512) != 0)
    730808                         prob->setPresolveOptions(prob->presolveOptions() | 1);
     809                    possibleBreak;
    731810                    paction_ = dupcol_action::presolve(prob, paction_);
    732811                    if (prob->status_)
     
    738817
    739818               if (duprow) {
     819                 possibleBreak;
    740820                    paction_ = duprow_action::presolve(prob, paction_);
    741821                    if (prob->status_)
     
    768848                    // On most passes do not touch costed slacks
    769849                    if (paction_ != paction0 && !stopLoop) {
     850                      possibleBreak;
    770851                         paction_ = slack_singleton_action::presolve(prob, paction_, NULL);
    771852                    } else {
    772853                         // do costed if Clp (at end as ruins rest of presolve)
     854                      possibleBreak;
    773855                         paction_ = slack_singleton_action::presolve(prob, paction_, rowObjective_);
    774856                         stopLoop = true;
     
    18541936               // infeasible or unbounded
    18551937               result = 1;
     1938               // Put status in nelems_!
     1939               nelems_ = - prob.status_;
    18561940               originalModel->setProblemStatus(prob.status_);
    18571941          } else {
  • stable/1.14/Clp/src/ClpPresolve.hpp

    r1665 r1753  
    181181          presolveActions_ |= 0x80000000;
    182182     }
     183     /// Return presolve status (0,1,2)
     184     int presolveStatus() const;
    183185
    184186     /**@name postsolve - postsolve the problem.  If the problem
  • stable/1.14/Clp/src/ClpPrimalColumnDantzig.cpp

    r1665 r1753  
    132132     reducedCost = model_->djRegion();
    133133
     134#ifndef CLP_PRIMAL_SLACK_MULTIPLIER
    134135     for (iSequence = 0; iSequence < number; iSequence++) {
    135136          // check flagged variable
     
    164165          }
    165166     }
     167#else
     168     // Columns
     169     int numberColumns = model_->numberColumns();
     170     for (iSequence = 0; iSequence < numberColumns; iSequence++) {
     171          // check flagged variable
     172          if (!model_->flagged(iSequence)) {
     173               double value = reducedCost[iSequence];
     174               ClpSimplex::Status status = model_->getStatus(iSequence);
     175
     176               switch(status) {
     177
     178               case ClpSimplex::basic:
     179               case ClpSimplex::isFixed:
     180                    break;
     181               case ClpSimplex::isFree:
     182               case ClpSimplex::superBasic:
     183                    if (fabs(value) > bestFreeDj) {
     184                         bestFreeDj = fabs(value);
     185                         bestFreeSequence = iSequence;
     186                    }
     187                    break;
     188               case ClpSimplex::atUpperBound:
     189                    if (value > bestDj) {
     190                         bestDj = value;
     191                         bestSequence = iSequence;
     192                    }
     193                    break;
     194               case ClpSimplex::atLowerBound:
     195                    if (value < -bestDj) {
     196                         bestDj = -value;
     197                         bestSequence = iSequence;
     198                    }
     199               }
     200          }
     201     }
     202     // Rows
     203     for ( ; iSequence < number; iSequence++) {
     204          // check flagged variable
     205          if (!model_->flagged(iSequence)) {
     206               double value = reducedCost[iSequence] * CLP_PRIMAL_SLACK_MULTIPLIER;
     207               ClpSimplex::Status status = model_->getStatus(iSequence);
     208
     209               switch(status) {
     210
     211               case ClpSimplex::basic:
     212               case ClpSimplex::isFixed:
     213                    break;
     214               case ClpSimplex::isFree:
     215               case ClpSimplex::superBasic:
     216                    if (fabs(value) > bestFreeDj) {
     217                         bestFreeDj = fabs(value);
     218                         bestFreeSequence = iSequence;
     219                    }
     220                    break;
     221               case ClpSimplex::atUpperBound:
     222                    if (value > bestDj) {
     223                         bestDj = value;
     224                         bestSequence = iSequence;
     225                    }
     226                    break;
     227               case ClpSimplex::atLowerBound:
     228                    if (value < -bestDj) {
     229                         bestDj = -value;
     230                         bestSequence = iSequence;
     231                    }
     232               }
     233          }
     234     }
     235#endif
    166236     // bias towards free
    167237     if (bestFreeSequence >= 0 && bestFreeDj > 0.1 * bestDj)
  • stable/1.14/Clp/src/ClpPrimalColumnPivot.hpp

    r1665 r1753  
    150150     //@}
    151151};
    152 
     152#ifndef CLP_PRIMAL_SLACK_MULTIPLIER
     153#define CLP_PRIMAL_SLACK_MULTIPLIER 1.01
    153154#endif
     155#endif
  • stable/1.14/Clp/src/ClpPrimalColumnSteepest.cpp

    r1665 r1753  
    272272                    saveWeights(model_, 4);
    273273                    anyUpdates = 0;
    274                     printf("switching to devex %d nel ratio %g\n", sizeFactorization_, ratio);
     274                    COIN_DETAIL_PRINT(printf("switching to devex %d nel ratio %g\n", sizeFactorization_, ratio));
    275275               }
    276276               if (switchType == 5) {
    277277                    numberLook *= 5; // needs tuning for gub
    278278                    if (model_->numberIterations() % 1000 == 0 && model_->logLevel() > 1) {
    279                          printf("numels %d ratio %g wanted %d look %d\n",
    280                                 sizeFactorization_, ratio, numberWanted, numberLook);
     279                         COIN_DETAIL_PRINT(printf("numels %d ratio %g wanted %d look %d\n",
     280                                                  sizeFactorization_, ratio, numberWanted, numberLook));
    281281                    }
    282282                    // Update duals and row djs
     
    402402               weights_ = NULL;
    403403               saveWeights(model_, 4);
    404                printf("switching to devex %d nel ratio %g\n", sizeFactorization_, ratio);
     404               COIN_DETAIL_PRINT(printf("switching to devex %d nel ratio %g\n", sizeFactorization_, ratio));
    405405          }
    406406          //if (model_->numberIterations()%1000==0)
     
    432432               weights_ = NULL;
    433433               saveWeights(model_, 4);
    434                printf("switching to exact %d nel ratio %g\n", sizeFactorization_, ratio);
     434               COIN_DETAIL_PRINT(printf("switching to exact %d nel ratio %g\n", sizeFactorization_, ratio));
    435435               updates->clear();
    436436          }
    437437          if (model_->numberIterations() % 1000 == 0)
    438                printf("numels %d ratio %g wanted %d type x\n", sizeFactorization_, ratio, numberWanted);
     438            COIN_DETAIL_PRINT(printf("numels %d ratio %g wanted %d type x\n", sizeFactorization_, ratio, numberWanted));
    439439     }
    440440     if (switchType < 4) {
     
    625625          reducedCost = model_->djRegion(iSection);
    626626          int addSequence;
     627#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     628          double slack_multiplier;
     629#endif
    627630
    628631          if (!iSection) {
     
    631634               updateBy = updates->denseVector();
    632635               addSequence = model_->numberColumns();
     636#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     637               slack_multiplier = CLP_PRIMAL_SLACK_MULTIPLIER;
     638#endif
    633639          } else {
    634640               number = spareColumn1->getNumElements();
     
    636642               updateBy = spareColumn1->denseVector();
    637643               addSequence = 0;
     644#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     645               slack_multiplier = 1.0;
     646#endif
    638647          }
    639648
     
    667676                    break;
    668677               case ClpSimplex::atUpperBound:
     678                    iSequence += addSequence;
    669679                    if (value > tolerance) {
     680#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     681                        value *= value*slack_multiplier;
     682#else
     683                        value *= value;
     684#endif
    670685                         // store square in list
    671                          if (infeas[iSequence+addSequence])
    672                               infeas[iSequence+addSequence] = value * value; // already there
     686                         if (infeas[iSequence])
     687                              infeas[iSequence] = value; // already there
    673688                         else
    674                               infeasible_->quickAdd(iSequence + addSequence, value * value);
     689                              infeasible_->quickAdd(iSequence, value);
    675690                    } else {
    676                          infeasible_->zero(iSequence + addSequence);
     691                         infeasible_->zero(iSequence);
    677692                    }
    678693                    break;
    679694               case ClpSimplex::atLowerBound:
     695                    iSequence += addSequence;
    680696                    if (value < -tolerance) {
     697#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     698                        value *= value*slack_multiplier;
     699#else
     700                        value *= value;
     701#endif
    681702                         // store square in list
    682                          if (infeas[iSequence+addSequence])
    683                               infeas[iSequence+addSequence] = value * value; // already there
     703                         if (infeas[iSequence])
     704                              infeas[iSequence] = value; // already there
    684705                         else
    685                               infeasible_->quickAdd(iSequence + addSequence, value * value);
     706                              infeasible_->quickAdd(iSequence, value);
    686707                    } else {
    687                          infeasible_->zero(iSequence + addSequence);
     708                         infeasible_->zero(iSequence);
    688709                    }
    689710               }
     
    725746     model_->factorization()->updateColumnTranspose(spareRow2, updates);
    726747     // and we can see if reference
    727      double referenceIn = 0.0;
     748     //double referenceIn = 0.0;
    728749     int sequenceIn = model_->sequenceIn();
    729      if (mode_ != 1 && reference(sequenceIn))
    730           referenceIn = 1.0;
     750     //if (mode_ != 1 && reference(sequenceIn))
     751     //   referenceIn = 1.0;
    731752     // save outgoing weight round update
    732753     double outgoingWeight = 0.0;
     
    798819                    value3 += 1.0;
    799820               weight[iSequence] = CoinMax(0.99 * thisWeight, value3);
     821               iSequence += addSequence;
    800822               if (value > tolerance) {
    801823                    // store square in list
    802                     if (infeas[iSequence+addSequence])
    803                          infeas[iSequence+addSequence] = value * value; // already there
     824#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     825                    value *= value*CLP_PRIMAL_SLACK_MULTIPLIER;
     826#else
     827                    value *= value;
     828#endif
     829                    if (infeas[iSequence])
     830                         infeas[iSequence] = value; // already there
    804831                    else
    805                          infeasible_->quickAdd(iSequence + addSequence, value * value);
     832                         infeasible_->quickAdd(iSequence , value);
    806833               } else {
    807                     infeasible_->zero(iSequence + addSequence);
     834                    infeasible_->zero(iSequence);
    808835               }
    809836               break;
     
    816843                    value3 += 1.0;
    817844               weight[iSequence] = CoinMax(0.99 * thisWeight, value3);
     845               iSequence += addSequence;
    818846               if (value < -tolerance) {
    819847                    // store square in list
    820                     if (infeas[iSequence+addSequence])
    821                          infeas[iSequence+addSequence] = value * value; // already there
     848#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     849                    value *= value*CLP_PRIMAL_SLACK_MULTIPLIER;
     850#else
     851                    value *= value;
     852#endif
     853                    if (infeas[iSequence])
     854                         infeas[iSequence] = value; // already there
    822855                    else
    823                          infeasible_->quickAdd(iSequence + addSequence, value * value);
     856                         infeasible_->quickAdd(iSequence , value);
    824857               } else {
    825                     infeasible_->zero(iSequence + addSequence);
     858                    infeasible_->zero(iSequence);
    826859               }
    827860          }
     
    10741107               }
    10751108               weight[iSequence] = thisWeight;
     1109               iSequence += addSequence;
    10761110               if (value > tolerance) {
    10771111                    // store square in list
    1078                     if (infeas[iSequence+addSequence])
    1079                          infeas[iSequence+addSequence] = value * value; // already there
     1112#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1113                    value *= value*CLP_PRIMAL_SLACK_MULTIPLIER;
     1114#else
     1115                    value *= value;
     1116#endif
     1117                    if (infeas[iSequence])
     1118                         infeas[iSequence] = value; // already there
    10801119                    else
    1081                          infeasible_->quickAdd(iSequence + addSequence, value * value);
     1120                         infeasible_->quickAdd(iSequence , value);
    10821121               } else {
    1083                     infeasible_->zero(iSequence + addSequence);
     1122                    infeasible_->zero(iSequence);
    10841123               }
    10851124               break;
     
    11071146               }
    11081147               weight[iSequence] = thisWeight;
     1148               iSequence += addSequence;
    11091149               if (value < -tolerance) {
    11101150                    // store square in list
    1111                     if (infeas[iSequence+addSequence])
    1112                          infeas[iSequence+addSequence] = value * value; // already there
     1151#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1152                    value *= value*CLP_PRIMAL_SLACK_MULTIPLIER;
     1153#else
     1154                    value *= value;
     1155#endif
     1156                    if (infeas[iSequence])
     1157                         infeas[iSequence] = value; // already there
    11131158                    else
    1114                          infeasible_->quickAdd(iSequence + addSequence, value * value);
     1159                         infeasible_->quickAdd(iSequence, value);
    11151160               } else {
    1116                     infeasible_->zero(iSequence + addSequence);
     1161                    infeasible_->zero(iSequence);
    11171162               }
    11181163          }
     
    12381283          reducedCost = model_->djRegion(iSection);
    12391284          int addSequence;
     1285#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1286          double slack_multiplier;
     1287#endif
    12401288
    12411289          if (!iSection) {
     
    12441292               updateBy = updates->denseVector();
    12451293               addSequence = model_->numberColumns();
     1294#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1295               slack_multiplier = CLP_PRIMAL_SLACK_MULTIPLIER;
     1296#endif
    12461297          } else {
    12471298               number = spareColumn1->getNumElements();
     
    12491300               updateBy = spareColumn1->denseVector();
    12501301               addSequence = 0;
     1302#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1303               slack_multiplier = 1.0;
     1304#endif
    12511305          }
    12521306
     
    12801334                    break;
    12811335               case ClpSimplex::atUpperBound:
     1336                    iSequence += addSequence;
    12821337                    if (value > tolerance) {
     1338#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1339                        value *= value*slack_multiplier;
     1340#else
     1341                        value *= value;
     1342#endif
    12831343                         // store square in list
    1284                          if (infeas[iSequence+addSequence])
    1285                               infeas[iSequence+addSequence] = value * value; // already there
     1344                         if (infeas[iSequence])
     1345                              infeas[iSequence] = value; // already there
    12861346                         else
    1287                               infeasible_->quickAdd(iSequence + addSequence, value * value);
     1347                              infeasible_->quickAdd(iSequence, value);
    12881348                    } else {
    1289                          infeasible_->zero(iSequence + addSequence);
     1349                         infeasible_->zero(iSequence);
    12901350                    }
    12911351                    break;
    12921352               case ClpSimplex::atLowerBound:
     1353                    iSequence += addSequence;
    12931354                    if (value < -tolerance) {
     1355#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1356                        value *= value*slack_multiplier;
     1357#else
     1358                        value *= value;
     1359#endif
    12941360                         // store square in list
    1295                          if (infeas[iSequence+addSequence])
    1296                               infeas[iSequence+addSequence] = value * value; // already there
     1361                         if (infeas[iSequence])
     1362                              infeas[iSequence] = value; // already there
    12971363                         else
    1298                               infeasible_->quickAdd(iSequence + addSequence, value * value);
     1364                              infeasible_->quickAdd(iSequence, value);
    12991365                    } else {
    1300                          infeasible_->zero(iSequence + addSequence);
     1366                         infeasible_->zero(iSequence);
    13011367                    }
    13021368               }
     
    13191385          infeasible_->zero(sequenceIn);
    13201386          // and we can see if reference
    1321           double referenceIn = 0.0;
    1322           if (mode_ != 1 && reference(sequenceIn))
    1323                referenceIn = 1.0;
     1387          //double referenceIn = 0.0;
     1388          //if (mode_ != 1 && reference(sequenceIn))
     1389          //   referenceIn = 1.0;
    13241390          // save outgoing weight round update
    13251391          double outgoingWeight = 0.0;
     
    14291495          reducedCost = model_->djRegion(iSection);
    14301496          int addSequence;
     1497#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1498          double slack_multiplier;
     1499#endif
    14311500
    14321501          if (!iSection) {
     
    14351504               updateBy = updates->denseVector();
    14361505               addSequence = model_->numberColumns();
     1506#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1507               slack_multiplier = CLP_PRIMAL_SLACK_MULTIPLIER;
     1508#endif
    14371509          } else {
    14381510               number = spareColumn1->getNumElements();
     
    14401512               updateBy = spareColumn1->denseVector();
    14411513               addSequence = 0;
     1514#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1515               slack_multiplier = 1.0;
     1516#endif
    14421517          }
    14431518
     
    14711546                    break;
    14721547               case ClpSimplex::atUpperBound:
     1548                    iSequence += addSequence;
    14731549                    if (value > tolerance) {
     1550#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1551                        value *= value*slack_multiplier;
     1552#else
     1553                        value *= value;
     1554#endif
    14741555                         // store square in list
    1475                          if (infeas[iSequence+addSequence])
    1476                               infeas[iSequence+addSequence] = value * value; // already there
     1556                         if (infeas[iSequence])
     1557                              infeas[iSequence] = value; // already there
    14771558                         else
    1478                               infeasible_->quickAdd(iSequence + addSequence, value * value);
     1559                              infeasible_->quickAdd(iSequence, value);
    14791560                    } else {
    1480                          infeasible_->zero(iSequence + addSequence);
     1561                         infeasible_->zero(iSequence);
    14811562                    }
    14821563                    break;
    14831564               case ClpSimplex::atLowerBound:
     1565                    iSequence += addSequence;
    14841566                    if (value < -tolerance) {
     1567#ifdef CLP_PRIMAL_SLACK_MULTIPLIER
     1568                        value *= value*slack_multiplier;
     1569#else
     1570                        value *= value;
     1571#endif
    14851572                         // store square in list
    1486                          if (infeas[iSequence+addSequence])
    1487                               infeas[iSequence+addSequence] = value * value; // already there
     1573                         if (infeas[iSequence])
     1574                              infeas[iSequence] = value; // already there
    14881575                         else
    1489                               infeasible_->quickAdd(iSequence + addSequence, value * value);
     1576                              infeasible_->quickAdd(iSequence, value);
    14901577                    } else {
    1491                          infeasible_->zero(iSequence + addSequence);
     1578                         infeasible_->zero(iSequence);
    14921579                    }
    14931580               }
     
    17471834     infeasible_->zero(sequenceIn);
    17481835     // and we can see if reference
    1749      double referenceIn = 0.0;
    1750      if (mode_ != 1 && reference(sequenceIn))
    1751           referenceIn = 1.0;
     1836     //double referenceIn = 0.0;
     1837     //if (mode_ != 1 && reference(sequenceIn))
     1838     //   referenceIn = 1.0;
    17521839     // save outgoing weight round update
    17531840     double outgoingWeight = 0.0;
     
    24212508               weights_ = NULL;
    24222509               saveWeights(model_, 4);
    2423                printf("switching to devex %d nel ratio %g\n", sizeFactorization_, ratio);
     2510               COIN_DETAIL_PRINT(printf("switching to devex %d nel ratio %g\n", sizeFactorization_, ratio));
    24242511               updates->clear();
    24252512          }
    24262513          if (model_->numberIterations() % 1000 == 0)
    2427                printf("numels %d ratio %g wanted %d\n", sizeFactorization_, ratio, numberWanted);
     2514            COIN_DETAIL_PRINT(printf("numels %d ratio %g wanted %d\n", sizeFactorization_, ratio, numberWanted));
    24282515     }
    24292516     if(switchType == 4) {
     
    24512538               weights_ = NULL;
    24522539               saveWeights(model_, 4);
    2453                printf("switching to exact %d nel ratio %g\n", sizeFactorization_, ratio);
     2540               COIN_DETAIL_PRINT(printf("switching to exact %d nel ratio %g\n", sizeFactorization_, ratio));
    24542541               updates->clear();
    24552542          }
    24562543          if (model_->numberIterations() % 1000 == 0)
    2457                printf("numels %d ratio %g wanted %d\n", sizeFactorization_, ratio, numberWanted);
     2544            COIN_DETAIL_PRINT(printf("numels %d ratio %g wanted %d\n", sizeFactorization_, ratio, numberWanted));
    24582545     }
    24592546     if (switchType < 4) {
     
    29493036
    29503037          if (!model_->nonLinearCost()->lookBothWays()) {
     3038#ifndef CLP_PRIMAL_SLACK_MULTIPLIER
    29513039               for (iSequence = 0; iSequence < number; iSequence++) {
    29523040                    double value = reducedCost[iSequence];
     
    29783066                    }
    29793067               }
     3068#else
     3069               // Columns
     3070               int numberColumns = model_->numberColumns();
     3071               for (iSequence = 0; iSequence < numberColumns; iSequence++) {
     3072                    double value = reducedCost[iSequence];
     3073                    ClpSimplex::Status status = model_->getStatus(iSequence);
     3074
     3075                    switch(status) {
     3076
     3077                    case ClpSimplex::basic:
     3078                    case ClpSimplex::isFixed:
     3079                         break;
     3080                    case ClpSimplex::isFree:
     3081                    case ClpSimplex::superBasic:
     3082                         if (fabs(value) > FREE_ACCEPT * tolerance) {
     3083                              // we are going to bias towards free (but only if reasonable)
     3084                              value *= FREE_BIAS;
     3085                              // store square in list
     3086                              infeasible_->quickAdd(iSequence, value * value);
     3087                         }
     3088                         break;
     3089                    case ClpSimplex::atUpperBound:
     3090                         if (value > tolerance) {
     3091                              infeasible_->quickAdd(iSequence, value * value);
     3092                         }
     3093                         break;
     3094                    case ClpSimplex::atLowerBound:
     3095                         if (value < -tolerance) {
     3096                              infeasible_->quickAdd(iSequence, value * value);
     3097                         }
     3098                    }
     3099               }
     3100               // Rows
     3101               for ( ; iSequence < number; iSequence++) {
     3102                    double value = reducedCost[iSequence];
     3103                    ClpSimplex::Status status = model_->getStatus(iSequence);
     3104
     3105                    switch(status) {
     3106
     3107                    case ClpSimplex::basic:
     3108                    case ClpSimplex::isFixed:
     3109                         break;
     3110                    case ClpSimplex::isFree:
     3111                    case ClpSimplex::superBasic:
     3112                         if (fabs(value) > FREE_ACCEPT * tolerance) {
     3113                              // we are going to bias towards free (but only if reasonable)
     3114                              value *= FREE_BIAS;
     3115                              // store square in list
     3116                              infeasible_->quickAdd(iSequence, value * value);
     3117                         }
     3118                         break;
     3119                    case ClpSimplex::atUpperBound:
     3120                         if (value > tolerance) {
     3121                              infeasible_->quickAdd(iSequence, value * value * CLP_PRIMAL_SLACK_MULTIPLIER);
     3122                         }
     3123                         break;
     3124                    case ClpSimplex::atLowerBound:
     3125                         if (value < -tolerance) {
     3126                              infeasible_->quickAdd(iSequence, value * value * CLP_PRIMAL_SLACK_MULTIPLIER);
     3127                         }
     3128                    }
     3129               }
     3130#endif
    29803131          } else {
    29813132               ClpNonLinearCost * nonLinear = model_->nonLinearCost();
     
    32903441     double check = CoinMax(devex, oldDevex);;
    32913442     if ( fabs ( devex - oldDevex ) > relativeTolerance * check ) {
    3292           printf("check %d old weight %g, new %g\n", sequence, oldDevex, devex);
     3443       COIN_DETAIL_PRINT(printf("check %d old weight %g, new %g\n", sequence, oldDevex, devex));
    32933444          // update so won't print again
    32943445          weights_[sequence] = devex;
     
    35323683     // Rows
    35333684     reducedCost = model_->djRegion(0);
    3534      int addSequence;
    35353685
    35363686     number = updates->getNumElements();
    35373687     index = updates->getIndices();
    35383688     updateBy = updates->denseVector();
    3539      addSequence = numberColumns;
    35403689     int j;
    35413690     double * duals = model_->dualRowSolution();
     
    36213770     double * duals2 = duals - numberColumns;
    36223771     int chunk = CoinMin(1024, (numberColumns + nSlacks) / 32);
     3772#ifdef COIN_DETAIL
    36233773     if (model_->numberIterations() % 1000 == 0 && model_->logLevel() > 1) {
    36243774          printf("%d wanted, nSlacks %d, chunk %d\n", numberWanted, nSlacks, chunk);
     
    36283778          printf("\n");
    36293779     }
     3780#endif
    36303781     chunk = CoinMax(chunk, 256);
    36313782     bool finishedR = false, finishedC = false;
  • stable/1.14/Clp/src/ClpQuadraticObjective.cpp

    r1665 r1753  
    756756               return maximumTheta;
    757757          } else {
    758                printf("odd linear direction %g\n", delta);
     758            COIN_DETAIL_PRINT(printf("odd linear direction %g\n", delta));
    759759               return 0.0;
    760760          }
  • stable/1.14/Clp/src/ClpSimplex.cpp

    r1665 r1753  
    1515#endif
    1616#include "CoinHelperFunctions.hpp"
     17#include "CoinFloatEqual.hpp"
    1718#include "ClpSimplex.hpp"
    1819#include "ClpFactorization.hpp"
     
    18281829
    18291830     // Update hidden stuff e.g. effective RHS and gub
    1830      matrix_->updatePivot(this, oldIn, oldOut);
     1831     int invertNow=matrix_->updatePivot(this, oldIn, oldOut);
    18311832     objectiveValue_ += objectiveChange / (objectiveScale_ * rhsScale_);
    18321833     if (handler_->logLevel() > 7) {
     
    18831884                    double tolerance = 10.0 * primalTolerance_;
    18841885                    double mostAway = 0.0;
    1885                     int iAway = -1;
    18861886                    for (int i = 0; i < numberColumns_; i++) {
    18871887                         // Save anyway
     
    19021902                                        if (mostAway < fabs(value - closest)) {
    19031903                                             mostAway = fabs(value - closest);
    1904                                              iAway = i;
    19051904                                        }
    19061905                                   } else {
     
    19151914                    }
    19161915                    solution->numberUnsatisfied[solution->numberSolutions++] = numberUnsat;
    1917                     printf("iteration %d, %d unsatisfied (%g,%g), %d fixed, %d satisfied\n",
    1918                            numberIterations_, numberUnsat, sumUnsat, mostAway, numberFixed, numberSat);
     1916                    COIN_DETAIL_PRINT(printf("iteration %d, %d unsatisfied (%g,%g), %d fixed, %d satisfied\n",
     1917                                             numberIterations_, numberUnsat, sumUnsat, mostAway, numberFixed, numberSat));
    19191918               }
    19201919          }
     
    19331932     int cycle = progress_.cycle(in, out,
    19341933                                 directionIn_, directionOut_);
    1935      if (cycle > 0 && objective_->type() < 2) {
     1934     if (cycle > 0 && objective_->type() < 2 && matrix_->type() < 15) {
    19361935          //if (cycle>0) {
    19371936          if (handler_->logLevel() >= 63)
     
    19451944               forceFactorization_ = CoinMax(1, cycle - off[extra]);
    19461945          } else {
    1947                // need to reject something
     1946            /* need to reject something
     1947               should be better if don't reject incoming
     1948               as it is in basis */
    19481949               int iSequence;
    1949                if (algorithm_ > 0)
    1950                     iSequence = sequenceIn_;
    1951                else
     1950               //if (algorithm_ > 0)
     1951               //   iSequence = sequenceIn_;
     1952               //else
    19521953                    iSequence = sequenceOut_;
    19531954               char x = isColumn(iSequence) ? 'C' : 'R';
     
    19831984          }
    19841985          return 1;
    1985      } else if (factorization_->timeToRefactorize() && !dontInvert) {
     1986     } else if ((factorization_->timeToRefactorize() && !dontInvert)
     1987                ||invertNow) {
    19861988          //printf("ret after %d pivots\n",factorization_->pivots());
    19871989          return 1;
     
    19931995               forceFactorization_ = -1; //off
    19941996          return 1;
    1995      } else if (numberIterations_ > 1000 + 10 * (numberRows_ + (numberColumns_ >> 2))) {
     1997     } else if (numberIterations_ > 1000 + 10 * (numberRows_ + (numberColumns_ >> 2)) && matrix_->type()<15) {
    19961998          double random = randomNumberGenerator_.randomDouble();
    19971999          int maxNumber = (forceFactorization_ < 0) ? maximumPivots : CoinMin(forceFactorization_, maximumPivots);
     
    27702772     // Say no free or superbasic
    27712773     moreSpecialOptions_ |= 8;
     2774     //#define PRINT_INFEAS
     2775#ifdef PRINT_INFEAS
     2776     int seqInf[10];
     2777#endif
    27722778     for (iSequence = 0; iSequence < numberTotal; iSequence++) {
    27732779          double value = solution_[iSequence];
     
    27852791               if (infeasibility > relaxedToleranceP)
    27862792                    sumOfRelaxedPrimalInfeasibilities_ += infeasibility - relaxedToleranceP;
     2793#ifdef PRINT_INFEAS
     2794               if (numberPrimalInfeasibilities_<10) {
     2795                 seqInf[numberPrimalInfeasibilities_]=iSequence;
     2796               }
     2797#endif
    27872798               numberPrimalInfeasibilities_ ++;
    27882799          } else if (distanceDown < -primalTolerance) {
     
    27912802               if (infeasibility > relaxedToleranceP)
    27922803                    sumOfRelaxedPrimalInfeasibilities_ += infeasibility - relaxedToleranceP;
     2804#ifdef PRINT_INFEAS
     2805               if (numberPrimalInfeasibilities_<10) {
     2806                 seqInf[numberPrimalInfeasibilities_]=iSequence;
     2807               }
     2808#endif
    27932809               numberPrimalInfeasibilities_ ++;
    27942810          } else {
     
    28432859     numberDualInfeasibilitiesWithoutFree_ = numberDualInfeasibilities_ -
    28442860                                             numberDualInfeasibilitiesFree;
     2861#ifdef PRINT_INFEAS
     2862     if (numberPrimalInfeasibilities_<=10) {
     2863       printf("---------------start-----------\n");
     2864       if (!rowScale_) {
     2865         for (int i=0;i<numberPrimalInfeasibilities_;i++) {
     2866           int iSeq = seqInf[i];
     2867           double infeas;
     2868           if (solution_[iSeq]<lower_[iSeq])
     2869             infeas = lower_[iSeq]-solution_[iSeq];
     2870           else
     2871             infeas = solution_[iSeq]-upper_[iSeq];
     2872           if (iSeq<numberColumns_) {
     2873             printf("INF C%d %.10g <= %.10g <= %.10g - infeas %g\n",
     2874                    iSeq,lower_[iSeq],solution_[iSeq],upper_[iSeq],infeas);
     2875           } else {
     2876             printf("INF R%d %.10g <= %.10g <= %.10g - infeas %g\n",
     2877                    iSeq-numberColumns_,lower_[iSeq],solution_[iSeq],upper_[iSeq],infeas);
     2878           }
     2879         }
     2880       } else {
     2881         for (int i=0;i<numberPrimalInfeasibilities_;i++) {
     2882           int iSeq = seqInf[i];
     2883           double infeas;
     2884           if (solution_[iSeq]<lower_[iSeq])
     2885             infeas = lower_[iSeq]-solution_[iSeq];
     2886           else
     2887             infeas = solution_[iSeq]-upper_[iSeq];
     2888           double unscaled = infeas;
     2889           if (iSeq<numberColumns_) {
     2890             unscaled *= columnScale_[iSeq];
     2891             printf("INF C%d %.10g <= %.10g <= %.10g - infeas %g - unscaled %g\n",
     2892                    iSeq,lower_[iSeq],solution_[iSeq],upper_[iSeq],infeas,unscaled);
     2893           } else {
     2894             unscaled /= rowScale_[iSeq-numberColumns_];
     2895             printf("INF R%d %.10g <= %.10g <= %.10g - infeas %g - unscaled %g\n",
     2896                    iSeq-numberColumns_,lower_[iSeq],solution_[iSeq],upper_[iSeq],infeas,unscaled);
     2897           }
     2898         }
     2899       }
     2900     }
     2901#endif
    28452902     if (algorithm_ < 0 && firstFreeDual >= 0) {
    28462903          // dual
     
    30003057               newArrays = true;
    30013058               keepPivots = false;
    3002                printf("createrim a %d rows, %d maximum rows %d maxinternal\n",
    3003                       numberRows_, maximumRows_, maximumInternalRows_);
     3059               COIN_DETAIL_PRINT(printf("createrim a %d rows, %d maximum rows %d maxinternal\n",
     3060                                        numberRows_, maximumRows_, maximumInternalRows_));
    30043061               int oldMaximumRows = maximumInternalRows_;
    30053062               int oldMaximumColumns = maximumInternalColumns_;
     
    30153072               assert(maximumInternalRows_ == maximumRows_);
    30163073               assert(maximumInternalColumns_ == maximumColumns_);
    3017                printf("createrim b %d rows, %d maximum rows, %d maxinternal\n",
    3018                       numberRows_, maximumRows_, maximumInternalRows_);
     3074               COIN_DETAIL_PRINT(printf("createrim b %d rows, %d maximum rows, %d maxinternal\n",
     3075                                        numberRows_, maximumRows_, maximumInternalRows_));
    30193076               int numberTotal2 = (maximumInternalRows_ + maximumInternalColumns_) * 2;
    30203077               delete [] cost_;
     
    31653222                         }
    31663223                    }
    3167                     printf("small obj %g, large %g - rhs %g\n", smallestObj, largestObj, largestRhs);
     3224                    COIN_DETAIL_PRINT(printf("small obj %g, large %g - rhs %g\n", smallestObj, largestObj, largestRhs));
    31683225                    bool scalingDone = false;
    31693226                    // look at element range
     
    45434600     //assert (infiniteUpperC==infiniteUpper);
    45444601     if (fabs(maximumUp - maximumUpC) > 1.0e-12 * CoinMax(fabs(maximumUp), fabs(maximumUpC)))
    4545           printf("row %d comp up %g, true up %g\n", iRow,
    4546                  maximumUpC, maximumUp);
     4602          COIN_DETAIL_PRINT(printf("row %d comp up %g, true up %g\n", iRow,
     4603                                   maximumUpC, maximumUp));
    45474604     if (fabs(maximumDown - maximumDownC) > 1.0e-12 * CoinMax(fabs(maximumDown), fabs(maximumDownC)))
    4548           printf("row %d comp down %g, true down %g\n", iRow,
    4549                  maximumDownC, maximumDown);
     4605          COIN_DETAIL_PRINT(printf("row %d comp down %g, true down %g\n", iRow,
     4606                 maximumDownC, maximumDown));
    45504607     maximumUpC = maximumUp;
    45514608     maximumDownC = maximumDown;
     
    56445701     int savePerturbation = perturbation_;
    56455702     perturbation_ = 100;
    5646      int returnCode = static_cast<ClpSimplexPrimal *> (this)->primal(0, 1);
     5703     /*int returnCode =*/ static_cast<ClpSimplexPrimal *> (this)->primal(0, 1);
    56475704     if (problemStatus_ == 10) {
    56485705          //printf("Cleaning up with dual\n");
     
    56575714               if (upperOut_ > 0.0)
    56585715                    dualBound_ = 2.0 * upperOut_;
    5659                returnCode = static_cast<ClpSimplexDual *> (this)->dual(0, 1);
     5716               /*returnCode =*/ static_cast<ClpSimplexDual *> (this)->dual(0, 1);
    56605717               dualBound_ = saveBound;
    56615718          } else {
    5662                returnCode = static_cast<ClpSimplexPrimal *> (this)->primal(0, 1);
     5719                /*returnCode =*/ static_cast<ClpSimplexPrimal *> (this)->primal(0, 1);
    56635720          }
    56645721          setInitialDenseFactorization(denseFactorization);
     
    56945751     int savePerturbation = perturbation_;
    56955752     perturbation_ = 100;
    5696      int returnCode = static_cast<ClpSimplexPrimal *> (this)->primal(0, 1);
     5753     /*int returnCode =*/ static_cast<ClpSimplexPrimal *> (this)->primal(0, 1);
    56975754     if (problemStatus_ == 10) {
    56985755          //printf("Cleaning up with dual\n");
     
    57075764               if (upperOut_ > 0.0)
    57085765                    dualBound_ = 2.0 * upperOut_;
    5709                returnCode = static_cast<ClpSimplexDual *> (this)->dual(0, 1);
     5766               /*returnCode =*/ static_cast<ClpSimplexDual *> (this)->dual(0, 1);
    57105767               dualBound_ = saveBound;
    57115768          } else {
    5712                returnCode = static_cast<ClpSimplexPrimal *> (this)->primal(0, 1);
     5769                /*returnCode =*/ static_cast<ClpSimplexPrimal *> (this)->primal(0, 1);
    57135770          }
    57145771          setInitialDenseFactorization(denseFactorization);
     
    58015858#include "ClpCholeskyBase.hpp"
    58025859// Preference is WSSMP, UFL (just ordering), MUMPS, TAUCS then base
    5803 #if WSSMP_BARRIER
    58045860#include "ClpCholeskyWssmp.hpp"
    58055861#include "ClpCholeskyWssmpKKT.hpp"
    5806 #endif
    5807 #if UFL_BARRIER
    58085862#include "ClpCholeskyUfl.hpp"
    5809 #endif
    5810 #if MUMPS_BARRIER
    58115863#include "ClpCholeskyMumps.hpp"
    5812 #endif
    58135864#if TAUCS_BARRIER
    58145865#include "ClpCholeskyTaucs.hpp"
     
    58405891          barrier.setCholesky(cholesky);
    58415892     }
    5842 #elif UFL_BARRIER
     5893#elif defined(COIN_HAS_AMD) || defined(COIN_HAS_CHOLMOD)
    58435894     if (!doKKT) {
    58445895          ClpCholeskyUfl * cholesky = new ClpCholeskyUfl();
     
    58545905     ClpCholeskyTaucs * cholesky = new ClpCholeskyTaucs();
    58555906     barrier.setCholesky(cholesky);
    5856 #elif MUMPS_BARRIER
     5907#elifdef COIN_HAS_MUMPS
    58575908     if (!doKKT) {
    58585909          ClpCholeskyMumps * cholesky = new ClpCholeskyMumps();
     
    61636214int outDoubleArray(double * array, int length, FILE * fp)
    61646215{
    6165      int numberWritten;
     6216     size_t numberWritten;
    61666217     if (array && length) {
    61676218          numberWritten = fwrite(&length, sizeof(int), 1, fp);
     
    61696220               return 1;
    61706221          numberWritten = fwrite(array, sizeof(double), length, fp);
    6171           if (numberWritten != length)
     6222          if (numberWritten != static_cast<size_t>(length))
    61726223               return 1;
    61736224     } else {
     
    61866237     if (fp) {
    61876238          Clp_scalars scalars;
    6188           CoinBigIndex numberWritten;
     6239          size_t numberWritten;
    61896240          // Fill in scalars
    61906241          scalars.optimizationDirection = optimizationDirection_;
     
    62206271          if (numberWritten != 1)
    62216272               return 1;
    6222           CoinBigIndex length;
     6273          size_t length;
    62236274#ifndef CLP_NO_STD
    62246275          int i;
     
    62986349               }
    62996350               numberWritten = fwrite(array, lengthNames_ + 1, numberRows_, fp);
    6300                if (numberWritten != numberRows_)
     6351               if (numberWritten != static_cast<size_t>(numberRows_))
    63016352                    return 1;
    63026353               put = array;
     
    63086359               }
    63096360               numberWritten = fwrite(array, lengthNames_ + 1, numberColumns_, fp);
    6310                if (numberWritten != numberColumns_)
     6361               if (numberWritten != static_cast<size_t>(numberColumns_))
    63116362                    return 1;
    63126363               delete [] array;
     
    63186369               numberWritten = fwrite(&marker, sizeof(int), 1, fp);
    63196370               numberWritten = fwrite(integerType_, 1, numberColumns_, fp);
    6320                if (numberWritten != numberColumns_)
     6371               if (numberWritten != static_cast<size_t>(numberColumns_))
    63216372                    return 1;
    63226373          } else {
     
    63446395          numberWritten = fwrite(matrix_->getVectorStarts(),
    63456396                                 sizeof(int), numberColumns_ + 1, fp);
    6346           if (numberWritten != numberColumns_ + 1)
     6397          if (numberWritten != static_cast<size_t>(numberColumns_) + 1)
    63476398               return 1;
    63486399          numberWritten = fwrite(matrix_->getVectorLengths(),
    63496400                                 sizeof(int), numberColumns_, fp);
    6350           if (numberWritten != numberColumns_)
     6401          if (numberWritten != static_cast<size_t>(numberColumns_))
    63516402               return 1;
    63526403          // finished
     
    63606411int inDoubleArray(double * &array, int length, FILE * fp)
    63616412{
    6362      int numberRead;
     6413     size_t numberRead;
    63636414     int length2;
    63646415     numberRead = fread(&length2, sizeof(int), 1, fp);
     
    63716422          array = new double[length];
    63726423          numberRead = fread(array, sizeof(double), length, fp);
    6373           if (numberRead != length)
     6424          if (numberRead != static_cast<size_t>(length))
    63746425               return 1;
    63756426     }
     
    63996450          factorization_->sparseThreshold(1);
    64006451          Clp_scalars scalars;
    6401           CoinBigIndex numberRead;
     6452          size_t numberRead;
    64026453
    64036454          // get scalars
     
    64986549               status_ = new char unsigned[length];
    64996550               numberRead = fread(status_, sizeof(char), length, fp);
    6500                if (numberRead != length)
     6551               if (numberRead != static_cast<size_t>(length))
    65016552                    return 1;
    65026553          }
     
    65076558               char * get = array;
    65086559               numberRead = fread(array, lengthNames_ + 1, numberRows_, fp);
    6509                if (numberRead != numberRows_)
     6560               if (numberRead != static_cast<size_t>(numberRows_))
    65106561                    return 1;
    65116562               rowNames_ = std::vector&