Changeset 1481


Ignore:
Timestamp:
Jun 2, 2019 7:21:56 PM (5 months ago)
Author:
lou
Message:

Merge trunk revisions 1431:1480 into autotools-update.

Location:
branches/autotools-update/Cgl
Files:
57 edited
2 copied

Legend:

Unmodified
Added
Removed
  • branches/autotools-update/Cgl

  • branches/autotools-update/Cgl/MSVisualStudio/v10/CglUnitTest/CglUnitTest.vcxproj

    r1100 r1481  
    8989    <ClCompile>
    9090      <Optimization>Disabled</Optimization>
    91       <AdditionalIncludeDirectories>..\..\..\src\CglClique;..\..\..\src\CglDuplicateRow;..\..\..\src\CglFlowCover;..\..\..\src\CglGomory;..\..\..\src\CglKnapsackCover;..\..\..\src\CglLandP;..\..\..\src\CglMixedIntegerRounding;..\..\..\src\CglMixedIntegerRounding2;..\..\..\src\CglOddHole;..\..\..\src\CglPreProcess;..\..\..\src\CglProbing;..\..\..\src\CglRedSplit;..\..\..\src\CglResidualCapacity;..\..\..\src\CglSimpleRounding;..\..\..\src\CglTwomir;..\..\..\src;..\..\..\..\Osi\src\Osi;..\..\..\..\Clp\src\OsiClp;..\..\..\..\Clp\src;..\..\..\..\CoinUtils\src;..\..\..\..\BuildTools\headers;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     91      <AdditionalIncludeDirectories>..\..\..\src\CglClique;..\..\..\src\CglDuplicateRow;..\..\..\src\CglFlowCover;..\..\..\src\CglGomory;..\..\..\src\CglKnapsackCover;..\..\..\src\CglLandP;..\..\..\src\CglMixedIntegerRounding;..\..\..\src\CglMixedIntegerRounding2;..\..\..\src\CglOddHole;..\..\..\src\CglPreProcess;..\..\..\src\CglProbing;..\..\..\src\CglRedSplit;..\..\..\src\CglRedSplit2;..\..\..\src\CglResidualCapacity;..\..\..\src\CglSimpleRounding;..\..\..\src\CglTwomir;..\..\..\src\CglZeroHalf;..\..\..\src;..\..\..\..\Osi\src\Osi;..\..\..\..\Clp\src\OsiClp;..\..\..\..\Clp\src;..\..\..\..\CoinUtils\src;..\..\..\..\BuildTools\headers;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    9292      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;COIN_HAS_OSICLP;SAMPLEDIR="..\\..\\..\\..\\Data\\Sample";TESTDIR="..\\..\\..\\test\\CglTestData";%(PreprocessorDefinitions)</PreprocessorDefinitions>
    9393      <MinimalRebuild>true</MinimalRebuild>
     
    114114      <Optimization>MaxSpeed</Optimization>
    115115      <IntrinsicFunctions>true</IntrinsicFunctions>
    116       <AdditionalIncludeDirectories>..\..\..\src\CglClique;..\..\..\src\CglDuplicateRow;..\..\..\src\CglFlowCover;..\..\..\src\CglGomory;..\..\..\src\CglKnapsackCover;..\..\..\src\CglLandP;..\..\..\src\CglMixedIntegerRounding;..\..\..\src\CglMixedIntegerRounding2;..\..\..\src\CglOddHole;..\..\..\src\CglPreProcess;..\..\..\src\CglProbing;..\..\..\src\CglRedSplit;..\..\..\src\CglResidualCapacity;..\..\..\src\CglSimpleRounding;..\..\..\src\CglTwomir;..\..\..\src;..\..\..\..\Osi\src\Osi;..\..\..\..\Clp\src\OsiClp;..\..\..\..\Clp\src;..\..\..\..\CoinUtils\src;..\..\..\..\BuildTools\headers;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     116      <AdditionalIncludeDirectories>..\..\..\src\CglClique;..\..\..\src\CglDuplicateRow;..\..\..\src\CglFlowCover;..\..\..\src\CglGomory;..\..\..\src\CglKnapsackCover;..\..\..\src\CglLandP;..\..\..\src\CglMixedIntegerRounding;..\..\..\src\CglMixedIntegerRounding2;..\..\..\src\CglOddHole;..\..\..\src\CglPreProcess;..\..\..\src\CglProbing;..\..\..\src\CglRedSplit;..\..\..\src\CglRedSplit2;..\..\..\src\CglResidualCapacity;..\..\..\src\CglSimpleRounding;..\..\..\src\CglTwomir;..\..\..\src\CglZeroHalf;..\..\..\src;..\..\..\..\Osi\src\Osi;..\..\..\..\Clp\src\OsiClp;..\..\..\..\Clp\src;..\..\..\..\CoinUtils\src;..\..\..\..\BuildTools\headers;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    117117      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;COIN_HAS_OSICLP;SAMPLEDIR="..\\..\\..\\..\\Data\\Sample";TESTDIR="..\\..\\..\\test\\CglTestData";%(PreprocessorDefinitions)</PreprocessorDefinitions>
    118118      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
     
    142142    <ClCompile>
    143143      <Optimization>Disabled</Optimization>
    144       <AdditionalIncludeDirectories>..\..\..\src\CglClique;..\..\..\src\CglDuplicateRow;..\..\..\src\CglFlowCover;..\..\..\src\CglGomory;..\..\..\src\CglKnapsackCover;..\..\..\src\CglLandP;..\..\..\src\CglMixedIntegerRounding;..\..\..\src\CglMixedIntegerRounding2;..\..\..\src\CglOddHole;..\..\..\src\CglPreProcess;..\..\..\src\CglProbing;..\..\..\src\CglRedSplit;..\..\..\src\CglResidualCapacity;..\..\..\src\CglSimpleRounding;..\..\..\src\CglTwomir;..\..\..\src;..\..\..\..\Osi\src\Osi;..\..\..\..\Clp\src\OsiClp;..\..\..\..\Clp\src;..\..\..\..\CoinUtils\src;..\..\..\..\BuildTools\headers;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     144      <AdditionalIncludeDirectories>..\..\..\src\CglClique;..\..\..\src\CglDuplicateRow;..\..\..\src\CglFlowCover;..\..\..\src\CglGomory;..\..\..\src\CglKnapsackCover;..\..\..\src\CglLandP;..\..\..\src\CglMixedIntegerRounding;..\..\..\src\CglMixedIntegerRounding2;..\..\..\src\CglOddHole;..\..\..\src\CglPreProcess;..\..\..\src\CglProbing;..\..\..\src\CglRedSplit;..\..\..\src\CglRedSplit2;..\..\..\src\CglResidualCapacity;..\..\..\src\CglSimpleRounding;..\..\..\src\CglTwomir;..\..\..\src\CglZeroHalf;..\..\..\src;..\..\..\..\Osi\src\Osi;..\..\..\..\Clp\src\OsiClp;..\..\..\..\Clp\src;..\..\..\..\CoinUtils\src;..\..\..\..\BuildTools\headers;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    145145      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;COIN_HAS_OSICLP;SAMPLEDIR="..\\..\\..\\..\\Data\\Sample";TESTDIR="..\\..\\..\\test\\CglTestData";%(PreprocessorDefinitions)</PreprocessorDefinitions>
    146146      <MinimalRebuild>true</MinimalRebuild>
     
    170170      <Optimization>MaxSpeed</Optimization>
    171171      <IntrinsicFunctions>true</IntrinsicFunctions>
    172       <AdditionalIncludeDirectories>..\..\..\src\CglClique;..\..\..\src\CglDuplicateRow;..\..\..\src\CglFlowCover;..\..\..\src\CglGomory;..\..\..\src\CglKnapsackCover;..\..\..\src\CglLandP;..\..\..\src\CglMixedIntegerRounding;..\..\..\src\CglMixedIntegerRounding2;..\..\..\src\CglOddHole;..\..\..\src\CglPreProcess;..\..\..\src\CglProbing;..\..\..\src\CglRedSplit;..\..\..\src\CglResidualCapacity;..\..\..\src\CglSimpleRounding;..\..\..\src\CglTwomir;..\..\..\src;..\..\..\..\Osi\src\Osi;..\..\..\..\Clp\src\OsiClp;..\..\..\..\Clp\src;..\..\..\..\CoinUtils\src;..\..\..\..\BuildTools\headers;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     172      <AdditionalIncludeDirectories>..\..\..\src\CglClique;..\..\..\src\CglDuplicateRow;..\..\..\src\CglFlowCover;..\..\..\src\CglGomory;..\..\..\src\CglKnapsackCover;..\..\..\src\CglLandP;..\..\..\src\CglMixedIntegerRounding;..\..\..\src\CglMixedIntegerRounding2;..\..\..\src\CglOddHole;..\..\..\src\CglPreProcess;..\..\..\src\CglProbing;..\..\..\src\CglRedSplit;..\..\..\src\CglRedSplit2;..\..\..\src\CglResidualCapacity;..\..\..\src\CglSimpleRounding;..\..\..\src\CglTwomir;..\..\..\src\CglZeroHalf;..\..\..\src;..\..\..\..\Osi\src\Osi;..\..\..\..\Clp\src\OsiClp;..\..\..\..\Clp\src;..\..\..\..\CoinUtils\src;..\..\..\..\BuildTools\headers;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    173173      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;COIN_HAS_OSICLP;SAMPLEDIR="..\\..\\..\\..\\Data\\Sample";TESTDIR="..\\..\\..\\test\\CglTestData";%(PreprocessorDefinitions)</PreprocessorDefinitions>
    174174      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
  • branches/autotools-update/Cgl/MSVisualStudio/v9/CglUnitTest/CglUnitTest.vcproj

    r893 r1481  
    4545                                Name="VCCLCompilerTool"
    4646                                Optimization="0"
    47                                 AdditionalIncludeDirectories="..\..\..\src\CglClique;..\..\..\src\CglDuplicateRow;..\..\..\src\CglFlowCover;..\..\..\src\CglGomory;..\..\..\src\CglKnapsackCover;..\..\..\src\CglLandP;..\..\..\src\CglMixedIntegerRounding;..\..\..\src\CglMixedIntegerRounding2;..\..\..\src\CglOddHole;..\..\..\src\CglPreProcess;..\..\..\src\CglProbing;..\..\..\src\CglRedSplit;..\..\..\src\CglResidualCapacity;..\..\..\src\CglSimpleRounding;..\..\..\src\CglTwomir;..\..\..\src;..\..\..\..\Osi\src\Osi;..\..\..\..\Clp\src\OsiClp;..\..\..\..\Clp\src;..\..\..\..\CoinUtils\src;..\..\..\..\BuildTools\headers"
     47                                AdditionalIncludeDirectories="..\..\..\src\CglClique;..\..\..\src\CglDuplicateRow;..\..\..\src\CglFlowCover;..\..\..\src\CglGomory;..\..\..\src\CglKnapsackCover;..\..\..\src\CglLandP;..\..\..\src\CglMixedIntegerRounding;..\..\..\src\CglMixedIntegerRounding2;..\..\..\src\CglOddHole;..\..\..\src\CglPreProcess;..\..\..\src\CglProbing;..\..\..\src\CglRedSplit;..\..\..\src\CglRedSplit2;..\..\..\src\CglResidualCapacity;..\..\..\src\CglSimpleRounding;..\..\..\src\CglZeroHalf;..\..\..\src\CglTwomir;..\..\..\src;..\..\..\..\Osi\src\Osi;..\..\..\..\Clp\src\OsiClp;..\..\..\..\Clp\src;..\..\..\..\CoinUtils\src;..\..\..\..\BuildTools\headers"
    4848                                PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;COIN_HAS_OSICLP;SAMPLEDIR=\&quot;..\\..\\..\\..\\Data\\Sample\&quot;;TESTDIR=\&quot;..\\..\\..\\test\\CglTestData\&quot;"
    4949                                MinimalRebuild="true"
     
    119119                                Optimization="2"
    120120                                EnableIntrinsicFunctions="true"
    121                                 AdditionalIncludeDirectories="..\..\..\src\CglClique;..\..\..\src\CglDuplicateRow;..\..\..\src\CglFlowCover;..\..\..\src\CglGomory;..\..\..\src\CglKnapsackCover;..\..\..\src\CglLandP;..\..\..\src\CglMixedIntegerRounding;..\..\..\src\CglMixedIntegerRounding2;..\..\..\src\CglOddHole;..\..\..\src\CglPreProcess;..\..\..\src\CglProbing;..\..\..\src\CglRedSplit;..\..\..\src\CglResidualCapacity;..\..\..\src\CglSimpleRounding;..\..\..\src\CglTwomir;..\..\..\src;..\..\..\..\Osi\src\Osi;..\..\..\..\Clp\src\OsiClp;..\..\..\..\Clp\src;..\..\..\..\CoinUtils\src;..\..\..\..\BuildTools\headers"
     121                                AdditionalIncludeDirectories="..\..\..\src\CglClique;..\..\..\src\CglDuplicateRow;..\..\..\src\CglFlowCover;..\..\..\src\CglGomory;..\..\..\src\CglKnapsackCover;..\..\..\src\CglLandP;..\..\..\src\CglMixedIntegerRounding;..\..\..\src\CglMixedIntegerRounding2;..\..\..\src\CglOddHole;..\..\..\src\CglPreProcess;..\..\..\src\CglProbing;..\..\..\src\CglRedSplit;..\..\..\src\CglRedSplit2;..\..\..\src\CglResidualCapacity;..\..\..\src\CglSimpleRounding;..\..\..\src\CglTwomir;..\..\..\src\CglZeroHalf;..\..\..\src;..\..\..\..\Osi\src\Osi;..\..\..\..\Clp\src\OsiClp;..\..\..\..\Clp\src;..\..\..\..\CoinUtils\src;..\..\..\..\BuildTools\headers"
    122122                                PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;COIN_HAS_OSICLP;SAMPLEDIR=\&quot;..\\..\\..\\..\\Data\\Sample\&quot;;TESTDIR=\&quot;..\\..\\..\\test\\CglTestData\&quot;"
    123123                                RuntimeLibrary="2"
     
    193193                                Name="VCCLCompilerTool"
    194194                                Optimization="0"
    195                                 AdditionalIncludeDirectories="..\..\..\src\CglClique;..\..\..\src\CglDuplicateRow;..\..\..\src\CglFlowCover;..\..\..\src\CglGomory;..\..\..\src\CglKnapsackCover;..\..\..\src\CglLandP;..\..\..\src\CglMixedIntegerRounding;..\..\..\src\CglMixedIntegerRounding2;..\..\..\src\CglOddHole;..\..\..\src\CglPreProcess;..\..\..\src\CglProbing;..\..\..\src\CglRedSplit;..\..\..\src\CglResidualCapacity;..\..\..\src\CglSimpleRounding;..\..\..\src\CglTwomir;..\..\..\src;..\..\..\..\Osi\src\Osi;..\..\..\..\Clp\src\OsiClp;..\..\..\..\Clp\src;..\..\..\..\CoinUtils\src;..\..\..\..\BuildTools\headers"
     195                                AdditionalIncludeDirectories="..\..\..\src\CglClique;..\..\..\src\CglDuplicateRow;..\..\..\src\CglFlowCover;..\..\..\src\CglGomory;..\..\..\src\CglKnapsackCover;..\..\..\src\CglLandP;..\..\..\src\CglMixedIntegerRounding;..\..\..\src\CglMixedIntegerRounding2;..\..\..\src\CglOddHole;..\..\..\src\CglPreProcess;..\..\..\src\CglProbing;..\..\..\src\CglRedSplit;..\..\..\src\CglRedSplit2;..\..\..\src\CglResidualCapacity;..\..\..\src\CglSimpleRounding;..\..\..\src\CglTwomir;..\..\..\src\CglZeroHalf;..\..\..\src;..\..\..\..\Osi\src\Osi;..\..\..\..\Clp\src\OsiClp;..\..\..\..\Clp\src;..\..\..\..\CoinUtils\src;..\..\..\..\BuildTools\headers"
    196196                                PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;COIN_HAS_OSICLP;SAMPLEDIR=\&quot;..\\..\\..\\..\\Data\\Sample\&quot;;TESTDIR=\&quot;..\\..\\..\\test\\CglTestData\&quot;"
    197197                                MinimalRebuild="true"
     
    268268                                Optimization="2"
    269269                                EnableIntrinsicFunctions="true"
    270                                 AdditionalIncludeDirectories="..\..\..\src\CglClique;..\..\..\src\CglDuplicateRow;..\..\..\src\CglFlowCover;..\..\..\src\CglGomory;..\..\..\src\CglKnapsackCover;..\..\..\src\CglLandP;..\..\..\src\CglMixedIntegerRounding;..\..\..\src\CglMixedIntegerRounding2;..\..\..\src\CglOddHole;..\..\..\src\CglPreProcess;..\..\..\src\CglProbing;..\..\..\src\CglRedSplit;..\..\..\src\CglResidualCapacity;..\..\..\src\CglSimpleRounding;..\..\..\src\CglTwomir;..\..\..\src;..\..\..\..\Osi\src\Osi;..\..\..\..\Clp\src\OsiClp;..\..\..\..\Clp\src;..\..\..\..\CoinUtils\src;..\..\..\..\BuildTools\headers"
     270                                AdditionalIncludeDirectories="..\..\..\src\CglClique;..\..\..\src\CglDuplicateRow;..\..\..\src\CglFlowCover;..\..\..\src\CglGomory;..\..\..\src\CglKnapsackCover;..\..\..\src\CglLandP;..\..\..\src\CglMixedIntegerRounding;..\..\..\src\CglMixedIntegerRounding2;..\..\..\src\CglOddHole;..\..\..\src\CglPreProcess;..\..\..\src\CglProbing;..\..\..\src\CglRedSplit;..\..\..\src\CglRedSplit2;..\..\..\src\CglResidualCapacity;..\..\..\src\CglSimpleRounding;..\..\..\src\CglTwomir;..\..\..\src\CglZeroHalf;..\..\..\src;..\..\..\..\Osi\src\Osi;..\..\..\..\Clp\src\OsiClp;..\..\..\..\Clp\src;..\..\..\..\CoinUtils\src;..\..\..\..\BuildTools\headers"
    271271                                PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;COIN_HAS_OSICLP;SAMPLEDIR=\&quot;..\\..\\..\\..\\Data\\Sample\&quot;;TESTDIR=\&quot;..\\..\\..\\test\\CglTestData\&quot;"
    272272                                RuntimeLibrary="2"
  • branches/autotools-update/Cgl/Makefile.in

    r1433 r1481  
    1 # Makefile.in generated by automake 1.15.1 from Makefile.am.
     1# Makefile.in generated by automake 1.16.1 from Makefile.am.
    22# @configure_input@
    33
    4 # Copyright (C) 1994-2017 Free Software Foundation, Inc.
     4# Copyright (C) 1994-2018 Free Software Foundation, Inc.
    55
    66# This Makefile.in is free software; the Free Software Foundation
     
    432432            $(SHELL) ./config.status;; \
    433433          *) \
    434             echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe)'; \
    435             cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe);; \
     434            echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__maybe_remake_depfiles)'; \
     435            cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__maybe_remake_depfiles);; \
    436436        esac;
    437437$(srcdir)/BuildTools/Makemain.inc $(am__empty):
  • branches/autotools-update/Cgl/README

    r908 r1481  
    1 CUT GENERATION LIBRARY README
    2 =============================
    3 
    4 In this document, the following names are used:
    5 
    6 1. 'coin-Cgl' is the full path to the directory in which you have
    7    dowloaded Cgl.
    8 
    9 2. 'build' is the full path to the directory used for the installation
    10    of Cgl. It might be coin-Cgl or any other directory of your choosing.
    11 
    12 
    13 OVERVIEW
    14 ========
    15 
    16 Welcome to the COIN-OR Cut Generator Library (Cgl). Cgl is
    17 distributed under the Eclipse Public License Version 1.0 and is freely
    18 redistributable. All source code and documentation is copyright
    19 by International Business Machines Corporation and others.
    20 This README file may be distributed freely.
    21 
    22 The COIN-OR Cut Generation Library is a collection of cut
    23 generators that can be used with other COIN-OR projects that make
    24 use of cuts, such as, among others, the linear solver Clp or the
    25 mixed integer linear programming solvers Cbc or BCP.
    26 
    27 Each cut generator is in a separate directory with its own maintainer.
    28 Maintainer names are listed in the AUTHORS file in the Cgl directory.
    29 For more information, see the Cgl Trac page (see below).
    30 
    31 
    32 CGL TRAC PAGE
    33 =============
    34 
    35 https://projects.coin-or.org/Cgl
    36 
    37 
    38 INSTALLATION
    39 ============
    40 
    41 If you have downloaded the Cgl package in the local directory coin-Cgl,
    42 please see the INSTALL file in coin-Cgl for a guide to install this package.
    43 
    44 If you have obtained Cgl by downloading another package, Cgl should be
    45 installed as part of the installation of that package. See the INSTALL
    46 file in the main directory of the package.
    47 
    48 
    49 SUPPORT
    50 =======
    51 
    52 1. Authors
    53 
    54    See the AUTHORS file.
    55 
    56 2. Project Managers
    57 
    58    Robin Lougee-Heimer, robinlh@us.ibm.com
    59    Francois Margot, fmargot@andrew.cmu.edu
    60 
    61 3. Mailing List
    62 
    63    Cgl users should use the Cgl mailing list. To subscribe, go to
    64    http://list.coin-or.org/mailman/listinfo/cgl
    65 
    66 4. Bug Reports
    67 
    68    Bug reports should be posted to the Cgl mailing list and/or on the
    69    Cgl Trac page.
     1This is the Cgl project. For information on the purpose of
     2this project please visit https://github.com/coin-or/Cgl
  • branches/autotools-update/Cgl/compile

    r1419 r1481  
    1 #! /bin/sh
     1#!/usr/bin/sh
    22# Wrapper for compilers which do not understand '-c -o'.
    33
  • branches/autotools-update/Cgl/config.guess

    r1432 r1481  
    1 #! /bin/sh
     1#!/usr/bin/sh
    22# Attempt to guess a canonical system name.
    33#   Copyright 1992-2016 Free Software Foundation, Inc.
  • branches/autotools-update/Cgl/config.sub

    r1432 r1481  
    1 #! /bin/sh
     1#!/usr/bin/sh
    22# Configuration validation subroutine script.
    33#   Copyright 1992-2016 Free Software Foundation, Inc.
  • branches/autotools-update/Cgl/configure

    r1433 r1481  
    603603
    604604ac_unique_file="src/CglCommon/CglMessage.hpp"
    605 ac_default_prefix=`pwd`
    606605# Factoring default headers for most tests.
    607606ac_includes_default="\
     
    735734AMDEP_FALSE
    736735AMDEP_TRUE
    737 am__quote
    738736am__include
    739737DEPDIR
     
    824822PACKAGE_NAME
    825823PATH_SEPARATOR
    826 SHELL'
     824SHELL
     825am__quote'
    827826ac_subst_files=''
    828827ac_user_opts='
     
    27232722
    27242723
    2725 am__api_version='1.15'
     2724am__api_version='1.16'
    27262725
    27272726# Find a good install program.  We prefer a C program (faster),
     
    32653264
    32663265
    3267 # Where should everything be installed by default?  The COIN default is to
    3268 # install directly into subdirectories of the directory where configure is
    3269 # run. The default would be to install under /usr/local.
    3270 
    3271 
    3272 
    32733266# Change the default compiler flags. This needs to run before
    32743267# AC_CANONICAL_BUILD.
     
    33863379# For better backward compatibility.  To be removed once Automake 1.9.x
    33873380# dies out for good.  For more background, see:
    3388 # <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
    3389 # <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
     3381# <https://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
     3382# <https://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
    33903383mkdir_p='$(MKDIR_P)'
    33913384
     
    34383431
    34393432You can download and install GNU coreutils to get an 'rm' implementation
    3440 that behaves properly: <http://www.gnu.org/software/coreutils/>.
     3433that behaves properly: <https://www.gnu.org/software/coreutils/>.
    34413434
    34423435If you want to complete the configuration process using your problematic
     
    34873480ac_config_commands="$ac_config_commands depfiles"
    34883481
    3489 
    3490 am_make=${MAKE-make}
    3491 cat > confinc << 'END'
     3482{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} supports the include directive" >&5
     3483$as_echo_n "checking whether ${MAKE-make} supports the include directive... " >&6; }
     3484cat > confinc.mk << 'END'
    34923485am__doit:
    3493         @echo this is the am__doit target
     3486        @echo this is the am__doit target >confinc.out
    34943487.PHONY: am__doit
    34953488END
    3496 # If we don't find an include directive, just comment out the code.
    3497 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5
    3498 $as_echo_n "checking for style of include used by $am_make... " >&6; }
    34993489am__include="#"
    35003490am__quote=
    3501 _am_result=none
    3502 # First try GNU make style include.
    3503 echo "include confinc" > confmf
    3504 # Ignore all kinds of additional output from 'make'.
    3505 case `$am_make -s -f confmf 2> /dev/null` in #(
    3506 *the\ am__doit\ target*)
    3507   am__include=include
    3508   am__quote=
    3509   _am_result=GNU
    3510   ;;
     3491# BSD make does it like this.
     3492echo '.include "confinc.mk" # ignored' > confmf.BSD
     3493# Other make implementations (GNU, Solaris 10, AIX) do it like this.
     3494echo 'include confinc.mk # ignored' > confmf.GNU
     3495_am_result=no
     3496for s in GNU BSD; do
     3497  { echo "$as_me:$LINENO: ${MAKE-make} -f confmf.$s && cat confinc.out" >&5
     3498   (${MAKE-make} -f confmf.$s && cat confinc.out) >&5 2>&5
     3499   ac_status=$?
     3500   echo "$as_me:$LINENO: \$? = $ac_status" >&5
     3501   (exit $ac_status); }
     3502  case $?:`cat confinc.out 2>/dev/null` in #(
     3503  '0:this is the am__doit target') :
     3504    case $s in #(
     3505  BSD) :
     3506    am__include='.include' am__quote='"' ;; #(
     3507  *) :
     3508    am__include='include' am__quote='' ;;
     3509esac ;; #(
     3510  *) :
     3511     ;;
    35113512esac
    3512 # Now try BSD make style include.
    3513 if test "$am__include" = "#"; then
    3514    echo '.include "confinc"' > confmf
    3515    case `$am_make -s -f confmf 2> /dev/null` in #(
    3516    *the\ am__doit\ target*)
    3517      am__include=.include
    3518      am__quote="\""
    3519      _am_result=BSD
    3520      ;;
    3521    esac
    3522 fi
    3523 
    3524 
    3525 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5
    3526 $as_echo "$_am_result" >&6; }
    3527 rm -f confinc confmf
     3513  if test "$am__include" != "#"; then
     3514    _am_result="yes ($s style)"
     3515    break
     3516  fi
     3517done
     3518rm -f confinc.* confmf.*
     3519{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${_am_result}" >&5
     3520$as_echo "${_am_result}" >&6; }
    35283521
    35293522# Check whether --enable-dependency-tracking was given.
     
    1690516898  case $coin_has_coinutils in
    1690616899    requested | build )
    16907       if test -n "$PKG_CONFIG" ; then
     16900      if test -n "$PKG_CONFIG" -a "" != skip ; then
    1690816901        if test $coin_has_coinutils = build ; then
    1690916902             pcfile=coincoinutils
     
    1692916922
    1693016923      else
    16931         coin_has_coinutils=yes
     16924        coin_has_coinutils=no
    1693216925        # AC_MSG_WARN([skipped check via pkgconf as no pkgconf available])
    1693316926      fi
     
    1716717160  case $coin_has_osi in
    1716817161    requested | build )
    17169       if test -n "$PKG_CONFIG" ; then
     17162      if test -n "$PKG_CONFIG" -a "" != skip ; then
    1717017163        if test $coin_has_osi = build ; then
    1717117164             pcfile=coinosi
     
    1719117184
    1719217185      else
    17193         coin_has_osi=yes
     17186        coin_has_osi=no
    1719417187        # AC_MSG_WARN([skipped check via pkgconf as no pkgconf available])
    1719517188      fi
     
    1743417427  case $coin_has_osiclp in
    1743517428    requested | build )
    17436       if test -n "$PKG_CONFIG" ; then
     17429      if test -n "$PKG_CONFIG" -a "osi-clp" != skip ; then
    1743717430        pcfile="osi-clp"
    1743817431
     
    1745417447
    1745517448      else
    17456         coin_has_osiclp=yes
     17449        coin_has_osiclp=no
    1745717450        # AC_MSG_WARN([skipped check via pkgconf as no pkgconf available])
    1745817451      fi
     
    1756217555        case $CC in */compile\ cl | cl | */cl | */compile\ icl | icl | */icl )
    1756317556          libexport_attribute="__declspec(dllimport)"
     17557          if test "$enable_static" = yes ; then
     17558            as_fn_error $? "Cannot do DLL and static LIB builds simultaneously. Do not add --enable-static without --disable-shared." "$LINENO" 5
     17559          fi
    1756417560        esac
    1756517561      fi
     
    1775517751  case $coin_has_osicpx in
    1775617752    requested | build )
    17757       if test -n "$PKG_CONFIG" ; then
     17753      if test -n "$PKG_CONFIG" -a "osi-cplex" != skip ; then
    1775817754        pcfile="osi-cplex"
    1775917755
     
    1777517771
    1777617772      else
    17777         coin_has_osicpx=yes
     17773        coin_has_osicpx=no
    1777817774        # AC_MSG_WARN([skipped check via pkgconf as no pkgconf available])
    1777917775      fi
     
    1800918005  case $coin_has_osiglpk in
    1801018006    requested | build )
    18011       if test -n "$PKG_CONFIG" ; then
     18007      if test -n "$PKG_CONFIG" -a "osi-glpk" != skip ; then
    1801218008        pcfile="osi-glpk"
    1801318009
     
    1802918025
    1803018026      else
    18031         coin_has_osiglpk=yes
     18027        coin_has_osiglpk=no
    1803218028        # AC_MSG_WARN([skipped check via pkgconf as no pkgconf available])
    1803318029      fi
     
    1826318259  case $coin_has_osigrb in
    1826418260    requested | build )
    18265       if test -n "$PKG_CONFIG" ; then
     18261      if test -n "$PKG_CONFIG" -a "osi-gurobi" != skip ; then
    1826618262        pcfile="osi-gurobi"
    1826718263
     
    1828318279
    1828418280      else
    18285         coin_has_osigrb=yes
     18281        coin_has_osigrb=no
    1828618282        # AC_MSG_WARN([skipped check via pkgconf as no pkgconf available])
    1828718283      fi
     
    1851718513  case $coin_has_osimsk in
    1851818514    requested | build )
    18519       if test -n "$PKG_CONFIG" ; then
     18515      if test -n "$PKG_CONFIG" -a "osi-mosek" != skip ; then
    1852018516        pcfile="osi-mosek"
    1852118517
     
    1853718533
    1853818534      else
    18539         coin_has_osimsk=yes
     18535        coin_has_osimsk=no
    1854018536        # AC_MSG_WARN([skipped check via pkgconf as no pkgconf available])
    1854118537      fi
     
    1877118767  case $coin_has_osixpr in
    1877218768    requested | build )
    18773       if test -n "$PKG_CONFIG" ; then
     18769      if test -n "$PKG_CONFIG" -a "osi-xpress" != skip ; then
    1877418770        pcfile="osi-xpress"
    1877518771
     
    1879118787
    1879218788      else
    18793         coin_has_osixpr=yes
     18789        coin_has_osixpr=no
    1879418790        # AC_MSG_WARN([skipped check via pkgconf as no pkgconf available])
    1879518791      fi
     
    1902519021  case $coin_has_osivol in
    1902619022    requested | build )
    19027       if test -n "$PKG_CONFIG" ; then
     19023      if test -n "$PKG_CONFIG" -a "osi-vol" != skip ; then
    1902819024        pcfile="osi-vol"
    1902919025
     
    1904519041
    1904619042      else
    19047         coin_has_osivol=yes
     19043        coin_has_osivol=no
    1904819044        # AC_MSG_WARN([skipped check via pkgconf as no pkgconf available])
    1904919045      fi
     
    1927919275  case $coin_has_osidylp in
    1928019276    requested | build )
    19281       if test -n "$PKG_CONFIG" ; then
     19277      if test -n "$PKG_CONFIG" -a "osi-dylp" != skip ; then
    1928219278        pcfile="osi-dylp"
    1928319279
     
    1929919295
    1930019296      else
    19301         coin_has_osidylp=yes
     19297        coin_has_osidylp=no
    1930219298        # AC_MSG_WARN([skipped check via pkgconf as no pkgconf available])
    1930319299      fi
     
    1953319529  case $coin_has_osispx in
    1953419530    requested | build )
    19535       if test -n "$PKG_CONFIG" ; then
     19531      if test -n "$PKG_CONFIG" -a "osi-soplex" != skip ; then
    1953619532        pcfile="osi-soplex"
    1953719533
     
    1955319549
    1955419550      else
    19555         coin_has_osispx=yes
     19551        coin_has_osispx=no
    1955619552        # AC_MSG_WARN([skipped check via pkgconf as no pkgconf available])
    1955719553      fi
     
    1965319649        case $CC in */compile\ cl | cl | */cl | */compile\ icl | icl | */icl )
    1965419650          libexport_attribute="__declspec(dllimport)"
     19651          if test "$enable_static" = yes ; then
     19652            as_fn_error $? "Cannot do DLL and static LIB builds simultaneously. Do not add --enable-static without --disable-shared." "$LINENO" 5
     19653          fi
    1965519654        esac
    1965619655      fi
     
    1981719816  case $coin_has_sample in
    1981819817    requested | build )
    19819       if test -n "$PKG_CONFIG" ; then
     19818      if test -n "$PKG_CONFIG" -a "coindatasample" != skip ; then
    1982019819        pcfile="coindatasample"
    1982119820
     
    1983719836
    1983819837      else
    19839         coin_has_sample=yes
     19838        coin_has_sample=no
    1984019839        # AC_MSG_WARN([skipped check via pkgconf as no pkgconf available])
    1984119840      fi
     
    2090820907# INIT-COMMANDS
    2090920908#
    20910 AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
     20909AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"
    2091120910
    2091220911
     
    2193121930  # are listed without --file.  Let's play safe and only enable the eval
    2193221931  # if we detect the quoting.
    21933   case $CONFIG_FILES in
    21934   *\'*) eval set x "$CONFIG_FILES" ;;
    21935   *)   set x $CONFIG_FILES ;;
    21936   esac
     21932  # TODO: see whether this extra hack can be removed once we start
     21933  # requiring Autoconf 2.70 or later.
     21934  case $CONFIG_FILES in #(
     21935  *\'*) :
     21936    eval set x "$CONFIG_FILES" ;; #(
     21937  *) :
     21938    set x $CONFIG_FILES ;; #(
     21939  *) :
     21940     ;;
     21941esac
    2193721942  shift
    21938   for mf
     21943  # Used to flag and report bootstrapping failures.
     21944  am_rc=0
     21945  for am_mf
    2193921946  do
    2194021947    # Strip MF so we end up with the name of the file.
    21941     mf=`echo "$mf" | sed -e 's/:.*$//'`
    21942     # Check whether this is an Automake generated Makefile or not.
    21943     # We used to match only the files named 'Makefile.in', but
    21944     # some people rename them; so instead we look at the file content.
    21945     # Grep'ing the first line is not enough: some people post-process
    21946     # each Makefile.in and add a new line on top of each file to say so.
    21947     # Grep'ing the whole file is not good either: AIX grep has a line
     21948    am_mf=`$as_echo "$am_mf" | sed -e 's/:.*$//'`
     21949    # Check whether this is an Automake generated Makefile which includes
     21950    # dependency-tracking related rules and includes.
     21951    # Grep'ing the whole file directly is not great: AIX grep has a line
    2194821952    # limit of 2048, but all sed's we know have understand at least 4000.
    21949     if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
    21950       dirpart=`$as_dirname -- "$mf" ||
    21951 $as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
    21952          X"$mf" : 'X\(//\)[^/]' \| \
    21953          X"$mf" : 'X\(//\)$' \| \
    21954          X"$mf" : 'X\(/\)' \| . 2>/dev/null ||
    21955 $as_echo X"$mf" |
     21953    sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \
     21954      || continue
     21955    am_dirpart=`$as_dirname -- "$am_mf" ||
     21956$as_expr X"$am_mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
     21957         X"$am_mf" : 'X\(//\)[^/]' \| \
     21958         X"$am_mf" : 'X\(//\)$' \| \
     21959         X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
     21960$as_echo X"$am_mf" |
    2195621961    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
    2195721962            s//\1/
     
    2197121976          }
    2197221977          s/.*/./; q'`
    21973     else
    21974       continue
    21975     fi
    21976     # Extract the definition of DEPDIR, am__include, and am__quote
    21977     # from the Makefile without running 'make'.
    21978     DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
    21979     test -z "$DEPDIR" && continue
    21980     am__include=`sed -n 's/^am__include = //p' < "$mf"`
    21981     test -z "$am__include" && continue
    21982     am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
    21983     # Find all dependency output files, they are included files with
    21984     # $(DEPDIR) in their names.  We invoke sed twice because it is the
    21985     # simplest approach to changing $(DEPDIR) to its actual value in the
    21986     # expansion.
    21987     for file in `sed -n "
    21988       s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
    21989          sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
    21990       # Make sure the directory exists.
    21991       test -f "$dirpart/$file" && continue
    21992       fdir=`$as_dirname -- "$file" ||
    21993 $as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
    21994          X"$file" : 'X\(//\)[^/]' \| \
    21995          X"$file" : 'X\(//\)$' \| \
    21996          X"$file" : 'X\(/\)' \| . 2>/dev/null ||
    21997 $as_echo X"$file" |
    21998     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
     21978    am_filepart=`$as_basename -- "$am_mf" ||
     21979$as_expr X/"$am_mf" : '.*/\([^/][^/]*\)/*$' \| \
     21980         X"$am_mf" : 'X\(//\)$' \| \
     21981         X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
     21982$as_echo X/"$am_mf" |
     21983    sed '/^.*\/\([^/][^/]*\)\/*$/{
    2199921984            s//\1/
    2200021985            q
    2200121986          }
    22002           /^X\(\/\/\)[^/].*/{
     21987          /^X\/\(\/\/\)$/{
    2200321988            s//\1/
    2200421989            q
    2200521990          }
    22006           /^X\(\/\/\)$/{
    22007             s//\1/
    22008             q
    22009           }
    22010           /^X\(\/\).*/{
     21991          /^X\/\(\/\).*/{
    2201121992            s//\1/
    2201221993            q
    2201321994          }
    2201421995          s/.*/./; q'`
    22015       as_dir=$dirpart/$fdir; as_fn_mkdir_p
    22016       # echo "creating $dirpart/$file"
    22017       echo '# dummy' > "$dirpart/$file"
    22018     done
     21996    { echo "$as_me:$LINENO: cd "$am_dirpart" \
     21997      && sed -e '/# am--include-marker/d' "$am_filepart" \
     21998        | $MAKE -f - am--depfiles" >&5
     21999   (cd "$am_dirpart" \
     22000      && sed -e '/# am--include-marker/d' "$am_filepart" \
     22001        | $MAKE -f - am--depfiles) >&5 2>&5
     22002   ac_status=$?
     22003   echo "$as_me:$LINENO: \$? = $ac_status" >&5
     22004   (exit $ac_status); } || am_rc=$?
    2201922005  done
     22006  if test $am_rc -ne 0; then
     22007    { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
     22008$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
     22009as_fn_error $? "Something went wrong bootstrapping makefile fragments
     22010    for automatic dependency tracking.  Try re-running configure with the
     22011    '--disable-dependency-tracking' option to at least be able to build
     22012    the package (albeit without support for automatic dependency tracking).
     22013See \`config.log' for more details" "$LINENO" 5; }
     22014  fi
     22015  { am_dirpart=; unset am_dirpart;}
     22016  { am_filepart=; unset am_filepart;}
     22017  { am_mf=; unset am_mf;}
     22018  { am_rc=; unset am_rc;}
     22019  rm -f conftest-deps.mk
    2202022020}
    2202122021 ;;
  • branches/autotools-update/Cgl/depcomp

    r1415 r1481  
    1 #! /bin/sh
     1#!/usr/bin/sh
    22# depcomp - compile a program generating dependencies as side-effects
    33
  • branches/autotools-update/Cgl/install-sh

    r1415 r1481  
    1 #!/bin/sh
     1#!/usr/bin/sh
    22# install - install a program, script, or datafile
    33
  • branches/autotools-update/Cgl/ltmain.sh

    r1432 r1481  
    21252125func_fatal_configuration ()
    21262126{
    2127     func__fatal_error ${1+"$@"} \
     2127    func_fatal_error ${1+"$@"} \
    21282128      "See the $PACKAGE documentation for more information." \
    21292129      "Fatal configuration error."
  • branches/autotools-update/Cgl/missing

    r1415 r1481  
    1 #! /bin/sh
     1#!/usr/bin/sh
    22# Common wrapper for a few potentially missing GNU programs.
    33
  • branches/autotools-update/Cgl/src/CglAllDifferent/Makefile.in

    r1433 r1481  
    1 # Makefile.in generated by automake 1.15.1 from Makefile.am.
     1# Makefile.in generated by automake 1.16.1 from Makefile.am.
    22# @configure_input@
    33
    4 # Copyright (C) 1994-2017 Free Software Foundation, Inc.
     4# Copyright (C) 1994-2018 Free Software Foundation, Inc.
    55
    66# This Makefile.in is free software; the Free Software Foundation
     
    146146DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)/src/CglCommon
    147147depcomp = $(SHELL) $(top_srcdir)/depcomp
    148 am__depfiles_maybe = depfiles
     148am__maybe_remake_depfiles = depfiles
     149am__depfiles_remade = ./$(DEPDIR)/CglAllDifferent.Plo
    149150am__mv = mv -f
    150151CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
     
    454455            cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
    455456          *) \
    456             echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
    457             cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
     457            echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
     458            cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
    458459        esac;
    459460$(top_srcdir)/BuildTools/Makemain.inc $(am__empty):
     
    488489        -rm -f *.tab.c
    489490
    490 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CglAllDifferent.Plo@am__quote@
     491@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CglAllDifferent.Plo@am__quote@ # am--include-marker
     492
     493$(am__depfiles_remade):
     494        @$(MKDIR_P) $(@D)
     495        @echo '# dummy' >$@-t && $(am__mv) $@-t $@
     496
     497am--depfiles: $(am__depfiles_remade)
    491498
    492499.cpp.o:
     
    632639
    633640distclean: distclean-am
    634         -rm -rf ./$(DEPDIR)
     641                -rm -f ./$(DEPDIR)/CglAllDifferent.Plo
    635642        -rm -f Makefile
    636643distclean-am: clean-am distclean-compile distclean-generic \
     
    678685
    679686maintainer-clean: maintainer-clean-am
    680         -rm -rf ./$(DEPDIR)
     687                -rm -f ./$(DEPDIR)/CglAllDifferent.Plo
    681688        -rm -f Makefile
    682689maintainer-clean-am: distclean-am maintainer-clean-generic
     
    699706.MAKE: install-am install-strip
    700707
    701 .PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
    702         clean-libtool clean-noinstLTLIBRARIES cscopelist-am ctags \
    703         ctags-am distclean distclean-compile distclean-generic \
    704         distclean-libtool distclean-tags dvi dvi-am html html-am info \
    705         info-am install install-am install-data install-data-am \
    706         install-dvi install-dvi-am install-exec install-exec-am \
    707         install-html install-html-am install-includecoinHEADERS \
    708         install-info install-info-am install-man install-pdf \
    709         install-pdf-am install-ps install-ps-am install-strip \
    710         installcheck installcheck-am installdirs maintainer-clean \
    711         maintainer-clean-generic mostlyclean mostlyclean-compile \
    712         mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
    713         tags tags-am uninstall uninstall-am \
    714         uninstall-includecoinHEADERS
     708.PHONY: CTAGS GTAGS TAGS all all-am am--depfiles check check-am clean \
     709        clean-generic clean-libtool clean-noinstLTLIBRARIES \
     710        cscopelist-am ctags ctags-am distclean distclean-compile \
     711        distclean-generic distclean-libtool distclean-tags dvi dvi-am \
     712        html html-am info info-am install install-am install-data \
     713        install-data-am install-dvi install-dvi-am install-exec \
     714        install-exec-am install-html install-html-am \
     715        install-includecoinHEADERS install-info install-info-am \
     716        install-man install-pdf install-pdf-am install-ps \
     717        install-ps-am install-strip installcheck installcheck-am \
     718        installdirs maintainer-clean maintainer-clean-generic \
     719        mostlyclean mostlyclean-compile mostlyclean-generic \
     720        mostlyclean-libtool pdf pdf-am ps ps-am tags tags-am uninstall \
     721        uninstall-am uninstall-includecoinHEADERS
    715722
    716723.PRECIOUS: Makefile
  • branches/autotools-update/Cgl/src/CglClique/CglClique.cpp

    r1388 r1481  
    1111#include "OsiRowCut.hpp"
    1212#include "CglClique.hpp"
     13
     14/* to prevent the creation of very
     15 * large incidence matrixes */
     16#ifndef MAX_CGLCLIQUE_COLS
     17#define MAX_CGLCLIQUE_COLS 10000
     18#endif
    1319
    1420/*****************************************************************************/
     
    116122#define MAX_CGLCLIQUE_ROWS 100000
    117123#endif
    118    if (sp_numrows > MAX_CGLCLIQUE_ROWS || sp_numcols < 2) {
     124   if (sp_numrows > MAX_CGLCLIQUE_ROWS || sp_numcols < 2 || sp_numcols>MAX_CGLCLIQUE_COLS) {
    119125     //printf("sp_numrows is %d\n",sp_numrows);
    120126     deleteSetPackingSubMatrix();
  • branches/autotools-update/Cgl/src/CglClique/Makefile.in

    r1433 r1481  
    1 # Makefile.in generated by automake 1.15.1 from Makefile.am.
     1# Makefile.in generated by automake 1.16.1 from Makefile.am.
    22# @configure_input@
    33
    4 # Copyright (C) 1994-2017 Free Software Foundation, Inc.
     4# Copyright (C) 1994-2018 Free Software Foundation, Inc.
    55
    66# This Makefile.in is free software; the Free Software Foundation
     
    147147DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)/src/CglCommon
    148148depcomp = $(SHELL) $(top_srcdir)/depcomp
    149 am__depfiles_maybe = depfiles
     149am__maybe_remake_depfiles = depfiles
     150am__depfiles_remade = ./$(DEPDIR)/CglClique.Plo \
     151        ./$(DEPDIR)/CglCliqueHelper.Plo ./$(DEPDIR)/CglCliqueTest.Plo
    150152am__mv = mv -f
    151153CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
     
    458460            cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
    459461          *) \
    460             echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
    461             cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
     462            echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
     463            cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
    462464        esac;
    463465$(top_srcdir)/BuildTools/Makemain.inc $(am__empty):
     
    492494        -rm -f *.tab.c
    493495
    494 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CglClique.Plo@am__quote@
    495 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CglCliqueHelper.Plo@am__quote@
    496 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CglCliqueTest.Plo@am__quote@
     496@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CglClique.Plo@am__quote@ # am--include-marker
     497@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CglCliqueHelper.Plo@am__quote@ # am--include-marker
     498@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CglCliqueTest.Plo@am__quote@ # am--include-marker
     499
     500$(am__depfiles_remade):
     501        @$(MKDIR_P) $(@D)
     502        @echo '# dummy' >$@-t && $(am__mv) $@-t $@
     503
     504am--depfiles: $(am__depfiles_remade)
    497505
    498506.cpp.o:
     
    638646
    639647distclean: distclean-am
    640         -rm -rf ./$(DEPDIR)
     648                -rm -f ./$(DEPDIR)/CglClique.Plo
     649        -rm -f ./$(DEPDIR)/CglCliqueHelper.Plo
     650        -rm -f ./$(DEPDIR)/CglCliqueTest.Plo
    641651        -rm -f Makefile
    642652distclean-am: clean-am distclean-compile distclean-generic \
     
    684694
    685695maintainer-clean: maintainer-clean-am
    686         -rm -rf ./$(DEPDIR)
     696                -rm -f ./$(DEPDIR)/CglClique.Plo
     697        -rm -f ./$(DEPDIR)/CglCliqueHelper.Plo
     698        -rm -f ./$(DEPDIR)/CglCliqueTest.Plo
    687699        -rm -f Makefile
    688700maintainer-clean-am: distclean-am maintainer-clean-generic
     
    705717.MAKE: install-am install-strip
    706718
    707 .PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
    708         clean-libtool clean-noinstLTLIBRARIES cscopelist-am ctags \
    709         ctags-am distclean distclean-compile distclean-generic \
    710         distclean-libtool distclean-tags dvi dvi-am html html-am info \
    711         info-am install install-am install-data install-data-am \
    712         install-dvi install-dvi-am install-exec install-exec-am \
    713         install-html install-html-am install-includecoinHEADERS \
    714         install-info install-info-am install-man install-pdf \
    715         install-pdf-am install-ps install-ps-am install-strip \
    716         installcheck installcheck-am installdirs maintainer-clean \
    717         maintainer-clean-generic mostlyclean mostlyclean-compile \
    718         mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
    719         tags tags-am uninstall uninstall-am \
    720         uninstall-includecoinHEADERS
     719.PHONY: CTAGS GTAGS TAGS all all-am am--depfiles check check-am clean \
     720        clean-generic clean-libtool clean-noinstLTLIBRARIES \
     721        cscopelist-am ctags ctags-am distclean distclean-compile \
     722        distclean-generic distclean-libtool distclean-tags dvi dvi-am \
     723        html html-am info info-am install install-am install-data \
     724        install-data-am install-dvi install-dvi-am install-exec \
     725        install-exec-am install-html install-html-am \
     726        install-includecoinHEADERS install-info install-info-am \
     727        install-man install-pdf install-pdf-am install-ps \
     728        install-ps-am install-strip installcheck installcheck-am \
     729        installdirs maintainer-clean maintainer-clean-generic \
     730        mostlyclean mostlyclean-compile mostlyclean-generic \
     731        mostlyclean-libtool pdf pdf-am ps ps-am tags tags-am uninstall \
     732        uninstall-am uninstall-includecoinHEADERS
    721733
    722734.PRECIOUS: Makefile
  • branches/autotools-update/Cgl/src/CglCommon/CglCutGenerator.cpp

    r1414 r1481  
    1212#include "CglCutGenerator.hpp"
    1313#include "CoinHelperFunctions.hpp"
    14  
    1514
    1615//-------------------------------------------------------------------
    17 // Default Constructor 
     16// Default Constructor
    1817//-------------------------------------------------------------------
    19 CglCutGenerator::CglCutGenerator ()
    20   : aggressive_(0),
    21 canDoGlobalCuts_(false)
     18CglCutGenerator::CglCutGenerator()
     19  : aggressive_(0)
     20  , canDoGlobalCuts_(false)
    2221{
    2322  // nothing to do here
     
    2524
    2625//-------------------------------------------------------------------
    27 // Copy constructor 
     26// Copy constructor
    2827//-------------------------------------------------------------------
    29 CglCutGenerator::CglCutGenerator (
    30                   const CglCutGenerator & source)         
    31   : aggressive_(source.aggressive_),
    32     canDoGlobalCuts_(source.canDoGlobalCuts_)
    33 { 
     28CglCutGenerator::CglCutGenerator(
     29  const CglCutGenerator &source)
     30  : aggressive_(source.aggressive_)
     31  , canDoGlobalCuts_(source.canDoGlobalCuts_)
     32{
    3433  // nothing to do here
    3534}
    3635
    37 
    3836//-------------------------------------------------------------------
    39 // Destructor 
     37// Destructor
    4038//-------------------------------------------------------------------
    41 CglCutGenerator::~CglCutGenerator ()
     39CglCutGenerator::~CglCutGenerator()
    4240{
    4341  // nothing to do here
     
    4543
    4644//----------------------------------------------------------------
    47 // Assignment operator 
     45// Assignment operator
    4846//-------------------------------------------------------------------
    4947CglCutGenerator &
    5048CglCutGenerator::operator=(
    51                    const CglCutGenerator& rhs)
     49  const CglCutGenerator &rhs)
    5250{
    5351  if (this != &rhs) {
     
    5755  return *this;
    5856}
    59 bool
    60 CglCutGenerator::mayGenerateRowCutsInTree() const
     57bool CglCutGenerator::mayGenerateRowCutsInTree() const
    6158{
    6259  return true;
    6360}
    6461// Return true if needs optimal basis to do cuts
    65 bool
    66 CglCutGenerator::needsOptimalBasis() const
     62bool CglCutGenerator::needsOptimalBasis() const
    6763{
    6864  return false;
     
    8278}
    8379#endif
     80
     81/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
     82*/
  • branches/autotools-update/Cgl/src/CglCommon/CglCutGenerator.hpp

    r1414 r1481  
    2121generator will inherit from this class.
    2222*/
    23 class CglCutGenerator  {
    24  
     23class CglCutGenerator {
     24
    2525public:
    26    
    2726  /**@name Generate Cuts */
    2827  //@{
     
    3130  collection of cuts cs.
    3231  */
    33   virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
    34                              const CglTreeInfo info = CglTreeInfo())=0;
     32  virtual void generateCuts(const OsiSolverInterface &si, OsiCuts &cs,
     33    const CglTreeInfo info = CglTreeInfo())
     34    = 0;
    3535  //@}
    3636
    37    
    3837  /**@name Constructors and destructors */
    3938  //@{
    40   /// Default constructor 
    41   CglCutGenerator ();
    42  
    43   /// Copy constructor 
    44   CglCutGenerator ( const CglCutGenerator &);
     39  /// Default constructor
     40  CglCutGenerator();
     41
     42  /// Copy constructor
     43  CglCutGenerator(const CglCutGenerator &);
    4544
    4645  /// Clone
    47   virtual CglCutGenerator * clone() const = 0;
     46  virtual CglCutGenerator *clone() const = 0;
    4847
    49   /// Assignment operator 
    50   CglCutGenerator & operator=(const CglCutGenerator& rhs);
     48  /// Assignment operator
     49  CglCutGenerator &operator=(const CglCutGenerator &rhs);
    5150
    52   /// Destructor 
    53   virtual ~CglCutGenerator ();
     51  /// Destructor
     52  virtual ~CglCutGenerator();
    5453
    5554  /** Create C++ lines to set the generator in the current state.
     
    6362      cut generators.
    6463  */
    65   virtual std::string generateCpp( FILE * ) {return "";}
     64  virtual std::string generateCpp(FILE *) { return ""; }
    6665
    6766  /// This can be used to refresh any information
    68   virtual void refreshSolver(OsiSolverInterface * ) {}
     67  virtual void refreshSolver(OsiSolverInterface *) {}
    6968  //@}
    70  
     69
    7170  /**@name Gets and Sets */
    7271  //@{
     
    7675  */
    7776  inline int getAggressiveness() const
    78   { return aggressive_;}
     77  {
     78    return aggressive_;
     79  }
    7980
    8081  /**
     
    8384  */
    8485  inline void setAggressiveness(int value)
    85   { aggressive_=value;}
     86  {
     87    aggressive_ = value;
     88  }
    8689  /// Set whether can do global cuts
    8790  inline void setGlobalCuts(bool trueOrFalse)
    88   { canDoGlobalCuts_ = trueOrFalse;}
     91  {
     92    canDoGlobalCuts_ = trueOrFalse;
     93  }
    8994  /// Say whether can do global cuts
    9095  inline bool canDoGlobalCuts() const
    91   {return canDoGlobalCuts_;}
     96  {
     97    return canDoGlobalCuts_;
     98  }
    9299  /**
    93100     Returns true if may generate Row cuts in tree (rather than root node).
     
    102109  /// Return maximum length of cut in tree
    103110  virtual int maximumLengthOfCutInTree() const
    104   { return COIN_INT_MAX;}
     111  {
     112    return COIN_INT_MAX;
     113  }
    105114  //@}
    106  
     115
    107116  // test this class
    108117  //static void unitTest();
    109  
    110 // private:
    111  
     118
     119  // private:
     120
    112121  /**
    113122     Aggressiveness - 0 = neutral, 100 is normal root node.
     
    120129
    121130#endif
     131
     132/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
     133*/
  • branches/autotools-update/Cgl/src/CglCommon/CglMessage.cpp

    r1414 r1481  
    1212  int externalNumber; // or continuation
    1313  char detail;
    14   const char * message;
     14  const char *message;
    1515} Cgl_message;
    16 static Cgl_message us_english[]=
    17 {
    18   {CGL_INFEASIBLE,0,1,"Cut generators found to be infeasible! (or unbounded)"},
    19   {CGL_CLIQUES,1,2,"%d cliques of average size %g"},
    20   {CGL_FIXED,2,1,"%d variables fixed"},
    21   {CGL_PROCESS_STATS,3,1,"%d fixed, %d tightened bounds, %d strengthened rows, %d substitutions"},
    22   {CGL_SLACKS,8,1,"%d inequality constraints converted to equality constraints"},
    23   {CGL_PROCESS_STATS2,4,1,"processed model has %d rows, %d columns (%d integer (%d of which binary)) and %d elements"},
    24   {CGL_PROCESS_SOS1,5,1,"%d SOS with %d members"},
    25   {CGL_PROCESS_SOS2,6,2,"%d SOS (%d members out of %d) with %d overlaps - too much overlap or too many others"},
    26   {CGL_UNBOUNDED,7,1,"Continuous relaxation is unbounded!"},
    27   {CGL_ELEMENTS_CHANGED1,9,2,"%d elements changed"},
    28   {CGL_ELEMENTS_CHANGED2,10,3,"element in row %d for column %d changed from %g to %g"},
    29   {CGL_MADE_INTEGER,11,1,"%d variables made integer"},
    30   {CGL_ADDED_INTEGERS,12,1,"Added %d variables (from %d rows) with %d elements"},
    31   {CGL_POST_INFEASIBLE,13,1,"Postprocessed model is infeasible - possible tolerance issue - try without preprocessing"},
    32   {CGL_POST_CHANGED,14,1,"Postprocessing changed objective from %g to %g - possible tolerance issue - try without preprocessing"},
    33   {CGL_GENERAL, 1000, 1, "%s"},
    34   {CGL_DUMMY_END,999999,0,""}
     16static Cgl_message us_english[] = {
     17  { CGL_INFEASIBLE, 0, 1, "Cut generators found to be infeasible! (or unbounded)" },
     18  { CGL_CLIQUES, 1, 2, "%d cliques of average size %g" },
     19  { CGL_FIXED, 2, 1, "%d variables fixed" },
     20  { CGL_PROCESS_STATS, 3, 1, "%d fixed, %d tightened bounds, %d strengthened rows, %d substitutions" },
     21  { CGL_SLACKS, 8, 1, "%d inequality constraints converted to equality constraints" },
     22  { CGL_PROCESS_STATS2, 4, 1, "processed model has %d rows, %d columns (%d integer (%d of which binary)) and %d elements" },
     23  { CGL_PROCESS_SOS1, 5, 1, "%d SOS with %d members" },
     24  { CGL_PROCESS_SOS2, 6, 2, "%d SOS (%d members out of %d) with %d overlaps - too much overlap or too many others" },
     25  { CGL_UNBOUNDED, 7, 1, "Continuous relaxation is unbounded!" },
     26  { CGL_ELEMENTS_CHANGED1, 9, 2, "%d elements changed" },
     27  { CGL_ELEMENTS_CHANGED2, 10, 3, "element in row %d for column %d changed from %g to %g" },
     28  { CGL_MADE_INTEGER, 11, 1, "%d variables made integer" },
     29  { CGL_ADDED_INTEGERS, 12, 1, "Added %d variables (from %d rows) with %d elements" },
     30  { CGL_POST_INFEASIBLE, 13, 1, "Postprocessed model is infeasible - possible tolerance issue - try without preprocessing" },
     31  { CGL_POST_CHANGED, 14, 1, "Postprocessing changed objective from %g to %g - possible tolerance issue - try without preprocessing" },
     32  { CGL_GENERAL, 1000, 1, "%s" },
     33  { CGL_DUMMY_END, 999999, 0, "" }
    3534};
    3635/* Constructor */
    37 CglMessage::CglMessage(Language language) :
    38   CoinMessages(sizeof(us_english)/sizeof(Cgl_message))
     36CglMessage::CglMessage(Language language)
     37  : CoinMessages(sizeof(us_english) / sizeof(Cgl_message))
    3938{
    40   language_=language;
    41   strcpy(source_,"Cgl");
     39  language_ = language;
     40  strcpy(source_, "Cgl");
    4241  class_ = 3; // Cuts
    43   Cgl_message * message = us_english;
     42  Cgl_message *message = us_english;
    4443
    45   while (message->internalNumber!=CGL_DUMMY_END) {
    46      CoinOneMessage oneMessage(message->externalNumber,message->detail,
    47                                message->message);
    48      addMessage(message->internalNumber,oneMessage);
    49      message ++;
     44  while (message->internalNumber != CGL_DUMMY_END) {
     45    CoinOneMessage oneMessage(message->externalNumber, message->detail,
     46      message->message);
     47    addMessage(message->internalNumber, oneMessage);
     48    message++;
    5049  }
    5150  // Put into compact form
    5251  toCompact();
     52}
    5353
    54 }
     54/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
     55*/
  • branches/autotools-update/Cgl/src/CglCommon/CglMessage.hpp

    r1414 r1481  
    77#define CglMessage_H
    88
    9 
    109#include "CoinPragma.hpp"
    1110
     
    1312
    1413#include "CoinMessageHandler.hpp"
    15 enum CGL_Message
    16 {
     14enum CGL_Message {
    1715  CGL_INFEASIBLE,
    1816  CGL_CLIQUES,
     
    3937
    4038public:
    41 
    4239  /**@name Constructors etc */
    4340  //@{
    4441  /** Constructor */
    45   CglMessage(Language language=us_en);
     42  CglMessage(Language language = us_en);
    4643  //@}
    47 
    4844};
    4945
    5046#endif
     47
     48/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
     49*/
  • branches/autotools-update/Cgl/src/CglCommon/CglParam.cpp

    r1414 r1481  
    11// Name:     CglParam.cpp
    2 // Author:   Francois Margot                                                 
     2// Author:   Francois Margot
    33//           Tepper School of Business
    44//           Carnegie Mellon University, Pittsburgh, PA 15213
     
    2222void CglParam::setINFINIT(const double inf)
    2323{
    24   if(inf > 0)
     24  if (inf > 0)
    2525    INFINIT = inf;
    2626} /* setINFINIT */
     
    2929void CglParam::setEPS(const double eps)
    3030{
    31   if(eps >= 0)
     31  if (eps >= 0)
    3232    EPS = eps;
    3333} /* setEPS */
     
    3636void CglParam::setEPS_COEFF(const double eps_c)
    3737{
    38   if(eps_c >= 0)
     38  if (eps_c >= 0)
    3939    EPS_COEFF = eps_c;
    4040} /* setEPS_COEFF */
     
    4343void CglParam::setMAX_SUPPORT(const int max_s)
    4444{
    45   if(max_s > 0)
     45  if (max_s > 0)
    4646    MAX_SUPPORT = max_s;
    4747} /* setMAX_SUPPORT */
    4848
    4949/***********************************************************************/
    50 CglParam::CglParam(const double inf, const double eps, const double eps_c,
    51                    const int max_s) :
    52   INFINIT(inf),
    53   EPS(eps),
    54   EPS_COEFF(eps_c),
    55   MAX_SUPPORT(max_s)
    56 {}
     50CglParam::CglParam(const double inf, const double eps, const double eps_c,
     51  const int max_s)
     52  : INFINIT(inf)
     53  , EPS(eps)
     54  , EPS_COEFF(eps_c)
     55  , MAX_SUPPORT(max_s)
     56{
     57}
    5758
    5859/***********************************************************************/
    59 CglParam::CglParam(const CglParam &source) :
    60   INFINIT(source.INFINIT),
    61   EPS(source.EPS),
    62   EPS_COEFF(source.EPS_COEFF),
    63   MAX_SUPPORT(source.MAX_SUPPORT)
    64 {}
     60CglParam::CglParam(const CglParam &source)
     61  : INFINIT(source.INFINIT)
     62  , EPS(source.EPS)
     63  , EPS_COEFF(source.EPS_COEFF)
     64  , MAX_SUPPORT(source.MAX_SUPPORT)
     65{
     66}
    6567
    6668/***********************************************************************/
    67 CglParam* CglParam::clone() const
     69CglParam *CglParam::clone() const
    6870{
    6971  return new CglParam(*this);
     
    7173
    7274/***********************************************************************/
    73 CglParam& CglParam::operator=(const CglParam &rhs)
     75CglParam &CglParam::operator=(const CglParam &rhs)
    7476{
    75   if(this != &rhs) {
     77  if (this != &rhs) {
    7678    INFINIT = rhs.INFINIT;
    7779    EPS = rhs.EPS;
     
    8486/***********************************************************************/
    8587CglParam::~CglParam()
    86 {}
     88{
     89}
     90
     91/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
     92*/
  • branches/autotools-update/Cgl/src/CglCommon/CglParam.hpp

    r1414 r1481  
    2323
    2424public:
    25 
    2625  /**@name Public Set/get methods */
    2726  //@{
     
    3029  virtual void setINFINIT(const double inf);
    3130  /** Get value of INFINIT */
    32   inline double getINFINIT() const {return INFINIT;}
     31  inline double getINFINIT() const { return INFINIT; }
    3332
    3433  /** Set EPS */
    3534  virtual void setEPS(const double eps);
    3635  /** Get value of EPS */
    37   inline double getEPS() const {return EPS;}
     36  inline double getEPS() const { return EPS; }
    3837
    3938  /** Set EPS_COEFF */
    4039  virtual void setEPS_COEFF(const double eps_c);
    4140  /** Get value of EPS_COEFF */
    42   inline double getEPS_COEFF() const {return EPS_COEFF;}
     41  inline double getEPS_COEFF() const { return EPS_COEFF; }
    4342
    4443  /** Set MAX_SUPPORT */
    4544  virtual void setMAX_SUPPORT(const int max_s);
    4645  /** Get value of MAX_SUPPORT */
    47   inline int getMAX_SUPPORT() const {return MAX_SUPPORT;}
     46  inline int getMAX_SUPPORT() const { return MAX_SUPPORT; }
    4847  //@}
    4948
    5049  /**@name Constructors and destructors */
    5150  //@{
    52   /// Default constructor 
     51  /// Default constructor
    5352  CglParam(const double inf = COIN_DBL_MAX, const double eps = 1e-6,
    54            const double eps_c = 1e-5, const int max_s = COIN_INT_MAX);
    55  
    56   /// Copy constructor 
    57   CglParam(const CglParam&);
     53    const double eps_c = 1e-5, const int max_s = COIN_INT_MAX);
     54
     55  /// Copy constructor
     56  CglParam(const CglParam &);
    5857
    5958  /// Clone
    60   virtual CglParam* clone() const;
     59  virtual CglParam *clone() const;
    6160
    62   /// Assignment operator 
    63   CglParam& operator=(const CglParam &rhs);
     61  /// Assignment operator
     62  CglParam &operator=(const CglParam &rhs);
    6463
    65   /// Destructor 
     64  /// Destructor
    6665  virtual ~CglParam();
    6766  //@}
    6867
    6968protected:
    70 
    7169  // Protected member data
    7270
     
    8078  double EPS;
    8179
    82   // Returned cuts do not have coefficients with absolute value smaller 
     80  // Returned cuts do not have coefficients with absolute value smaller
    8381  // than EPS_COEFF. Default: 1e-5.
    8482  double EPS_COEFF;
    8583
    8684  /** Maximum number of non zero coefficients in a generated cut;
    87       Default: COIN_INT_MAX */ 
    88   int MAX_SUPPORT; 
     85      Default: COIN_INT_MAX */
     86  int MAX_SUPPORT;
    8987  //@}
    90 
    9188};
    9289
    9390#endif
     91
     92/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
     93*/
  • branches/autotools-update/Cgl/src/CglCommon/CglStored.cpp

    r1414 r1481  
    2020//-------------------------------------------------------------------
    2121// Generate Stored cuts
    22 //-------------------------------------------------------------------
    23 void
    24 CglStored::generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
    25                         const CglTreeInfo /*info*/)
     22//-------------------------------------------------------------------
     23void CglStored::generateCuts(const OsiSolverInterface &si, OsiCuts &cs,
     24  const CglTreeInfo /*info*/)
    2625{
    2726  // Get basic problem information
    28   const double * solution = si.getColSolution();
     27  const double *solution = si.getColSolution();
    2928  int numberRowCuts = cuts_.sizeRowCuts();
    30   for (int i=0;i<numberRowCuts;i++) {
    31     const OsiRowCut * rowCutPointer = cuts_.rowCutPtr(i);
     29  for (int i = 0; i < numberRowCuts; i++) {
     30    const OsiRowCut *rowCutPointer = cuts_.rowCutPtr(i);
    3231    double violation = rowCutPointer->violated(solution);
    33     if (violation>=requiredViolation_)
     32    if (violation >= requiredViolation_)
    3433      cs.insert(*rowCutPointer);
    3534  }
    3635  if (probingInfo_) {
    3736    int number01 = probingInfo_->numberIntegers();
    38     const CliqueEntry * entry = probingInfo_->fixEntries();
    39     const int * toZero = probingInfo_->toZero();
    40     const int * toOne = probingInfo_->toOne();
    41     const int * integerVariable = probingInfo_->integerVariable();
    42     const double * lower = si.getColLower();
    43     const double * upper = si.getColUpper();
     37    const CliqueEntry *entry = probingInfo_->fixEntries();
     38    const int *toZero = probingInfo_->toZero();
     39    const int *toOne = probingInfo_->toOne();
     40    const int *integerVariable = probingInfo_->integerVariable();
     41    const double *lower = si.getColLower();
     42    const double *upper = si.getColUpper();
    4443    OsiRowCut cut;
    4544    int column[2];
    4645    double element[2];
    47     for (int i=0;i<number01;i++) {
    48       int iColumn=integerVariable[i];
    49       if (upper[iColumn]==lower[iColumn])
    50         continue;
     46    for (int i = 0; i < number01; i++) {
     47      int iColumn = integerVariable[i];
     48      if (upper[iColumn] == lower[iColumn])
     49        continue;
    5150      double value1 = solution[iColumn];
    52       for (int j=toZero[i];j<toOne[i];j++) {
    53         int jColumn=sequenceInCliqueEntry(entry[j]);
    54         if (jColumn<number01) {
    55           jColumn=integerVariable[jColumn];
    56           assert (jColumn>=0);
    57           double value2 = solution[jColumn];
    58           if (oneFixesInCliqueEntry(entry[j])) {
    59             double violation = 1.0-value1-value2;
    60             if (violation>requiredViolation_) {
    61               //printf("XXX can do %d + %d >=1\n",iColumn,jColumn);
    62               cut.setLb(1.0);
    63               cut.setUb(COIN_DBL_MAX);
    64               column[0]=iColumn;
    65               element[0]=1.0;
    66               column[1]=jColumn;
    67               element[1]= 1.0;
    68               cut.setEffectiveness(violation);
    69               cut.setRow(2,column,element,false);
    70               cs.insert(cut);
    71             }
    72           } else {
    73             double violation = value2-value1;
    74             if (violation>requiredViolation_) {
    75               //printf("XXX can do %d >= %d\n",iColumn,jColumn);
    76               cut.setLb(0.0);
    77               cut.setUb(COIN_DBL_MAX);
    78               column[0]=iColumn;
    79               element[0]=1.0;
    80               column[1]=jColumn;
    81               element[1]= -1.0;
    82               cut.setEffectiveness(violation);
    83               cut.setRow(2,column,element,false);
    84               cs.insert(cut);
    85             }
    86           }
    87         } else {
    88           jColumn -= number01; // not 0-1
    89           double value2 = solution[jColumn];
    90           double lowerValue = lower[jColumn];
    91           double upperValue = upper[jColumn];
    92           if (oneFixesInCliqueEntry(entry[j])) {
    93             double violation = upperValue-value1*(upperValue-lowerValue)-value2;
    94             if (violation>requiredViolation_) {
    95               //printf("XXX can do %g*%d + %d >=%g\n",(upperValue-lowerValue),iColumn,jColumn,upperValue);
    96               cut.setLb(upperValue);
    97               cut.setUb(COIN_DBL_MAX);
    98               column[0]=iColumn;
    99               element[0]=upperValue-lowerValue;
    100               column[1]=jColumn;
    101               element[1]= 1.0;
    102               cut.setEffectiveness(violation);
    103               cut.setRow(2,column,element,false);
    104               cs.insert(cut);
    105             }
    106           } else {
    107             double violation = value2-value1*(upperValue-lowerValue)-lowerValue;
    108             if (violation>requiredViolation_) {
    109               //printf("XXX can do %g*%d >= %d -%g\n",(upperValue-lowerValue),iColumn,jColumn,lowerValue);
    110               cut.setLb(-lowerValue);
    111               cut.setUb(COIN_DBL_MAX);
    112               column[0]=iColumn;
    113               element[0]=upperValue-lowerValue;
    114               column[1]=jColumn;
    115               element[1]= -1.0;
    116               cut.setEffectiveness(violation);
    117               cut.setRow(2,column,element,false);
    118               cs.insert(cut);
    119             }
    120           }
    121         }
     51      for (int j = toZero[i]; j < toOne[i]; j++) {
     52        int jColumn = sequenceInCliqueEntry(entry[j]);
     53        if (jColumn < number01) {
     54          jColumn = integerVariable[jColumn];
     55          assert(jColumn >= 0);
     56          double value2 = solution[jColumn];
     57          if (oneFixesInCliqueEntry(entry[j])) {
     58            double violation = 1.0 - value1 - value2;
     59            if (violation > requiredViolation_) {
     60              //printf("XXX can do %d + %d >=1\n",iColumn,jColumn);
     61              cut.setLb(1.0);
     62              cut.setUb(COIN_DBL_MAX);
     63              column[0] = iColumn;
     64              element[0] = 1.0;
     65              column[1] = jColumn;
     66              element[1] = 1.0;
     67              cut.setEffectiveness(violation);
     68              cut.setRow(2, column, element, false);
     69              cs.insert(cut);
     70            }
     71          } else {
     72            double violation = value2 - value1;
     73            if (violation > requiredViolation_) {
     74              //printf("XXX can do %d >= %d\n",iColumn,jColumn);
     75              cut.setLb(0.0);
     76              cut.setUb(COIN_DBL_MAX);
     77              column[0] = iColumn;
     78              element[0] = 1.0;
     79              column[1] = jColumn;
     80              element[1] = -1.0;
     81              cut.setEffectiveness(violation);
     82              cut.setRow(2, column, element, false);
     83              cs.insert(cut);
     84            }
     85          }
     86        } else {
     87          jColumn -= number01; // not 0-1
     88          double value2 = solution[jColumn];
     89          double lowerValue = lower[jColumn];
     90          double upperValue = upper[jColumn];
     91          if (oneFixesInCliqueEntry(entry[j])) {
     92            double violation = upperValue - value1 * (upperValue - lowerValue) - value2;
     93            if (violation > requiredViolation_) {
     94              //printf("XXX can do %g*%d + %d >=%g\n",(upperValue-lowerValue),iColumn,jColumn,upperValue);
     95              cut.setLb(upperValue);
     96              cut.setUb(COIN_DBL_MAX);
     97              column[0] = iColumn;
     98              element[0] = upperValue - lowerValue;
     99              column[1] = jColumn;
     100              element[1] = 1.0;
     101              cut.setEffectiveness(violation);
     102              cut.setRow(2, column, element, false);
     103              cs.insert(cut);
     104            }
     105          } else {
     106            double violation = value2 - value1 * (upperValue - lowerValue) - lowerValue;
     107            if (violation > requiredViolation_) {
     108              //printf("XXX can do %g*%d >= %d -%g\n",(upperValue-lowerValue),iColumn,jColumn,lowerValue);
     109              cut.setLb(-lowerValue);
     110              cut.setUb(COIN_DBL_MAX);
     111              column[0] = iColumn;
     112              element[0] = upperValue - lowerValue;
     113              column[1] = jColumn;
     114              element[1] = -1.0;
     115              cut.setEffectiveness(violation);
     116              cut.setRow(2, column, element, false);
     117              cs.insert(cut);
     118            }
     119          }
     120        }
    122121      }
    123       for (int j=toOne[i];j<toZero[i+1];j++) {
    124         int jColumn=sequenceInCliqueEntry(entry[j]);
    125         if (jColumn<number01) {
    126           jColumn=integerVariable[jColumn];
    127           assert (jColumn>=0);
    128           double value2 = solution[jColumn];
    129           if (oneFixesInCliqueEntry(entry[j])) {
    130             double violation = value1-value2;
    131             if (violation>requiredViolation_) {
    132               //printf("XXX can do %d <= %d\n",iColumn,jColumn);
    133               cut.setLb(-COIN_DBL_MAX);
    134               cut.setUb(0.0);
    135               column[0]=iColumn;
    136               element[0]=1.0;
    137               column[1]=jColumn;
    138               element[1]= -1.0;
    139               cut.setEffectiveness(violation);
    140               cut.setRow(2,column,element,false);
    141               cs.insert(cut);
    142             }
    143           } else {
    144             double violation = value1+value2-1.0;
    145             if (violation>requiredViolation_) {
    146               //printf("XXX can do %d + %d <=1\n",iColumn,jColumn);
    147               cut.setLb(-COIN_DBL_MAX);
    148               cut.setUb(1.0);
    149               column[0]=iColumn;
    150               element[0]=1.0;
    151               column[1]=jColumn;
    152               element[1]= 1.0;
    153               cut.setEffectiveness(violation);
    154               cut.setRow(2,column,element,false);
    155               cs.insert(cut);
    156             }
    157           }
    158         } else {
    159           jColumn -= number01; // not 0-1
    160           double value2 = solution[jColumn];
    161           double lowerValue = lower[jColumn];
    162           double upperValue = upper[jColumn];
    163           if (oneFixesInCliqueEntry(entry[j])) {
    164             double violation = lowerValue +(upperValue-lowerValue)*value1-value2;
    165             if (violation>requiredViolation_) {
    166               //printf("XXX can do %g*%d <= %d -%g\n",(upperValue-lowerValue),iColumn,jColumn,lowerValue);
    167               cut.setLb(-COIN_DBL_MAX);
    168               cut.setUb(-lowerValue);
    169               column[0]=iColumn;
    170               element[0]=upperValue-lowerValue;
    171               column[1]=jColumn;
    172               element[1]= -1.0;
    173               cut.setEffectiveness(violation);
    174               cut.setRow(2,column,element,false);
    175               cs.insert(cut);
    176             }
    177           } else {
    178             double violation = (upperValue-lowerValue)*value1+value2-upperValue;
    179             if (violation>requiredViolation_) {
    180               //printf("XXX can do %g*%d + %d <=%g\n",(upperValue-lowerValue),iColumn,jColumn,upperValue);
    181               cut.setLb(-COIN_DBL_MAX);
    182               cut.setUb(upperValue);
    183               column[0]=iColumn;
    184               element[0]=upperValue-lowerValue;
    185               column[1]=jColumn;
    186               element[1]= 1.0;
    187               cut.setEffectiveness(violation);
    188               cut.setRow(2,column,element,false);
    189               cs.insert(cut);
    190             }
    191           }
    192         }
     122      for (int j = toOne[i]; j < toZero[i + 1]; j++) {
     123        int jColumn = sequenceInCliqueEntry(entry[j]);
     124        if (jColumn < number01) {
     125          jColumn = integerVariable[jColumn];
     126          assert(jColumn >= 0);
     127          double value2 = solution[jColumn];
     128          if (oneFixesInCliqueEntry(entry[j])) {
     129            double violation = value1 - value2;
     130            if (violation > requiredViolation_) {
     131              //printf("XXX can do %d <= %d\n",iColumn,jColumn);
     132              cut.setLb(-COIN_DBL_MAX);
     133              cut.setUb(0.0);
     134              column[0] = iColumn;
     135              element[0] = 1.0;
     136              column[1] = jColumn;
     137              element[1] = -1.0;
     138              cut.setEffectiveness(violation);
     139              cut.setRow(2, column, element, false);
     140              cs.insert(cut);
     141            }
     142          } else {
     143            double violation = value1 + value2 - 1.0;
     144            if (violation > requiredViolation_) {
     145              //printf("XXX can do %d + %d <=1\n",iColumn,jColumn);
     146              cut.setLb(-COIN_DBL_MAX);
     147              cut.setUb(1.0);
     148              column[0] = iColumn;
     149              element[0] = 1.0;
     150              column[1] = jColumn;
     151              element[1] = 1.0;
     152              cut.setEffectiveness(violation);
     153              cut.setRow(2, column, element, false);
     154              cs.insert(cut);
     155            }
     156          }
     157        } else {
     158          jColumn -= number01; // not 0-1
     159          double value2 = solution[jColumn];
     160          double lowerValue = lower[jColumn];
     161          double upperValue = upper[jColumn];
     162          if (oneFixesInCliqueEntry(entry[j])) {
     163            double violation = lowerValue + (upperValue - lowerValue) * value1 - value2;
     164            if (violation > requiredViolation_) {
     165              //printf("XXX can do %g*%d <= %d -%g\n",(upperValue-lowerValue),iColumn,jColumn,lowerValue);
     166              cut.setLb(-COIN_DBL_MAX);
     167              cut.setUb(-lowerValue);
     168              column[0] = iColumn;
     169              element[0] = upperValue - lowerValue;
     170              column[1] = jColumn;
     171              element[1] = -1.0;
     172              cut.setEffectiveness(violation);
     173              cut.setRow(2, column, element, false);
     174              cs.insert(cut);
     175            }
     176          } else {
     177            double violation = (upperValue - lowerValue) * value1 + value2 - upperValue;
     178            if (violation > requiredViolation_) {
     179              //printf("XXX can do %g*%d + %d <=%g\n",(upperValue-lowerValue),iColumn,jColumn,upperValue);
     180              cut.setLb(-COIN_DBL_MAX);
     181              cut.setUb(upperValue);
     182              column[0] = iColumn;
     183              element[0] = upperValue - lowerValue;
     184              column[1] = jColumn;
     185              element[1] = 1.0;
     186              cut.setEffectiveness(violation);
     187              cut.setRow(2, column, element, false);
     188              cs.insert(cut);
     189            }
     190          }
     191        }
    193192      }
    194193    }
     
    196195}
    197196// Add cuts
    198 void
    199 CglStored::addCut(const OsiCuts & cs)
     197void CglStored::addCut(const OsiCuts &cs)
    200198{
    201199  int numberRowCuts = cs.sizeRowCuts();
    202   for (int i=0;i<numberRowCuts;i++) {
     200  for (int i = 0; i < numberRowCuts; i++) {
    203201    cuts_.insert(*cs.rowCutPtr(i));
    204202  }
    205203}
    206204// Add a row cut
    207 void
    208 CglStored::addCut(const OsiRowCut & cut)
     205void CglStored::addCut(const OsiRowCut &cut)
    209206{
    210207  cuts_.insert(cut);
    211208}
    212209// Add a row cut from a packed vector
    213 void
    214 CglStored::addCut(double lb, double ub, const CoinPackedVector & vector)
     210void CglStored::addCut(double lb, double ub, const CoinPackedVector &vector)
    215211{
    216212  OsiRowCut rc;
     
    218214  rc.mutableRow().setTestForDuplicateIndex(false);
    219215  rc.setLb(lb);
    220   rc.setUb(ub);   
     216  rc.setUb(ub);
    221217  cuts_.insert(rc);
    222218}
    223219// Add a row cut from elements
    224 void
    225 CglStored::addCut(double lb, double ub, int size, const int * colIndices, const double * elements)
     220void CglStored::addCut(double lb, double ub, int size, const int *colIndices, const double *elements)
    226221{
    227222  OsiRowCut rc;
    228   rc.setRow(size,colIndices,elements,false);
     223  rc.setRow(size, colIndices, elements, false);
    229224  rc.setLb(lb);
    230   rc.setUb(ub);   
     225  rc.setUb(ub);
    231226  cuts_.insert(rc);
    232227}
    233228
    234229//-------------------------------------------------------------------
    235 // Default Constructor
    236 //-------------------------------------------------------------------
    237 CglStored::CglStored (int numberColumns)
    238 :
    239   CglCutGenerator(),
    240   requiredViolation_(1.0e-5),
    241   probingInfo_(NULL),
    242   numberColumns_(numberColumns),
    243   bestSolution_(NULL),
    244   bounds_(NULL)
    245 {
    246 }
    247 
    248 //-------------------------------------------------------------------
    249 // Copy constructor
    250 //-------------------------------------------------------------------
    251 CglStored::CglStored (const CglStored & source) :
    252   CglCutGenerator(source),
    253   requiredViolation_(source.requiredViolation_),
    254   probingInfo_(NULL),
    255   cuts_(source.cuts_),
    256   numberColumns_(source.numberColumns_),
    257   bestSolution_(NULL),
    258   bounds_(NULL)
    259 
     230// Default Constructor
     231//-------------------------------------------------------------------
     232CglStored::CglStored(int numberColumns)
     233  : CglCutGenerator()
     234  , requiredViolation_(1.0e-5)
     235  , probingInfo_(NULL)
     236  , numberColumns_(numberColumns)
     237  , bestSolution_(NULL)
     238  , bounds_(NULL)
     239{
     240}
     241
     242//-------------------------------------------------------------------
     243// Copy constructor
     244//-------------------------------------------------------------------
     245CglStored::CglStored(const CglStored &source)
     246  : CglCutGenerator(source)
     247  , requiredViolation_(source.requiredViolation_)
     248  , probingInfo_(NULL)
     249  , cuts_(source.cuts_)
     250  , numberColumns_(source.numberColumns_)
     251  , bestSolution_(NULL)
     252  , bounds_(NULL)
     253{
    260254  if (source.probingInfo_)
    261255    probingInfo_ = new CglTreeProbingInfo(*source.probingInfo_);
    262256  if (numberColumns_) {
    263     bestSolution_ = CoinCopyOfArray(source.bestSolution_,numberColumns_+1);
    264     bounds_ = CoinCopyOfArray(source.bounds_,2*numberColumns_);
     257    bestSolution_ = CoinCopyOfArray(source.bestSolution_, numberColumns_ + 1);
     258    bounds_ = CoinCopyOfArray(source.bounds_, 2 * numberColumns_);
    265259  }
    266260}
     
    268262// Constructor from file
    269263//-------------------------------------------------------------------
    270 CglStored::CglStored (const char * fileName) :
    271   CglCutGenerator(),
    272   requiredViolation_(1.0e-5),
    273   probingInfo_(NULL),
    274   numberColumns_(0),
    275   bestSolution_(NULL),
    276   bounds_(NULL)
    277 { 
    278   FILE * fp = fopen(fileName,"rb");
     264CglStored::CglStored(const char *fileName)
     265  : CglCutGenerator()
     266  , requiredViolation_(1.0e-5)
     267  , probingInfo_(NULL)
     268  , numberColumns_(0)
     269  , bestSolution_(NULL)
     270  , bounds_(NULL)
     271{
     272  FILE *fp = fopen(fileName, "rb");
    279273  if (fp) {
    280274#ifndef NDEBUG
    281275    size_t numberRead;
    282276#endif
    283     int maxInCut=0;
    284     int * index = NULL;
    285     double * coefficient = NULL;
     277    int maxInCut = 0;
     278    int *index = NULL;
     279    double *coefficient = NULL;
    286280    double rhs[2];
    287     int n=0;
    288     while (n>=0) {
     281    int n = 0;
     282    while (n >= 0) {
    289283#ifndef NDEBUG
    290       numberRead = fread(&n,sizeof(int),1,fp);
    291       assert (numberRead==1);
     284      numberRead = fread(&n, sizeof(int), 1, fp);
     285      assert(numberRead == 1);
    292286#else
    293       fread(&n,sizeof(int),1,fp);
     287      fread(&n, sizeof(int), 1, fp);
    294288#endif
    295       if (n<0)
    296         break;
    297       if (n>maxInCut) {
    298         maxInCut=n;
    299         delete [] index;
    300         delete [] coefficient;
    301         index = new int [maxInCut];
    302         coefficient = new double [maxInCut];
     289      if (n < 0)
     290        break;
     291      if (n > maxInCut) {
     292        maxInCut = n;
     293        delete[] index;
     294        delete[] coefficient;
     295        index = new int[maxInCut];
     296        coefficient = new double[maxInCut];
    303297      }
    304298#ifndef NDEBUG
    305       numberRead = fread(rhs,sizeof(double),2,fp);
    306       assert (numberRead==2);
     299      numberRead = fread(rhs, sizeof(double), 2, fp);
     300      assert(numberRead == 2);
    307301#else
    308       fread(rhs,sizeof(double),2,fp);
     302      fread(rhs, sizeof(double), 2, fp);
    309303#endif
    310       fread(index,sizeof(int),n,fp);
    311       fread(coefficient,sizeof(double),n,fp);
     304      fread(index, sizeof(int), n, fp);
     305      fread(coefficient, sizeof(double), n, fp);
    312306      OsiRowCut rc;
    313       rc.setRow(n,index,coefficient,false);
     307      rc.setRow(n, index, coefficient, false);
    314308      rc.setLb(rhs[0]);
    315       rc.setUb(rhs[1]);   
     309      rc.setUb(rhs[1]);
    316310      cuts_.insert(rc);
    317311    }
    318     delete [] index;
    319     delete [] coefficient;
     312    delete[] index;
     313    delete[] coefficient;
    320314    fclose(fp);
    321315  }
     
    332326
    333327//-------------------------------------------------------------------
    334 // Destructor 
    335 //-------------------------------------------------------------------
    336 CglStored::~CglStored ()
    337 {
    338   delete  probingInfo_;
    339   delete [] bestSolution_;
    340   delete [] bounds_;
     328// Destructor
     329//-------------------------------------------------------------------
     330CglStored::~CglStored()
     331{
     332  delete probingInfo_;
     333  delete[] bestSolution_;
     334  delete[] bounds_;
    341335}
    342336
    343337//----------------------------------------------------------------
    344 // Assignment operator 
     338// Assignment operator
    345339//-------------------------------------------------------------------
    346340CglStored &
    347 CglStored::operator=(const CglStored& rhs)
     341CglStored::operator=(const CglStored &rhs)
    348342{
    349343  if (this != &rhs) {
    350344    CglCutGenerator::operator=(rhs);
    351     requiredViolation_=rhs.requiredViolation_;
    352     cuts_=rhs.cuts_;
     345    requiredViolation_ = rhs.requiredViolation_;
     346    cuts_ = rhs.cuts_;
    353347    delete probingInfo_;
    354348    if (rhs.probingInfo_)
     
    356350    else
    357351      probingInfo_ = NULL;
    358     delete [] bestSolution_;
    359     delete [] bounds_;
     352    delete[] bestSolution_;
     353    delete[] bounds_;
    360354    bestSolution_ = NULL;
    361355    bounds_ = NULL;
    362356    numberColumns_ = rhs.numberColumns_;
    363357    if (numberColumns_) {
    364       bestSolution_ = CoinCopyOfArray(rhs.bestSolution_,numberColumns_+1);
    365       bounds_ = CoinCopyOfArray(rhs.bounds_,2*numberColumns_);
     358      bestSolution_ = CoinCopyOfArray(rhs.bestSolution_, numberColumns_ + 1);
     359      bounds_ = CoinCopyOfArray(rhs.bounds_, 2 * numberColumns_);
    366360    }
    367361  }
     
    369363}
    370364// Save stuff
    371 void
    372 CglStored::saveStuff(double bestObjective, const double * bestSolution,
    373                      const double * lower, const double * upper)
    374 {
    375   assert (numberColumns_);
    376   delete [] bestSolution_;
    377   delete [] bounds_;
     365void CglStored::saveStuff(double bestObjective, const double *bestSolution,
     366  const double *lower, const double *upper)
     367{
     368  assert(numberColumns_);
     369  delete[] bestSolution_;
     370  delete[] bounds_;
    378371  if (bestSolution) {
    379     bestSolution_ = new double[numberColumns_+1];
    380     memcpy(bestSolution_,bestSolution,numberColumns_*sizeof(double));
    381     bestSolution_[numberColumns_]=bestObjective;
     372    bestSolution_ = new double[numberColumns_ + 1];
     373    memcpy(bestSolution_, bestSolution, numberColumns_ * sizeof(double));
     374    bestSolution_[numberColumns_] = bestObjective;
    382375  } else {
    383     bestSolution_=NULL;
    384   }
    385   bounds_ = new double [2*numberColumns_];
    386   memcpy(bounds_,lower,numberColumns_*sizeof(double));
    387   memcpy(bounds_+numberColumns_,upper,numberColumns_*sizeof(double));
     376    bestSolution_ = NULL;
     377  }
     378  bounds_ = new double[2 * numberColumns_];
     379  memcpy(bounds_, lower, numberColumns_ * sizeof(double));
     380  memcpy(bounds_ + numberColumns_, upper, numberColumns_ * sizeof(double));
    388381}
    389382// Best objective
    390 double 
     383double
    391384CglStored::bestObjective() const
    392385{
     
    396389    return COIN_DBL_MAX;
    397390}
     391
     392/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
     393*/
  • branches/autotools-update/Cgl/src/CglCommon/CglStored.hpp

    r1414 r1481  
    1515/** Stored Cut Generator Class */
    1616class CglStored : public CglCutGenerator {
    17  
     17
    1818public:
    19    
    20  
    2119  /**@name Generate Cuts */
    2220  //@{
     
    2927      and inserts any that are violated by enough
    3028  */
    31   virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
    32                              const CglTreeInfo info = CglTreeInfo());
     29  virtual void generateCuts(const OsiSolverInterface &si, OsiCuts &cs,
     30    const CglTreeInfo info = CglTreeInfo());
    3331  //@}
    3432
     
    3937  /// Set
    4038  inline void setRequiredViolation(double value)
    41   { requiredViolation_=value;}
     39  {
     40    requiredViolation_ = value;
     41  }
    4242  /// Get
    4343  inline double getRequiredViolation() const
    44   { return requiredViolation_;}
     44  {
     45    return requiredViolation_;
     46  }
    4547  /// Takes over ownership of probing info
    46   inline void setProbingInfo(CglTreeProbingInfo * info)
    47   { probingInfo_ = info;}
     48  inline void setProbingInfo(CglTreeProbingInfo *info)
     49  {
     50    probingInfo_ = info;
     51  }
    4852  //@}
    4953
     
    5155  //@{
    5256  /// Add cuts
    53   void addCut(const OsiCuts & cs);
     57  void addCut(const OsiCuts &cs);
    5458  /// Add a row cut
    55   void addCut(const OsiRowCut & cut);
     59  void addCut(const OsiRowCut &cut);
    5660  /// Add a row cut from a packed vector
    57   void addCut(double lb, double ub, const CoinPackedVector & vector);
     61  void addCut(double lb, double ub, const CoinPackedVector &vector);
    5862  /// Add a row cut from elements
    59   void addCut(double lb, double ub, int size, const int * colIndices, const double * elements);
     63  void addCut(double lb, double ub, int size, const int *colIndices, const double *elements);
    6064  inline int sizeRowCuts() const
    61   { return cuts_.sizeRowCuts();}
    62   const OsiRowCut * rowCutPointer(int index) const
    63   { return cuts_.rowCutPtr(index);}
     65  {
     66    return cuts_.sizeRowCuts();
     67  }
     68  const OsiRowCut *rowCutPointer(int index) const
     69  {
     70    return cuts_.rowCutPtr(index);
     71  }
    6472  /// Save stuff
    65   void saveStuff(double bestObjective, const double * bestSolution,
    66                  const double * lower, const double * upper);
     73  void saveStuff(double bestObjective, const double *bestSolution,
     74    const double *lower, const double *upper);
    6775  /// Best solution (or NULL)
    68   inline const double * bestSolution() const
    69   { return bestSolution_;}
     76  inline const double *bestSolution() const
     77  {
     78    return bestSolution_;
     79  }
    7080  /// Best objective
    7181  double bestObjective() const;
    7282  /// Tight lower bounds
    73   const double * tightLower() const
    74   { return bounds_;}
     83  const double *tightLower() const
     84  {
     85    return bounds_;
     86  }
    7587  /// Tight upper bounds
    76   const double * tightUpper() const
    77   { return bounds_+numberColumns_;}
     88  const double *tightUpper() const
     89  {
     90    return bounds_ + numberColumns_;
     91  }
    7892  //@}
    7993
    8094  /**@name Constructors and destructors */
    8195  //@{
    82   /// Default constructor 
    83   CglStored (int numberColumns=0);
    84  
    85   /// Copy constructor 
    86   CglStored (const CglStored & rhs);
     96  /// Default constructor
     97  CglStored(int numberColumns = 0);
     98
     99  /// Copy constructor
     100  CglStored(const CglStored &rhs);
    87101
    88102  /// Constructor from file
    89   CglStored (const char * fileName);
     103  CglStored(const char *fileName);
    90104
    91105  /// Clone
    92   virtual CglCutGenerator * clone() const;
     106  virtual CglCutGenerator *clone() const;
    93107
    94   /// Assignment operator 
     108  /// Assignment operator
    95109  CglStored &
    96     operator=(const CglStored& rhs);
    97  
    98   /// Destructor
    99   virtual
    100     ~CglStored ();
     110  operator=(const CglStored &rhs);
     111
     112  /// Destructor
     113  virtual ~CglStored();
    101114  //@}
    102      
     115
    103116protected:
    104  
    105  // Protected member methods
     117  // Protected member methods
    106118
    107119  // Protected member data
     
    112124  double requiredViolation_;
    113125  /// Pointer to probing information
    114   CglTreeProbingInfo * probingInfo_;
     126  CglTreeProbingInfo *probingInfo_;
    115127  /// Cuts
    116128  OsiCuts cuts_;
     
    118130  int numberColumns_;
    119131  /// Best solution (objective at end)
    120   double * bestSolution_;
     132  double *bestSolution_;
    121133  /// Tight bounds
    122   double * bounds_;
     134  double *bounds_;
    123135  //@}
    124136};
    125137#endif
     138
     139/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
     140*/
  • branches/autotools-update/Cgl/src/CglCommon/CglTreeInfo.cpp

    r1414 r1481  
    1919#include "OsiRowCut.hpp"
    2020
    21 // Default constructor
    22 CglTreeInfo::CglTreeInfo ()
    23   : level(-1), pass(-1), formulation_rows(-1), options(0), inTree(false),
    24     hasParent(0),parentSolver(NULL),originalColumns(NULL),
    25     strengthenRow(NULL),randomNumberGenerator(NULL) {}
     21// Default constructor
     22CglTreeInfo::CglTreeInfo()
     23  : level(-1)
     24  , pass(-1)
     25  , formulation_rows(-1)
     26  , options(0)
     27  , inTree(false)
     28  , hasParent(0)
     29  , parentSolver(NULL)
     30  , originalColumns(NULL)
     31  , strengthenRow(NULL)
     32  , randomNumberGenerator(NULL)
     33{
     34}
    2635
    27 // Copy constructor 
    28 CglTreeInfo::CglTreeInfo (const CglTreeInfo & rhs)
    29   : level(rhs.level),
    30     pass(rhs.pass),
    31     formulation_rows(rhs.formulation_rows),
    32     options(rhs.options),
    33     inTree(rhs.inTree),
    34     hasParent(rhs.hasParent),
    35     parentSolver(rhs.parentSolver),
    36     originalColumns(rhs.originalColumns),
    37     strengthenRow(rhs.strengthenRow),
    38     randomNumberGenerator(rhs.randomNumberGenerator)
     36// Copy constructor
     37CglTreeInfo::CglTreeInfo(const CglTreeInfo &rhs)
     38  : level(rhs.level)
     39  , pass(rhs.pass)
     40  , formulation_rows(rhs.formulation_rows)
     41  , options(rhs.options)
     42  , inTree(rhs.inTree)
     43  , hasParent(rhs.hasParent)
     44  , parentSolver(rhs.parentSolver)
     45  , originalColumns(rhs.originalColumns)
     46  , strengthenRow(rhs.strengthenRow)
     47  , randomNumberGenerator(rhs.randomNumberGenerator)
    3948{
    4049}
    4150// Clone
    42 CglTreeInfo * 
     51CglTreeInfo *
    4352CglTreeInfo::clone() const
    4453{
     
    4655}
    4756
    48 // Assignment operator 
     57// Assignment operator
    4958CglTreeInfo &
    50 CglTreeInfo::operator=(const CglTreeInfo& rhs)
     59CglTreeInfo::operator=(const CglTreeInfo &rhs)
    5160{
    5261  if (this != &rhs) {
    5362    //CglCutGenerator::operator=(rhs);
    54     level = rhs.level; 
    55     pass = rhs.pass; 
    56     formulation_rows = rhs.formulation_rows; 
     63    level = rhs.level;
     64    pass = rhs.pass;
     65    formulation_rows = rhs.formulation_rows;
    5766    options = rhs.options;
    5867    inTree = rhs.inTree;
     
    6574  return *this;
    6675}
    67  
    68  // Destructor
    69 CglTreeInfo::~CglTreeInfo ()
    70 {
    71 }
    7276
    73 // Default constructor
    74 CglTreeProbingInfo::CglTreeProbingInfo ()
    75   : CglTreeInfo(),
    76     fixEntry_(NULL),
    77     toZero_(NULL),
    78     toOne_(NULL),
    79     integerVariable_(NULL),
    80     backward_(NULL),
    81     fixingEntry_(NULL),
    82     numberVariables_(0),
    83     numberIntegers_(0),
    84     maximumEntries_(0),
    85     numberEntries_(-1)
     77// Destructor
     78CglTreeInfo::~CglTreeInfo()
     79{
     80}
     81
     82// Default constructor
     83CglTreeProbingInfo::CglTreeProbingInfo()
     84  : CglTreeInfo()
     85  , fixEntry_(NULL)
     86  , toZero_(NULL)
     87  , toOne_(NULL)
     88  , integerVariable_(NULL)
     89  , backward_(NULL)
     90  , fixingEntry_(NULL)
     91  , numberVariables_(0)
     92  , numberIntegers_(0)
     93  , maximumEntries_(0)
     94  , numberEntries_(-1)
    8695{
    8796}
    8897// Constructor from model
    89 CglTreeProbingInfo::CglTreeProbingInfo (const OsiSolverInterface * model)
    90   : CglTreeInfo(),
    91     fixEntry_(NULL),
    92     toZero_(NULL),
    93     toOne_(NULL),
    94     integerVariable_(NULL),
    95     backward_(NULL),
    96     fixingEntry_(NULL),
    97     numberVariables_(0),
    98     numberIntegers_(0),
    99     maximumEntries_(0),
    100     numberEntries_(-1)
    101 {
    102   numberVariables_=model->getNumCols();
     98CglTreeProbingInfo::CglTreeProbingInfo(const OsiSolverInterface *model)
     99  : CglTreeInfo()
     100  , fixEntry_(NULL)
     101  , toZero_(NULL)
     102  , toOne_(NULL)
     103  , integerVariable_(NULL)
     104  , backward_(NULL)
     105  , fixingEntry_(NULL)
     106  , numberVariables_(0)
     107  , numberIntegers_(0)
     108  , maximumEntries_(0)
     109  , numberEntries_(-1)
     110{
     111  numberVariables_ = model->getNumCols();
    103112  // Too many ... but
    104   integerVariable_ = new int [numberVariables_];
    105   backward_ = new int [numberVariables_];
     113  integerVariable_ = new int[numberVariables_];
     114  backward_ = new int[numberVariables_];
    106115  int i;
    107116  // Get integer types
    108   const char * columnType = model->getColType (true);
    109   for (i=0;i<numberVariables_;i++) {
    110     backward_[i]=-1;
     117  const char *columnType = model->getColType(true);
     118  for (i = 0; i < numberVariables_; i++) {
     119    backward_[i] = -1;
    111120    if (columnType[i]) {
    112       if (columnType[i]==1) {
    113         backward_[i]=numberIntegers_;
    114         integerVariable_[numberIntegers_++]=i;
     121      if (columnType[i] == 1) {
     122        backward_[i] = numberIntegers_;
     123        integerVariable_[numberIntegers_++] = i;
    115124      } else {
    116         backward_[i]=-2;
     125        backward_[i] = -2;
    117126      }
    118127    }
     
    120129  // Set up to arrays
    121130  toOne_ = new int[numberIntegers_];
    122   toZero_ = new int[numberIntegers_+1];
     131  toZero_ = new int[numberIntegers_ + 1];
    123132  // zero out
    124   CoinZeroN(toOne_,numberIntegers_);
    125   CoinZeroN(toZero_,numberIntegers_+1);
     133  CoinZeroN(toOne_, numberIntegers_);
     134  CoinZeroN(toZero_, numberIntegers_ + 1);
    126135}
    127136
    128 // Copy constructor 
    129 CglTreeProbingInfo::CglTreeProbingInfo (const CglTreeProbingInfo & rhs)
    130   : CglTreeInfo(rhs),
    131     fixEntry_(NULL),
    132     toZero_(NULL),
    133     toOne_(NULL),
    134     integerVariable_(NULL),
    135     backward_(NULL),
    136     fixingEntry_(NULL),
    137     numberVariables_(rhs.numberVariables_),
    138     numberIntegers_(rhs.numberIntegers_),
    139     maximumEntries_(rhs.maximumEntries_),
    140     numberEntries_(rhs.numberEntries_)
     137// Copy constructor
     138CglTreeProbingInfo::CglTreeProbingInfo(const CglTreeProbingInfo &rhs)
     139  : CglTreeInfo(rhs)
     140  , fixEntry_(NULL)
     141  , toZero_(NULL)
     142  , toOne_(NULL)
     143  , integerVariable_(NULL)
     144  , backward_(NULL)
     145  , fixingEntry_(NULL)
     146  , numberVariables_(rhs.numberVariables_)
     147  , numberIntegers_(rhs.numberIntegers_)
     148  , maximumEntries_(rhs.maximumEntries_)
     149  , numberEntries_(rhs.numberEntries_)
    141150{
    142151  if (numberVariables_) {
    143     fixEntry_ = new CliqueEntry [maximumEntries_];
    144     memcpy(fixEntry_,rhs.fixEntry_,maximumEntries_*sizeof(CliqueEntry));
    145     if (numberEntries_<0) {
     152    fixEntry_ = new CliqueEntry[maximumEntries_];
     153    memcpy(fixEntry_, rhs.fixEntry_, maximumEntries_ * sizeof(CliqueEntry));
     154    if (numberEntries_ < 0) {
    146155      // in order
    147       toZero_ = CoinCopyOfArray(rhs.toZero_,numberIntegers_+1);
    148       toOne_ = CoinCopyOfArray(rhs.toOne_,numberIntegers_);
     156      toZero_ = CoinCopyOfArray(rhs.toZero_, numberIntegers_ + 1);
     157      toOne_ = CoinCopyOfArray(rhs.toOne_, numberIntegers_);
    149158    } else {
    150159      // not in order
    151       fixingEntry_ = CoinCopyOfArray(rhs.fixingEntry_,maximumEntries_);
    152     }
    153     integerVariable_ = CoinCopyOfArray(rhs.integerVariable_,numberIntegers_);
    154     backward_ = CoinCopyOfArray(rhs.backward_,numberVariables_);
     160      fixingEntry_ = CoinCopyOfArray(rhs.fixingEntry_, maximumEntries_);
     161    }
     162    integerVariable_ = CoinCopyOfArray(rhs.integerVariable_, numberIntegers_);
     163    backward_ = CoinCopyOfArray(rhs.backward_, numberVariables_);
    155164  }
    156165}
    157166// Clone
    158 CglTreeInfo * 
     167CglTreeInfo *
    159168CglTreeProbingInfo::clone() const
    160169{
     
    162171}
    163172
    164 // Assignment operator 
     173// Assignment operator
    165174CglTreeProbingInfo &
    166 CglTreeProbingInfo::operator=(const CglTreeProbingInfo& rhs)
     175CglTreeProbingInfo::operator=(const CglTreeProbingInfo &rhs)
    167176{
    168177  if (this != &rhs) {
    169178    CglTreeInfo::operator=(rhs);
    170     delete [] fixEntry_;
    171     delete [] toZero_;
    172     delete [] toOne_;
    173     delete [] integerVariable_;
    174     delete [] backward_;
    175     delete [] fixingEntry_;
     179    delete[] fixEntry_;
     180    delete[] toZero_;
     181    delete[] toOne_;
     182    delete[] integerVariable_;
     183    delete[] backward_;
     184    delete[] fixingEntry_;
    176185    numberVariables_ = rhs.numberVariables_;
    177186    numberIntegers_ = rhs.numberIntegers_;
     
    179188    numberEntries_ = rhs.numberEntries_;
    180189    if (numberVariables_) {
    181       fixEntry_ = new CliqueEntry [maximumEntries_];
    182       memcpy(fixEntry_,rhs.fixEntry_,maximumEntries_*sizeof(CliqueEntry));
    183       if (numberEntries_<0) {
    184         // in order
    185         toZero_ = CoinCopyOfArray(rhs.toZero_,numberIntegers_+1);
    186         toOne_ = CoinCopyOfArray(rhs.toOne_,numberIntegers_);
    187         fixingEntry_ = NULL;
     190      fixEntry_ = new CliqueEntry[maximumEntries_];
     191      memcpy(fixEntry_, rhs.fixEntry_, maximumEntries_ * sizeof(CliqueEntry));
     192      if (numberEntries_ < 0) {
     193        // in order
     194        toZero_ = CoinCopyOfArray(rhs.toZero_, numberIntegers_ + 1);
     195        toOne_ = CoinCopyOfArray(rhs.toOne_, numberIntegers_);
     196        fixingEntry_ = NULL;
    188197      } else {
    189         // not in order
    190         fixingEntry_ = CoinCopyOfArray(rhs.fixingEntry_,maximumEntries_);
    191         toZero_ = NULL;
    192         toOne_ = NULL;
    193       }
    194       toZero_ = CoinCopyOfArray(rhs.toZero_,numberIntegers_+1);
    195       toOne_ = CoinCopyOfArray(rhs.toOne_,numberIntegers_);
    196       integerVariable_ = CoinCopyOfArray(rhs.integerVariable_,numberIntegers_);
    197       backward_ = CoinCopyOfArray(rhs.backward_,numberVariables_);
     198        // not in order
     199        fixingEntry_ = CoinCopyOfArray(rhs.fixingEntry_, maximumEntries_);
     200        toZero_ = NULL;
     201        toOne_ = NULL;
     202      }
     203      toZero_ = CoinCopyOfArray(rhs.toZero_, numberIntegers_ + 1);
     204      toOne_ = CoinCopyOfArray(rhs.toOne_, numberIntegers_);
     205      integerVariable_ = CoinCopyOfArray(rhs.integerVariable_, numberIntegers_);
     206      backward_ = CoinCopyOfArray(rhs.backward_, numberVariables_);
    198207    } else {
    199208      fixEntry_ = NULL;
     
    207216  return *this;
    208217}
    209  
    210  // Destructor
    211 CglTreeProbingInfo::~CglTreeProbingInfo ()
    212 {
    213   delete [] fixEntry_;
    214   delete [] toZero_;
    215   delete [] toOne_;
    216   delete [] integerVariable_;
    217   delete [] backward_;
    218   delete [] fixingEntry_;
    219 }
    220 static int outDupsEtc(int numberIntegers, int & numberCliques, int & numberMatrixCliques,
    221                       CoinBigIndex * & cliqueStart, char * & cliqueType, CliqueEntry *& entry,
    222                       int numberLastTime, int printit)
    223 {
    224   bool allNew=false;
    225   int * whichP = new int [numberIntegers];
     218
     219// Destructor
     220CglTreeProbingInfo::~CglTreeProbingInfo()
     221{
     222  delete[] fixEntry_;
     223  delete[] toZero_;
     224  delete[] toOne_;
     225  delete[] integerVariable_;
     226  delete[] backward_;
     227  delete[] fixingEntry_;
     228}
     229static int outDupsEtc(int numberIntegers, int &numberCliques, int &numberMatrixCliques,
     230  CoinBigIndex *&cliqueStart, char *&cliqueType, CliqueEntry *&entry,
     231  int numberLastTime, int printit)
     232{
     233  bool allNew = false;
     234  int *whichP = new int[numberIntegers];
    226235  int iClique;
    227   assert (sizeof(int)==4);
    228   assert (sizeof(CliqueEntry)==4);
     236  assert(sizeof(int) == 4);
     237  assert(sizeof(CliqueEntry) == 4);
    229238  // If lots then get rid of short ones
    230239#define KEEP_CLIQUES 10000
    231   if (numberCliques-numberMatrixCliques>KEEP_CLIQUES) {
    232     int * sort = new int [numberCliques];
    233     for (iClique=numberMatrixCliques;iClique<numberCliques;iClique++) {
     240  if (numberCliques - numberMatrixCliques > KEEP_CLIQUES) {
     241    int *sort = new int[numberCliques];
     242    for (iClique = numberMatrixCliques; iClique < numberCliques; iClique++) {
    234243      CoinBigIndex j = cliqueStart[iClique];
    235       int n = static_cast<int>(cliqueStart[iClique+1]-j);
    236       sort[iClique]=n;
    237     }
    238     std::sort(sort+numberMatrixCliques,sort+numberCliques);
    239     int allow = sort[numberCliques-KEEP_CLIQUES];
    240     int nEqual=0;
    241     for (iClique=numberCliques-KEEP_CLIQUES;iClique<numberCliques;iClique++) {
    242       if (sort[iClique]>allow)
    243         break;
     244      int n = static_cast< int >(cliqueStart[iClique + 1] - j);
     245      sort[iClique] = n;
     246    }
     247    std::sort(sort + numberMatrixCliques, sort + numberCliques);
     248    int allow = sort[numberCliques - KEEP_CLIQUES];
     249    int nEqual = 0;
     250    for (iClique = numberCliques - KEEP_CLIQUES; iClique < numberCliques; iClique++) {
     251      if (sort[iClique] > allow)
     252        break;
    244253      else
    245         nEqual++;
    246     }
    247     delete [] sort;
    248     CoinBigIndex j=cliqueStart[numberMatrixCliques];
    249     CoinBigIndex put=j;
    250     int nClique=numberMatrixCliques;
    251     for (iClique=numberMatrixCliques;iClique<numberCliques;iClique++) {
    252       CoinBigIndex end = cliqueStart[iClique+1];
    253       int n = static_cast<int>(end-j);
    254       bool copy=false;
    255       if (n>allow) {
    256         copy=true;
    257       } else if (n==allow&&nEqual) {
    258         copy=true;
    259         nEqual--;
     254        nEqual++;
     255    }
     256    delete[] sort;
     257    CoinBigIndex j = cliqueStart[numberMatrixCliques];
     258    CoinBigIndex put = j;
     259    int nClique = numberMatrixCliques;
     260    for (iClique = numberMatrixCliques; iClique < numberCliques; iClique++) {
     261      CoinBigIndex end = cliqueStart[iClique + 1];
     262      int n = static_cast< int >(end - j);
     263      bool copy = false;
     264      if (n > allow) {
     265        copy = true;
     266      } else if (n == allow && nEqual) {
     267        copy = true;
     268        nEqual--;
    260269      }
    261270      if (copy) {
    262         cliqueType[nClique++]=cliqueType[iClique];
    263         for (;j<end;j++)
    264           entry[put++]=entry[j];
    265       }
    266       j = cliqueStart[iClique+1];
    267       cliqueStart[nClique]=put;
     271        cliqueType[nClique++] = cliqueType[iClique];
     272        for (; j < end; j++)
     273          entry[put++] = entry[j];
     274      }
     275      j = cliqueStart[iClique + 1];
     276      cliqueStart[nClique] = put;
    268277    }
    269278    numberCliques = nClique;
    270279  }
    271280  // sort
    272   for (iClique=0;iClique<numberCliques;iClique++) {
     281  for (iClique = 0; iClique < numberCliques; iClique++) {
    273282    CoinBigIndex j = cliqueStart[iClique];
    274     int n = static_cast<int>(cliqueStart[iClique+1]-j);
    275     for (int i=0;i<n;i++)
    276       whichP[i]=sequenceInCliqueEntry(entry[i+j]);
    277     CoinSort_2(whichP,whichP+n,(reinterpret_cast<int *>(entry))+j);
     283    int n = static_cast< int >(cliqueStart[iClique + 1] - j);
     284    for (int i = 0; i < n; i++)
     285      whichP[i] = sequenceInCliqueEntry(entry[i + j]);
     286    CoinSort_2(whichP, whichP + n, (reinterpret_cast< int * >(entry)) + j);
    278287  }
    279288  // lexicographic sort
    280   int * which = new int [numberCliques];
    281   CoinBigIndex * position = new CoinBigIndex [numberCliques];
    282   int * sort = new int [numberCliques];
    283   int * value = new int [numberCliques];
    284   for (iClique=0;iClique<numberCliques;iClique++) {
    285     which[iClique]=iClique;
    286     sort[iClique]=sequenceInCliqueEntry(entry[cliqueStart[iClique]]);
    287     value[iClique]=sort[iClique];
    288     position[iClique]=0;
    289   }
    290   CoinSort_2(sort,sort+numberCliques,which);
    291   int lastDone=-1;
    292   int nDup=0;
    293   CoinBigIndex nSave=0;
    294   while (lastDone<numberCliques-1) {
    295     int jClique=lastDone+1;
     289  int *which = new int[numberCliques];
     290  CoinBigIndex *position = new CoinBigIndex[numberCliques];
     291  int *sort = new int[numberCliques];
     292  int *value = new int[numberCliques];
     293  for (iClique = 0; iClique < numberCliques; iClique++) {
     294    which[iClique] = iClique;
     295    sort[iClique] = sequenceInCliqueEntry(entry[cliqueStart[iClique]]);
     296    value[iClique] = sort[iClique];
     297    position[iClique] = 0;
     298  }
     299  CoinSort_2(sort, sort + numberCliques, which);
     300  int lastDone = -1;
     301  int nDup = 0;
     302  CoinBigIndex nSave = 0;
     303  while (lastDone < numberCliques - 1) {
     304    int jClique = lastDone + 1;
    296305    int jFirst = jClique;
    297306    int iFirst = which[jFirst];
     
    299308    CoinBigIndex iPos = position[iFirst];
    300309    jClique++;
    301     for (;jClique<numberCliques;jClique++) {
     310    for (; jClique < numberCliques; jClique++) {
    302311      int kClique = which[jClique];
    303312      int jValue = value[kClique];
    304       if (jValue>iValue||position[kClique]<iPos)
    305         break;
    306     }
    307     if (jClique==jFirst+1) {
     313      if (jValue > iValue || position[kClique] < iPos)
     314        break;
     315    }
     316    if (jClique == jFirst + 1) {
    308317      // done that bit
    309318      lastDone++;
    310319    } else {
    311320      // use next bit to sort and then repeat
    312       int jLast=jClique;
    313       for (jClique=jFirst;jClique<jLast;jClique++) {
    314         int kClique = which[jClique];
    315         int iValue = value[kClique];
    316         // put at end if finished
    317         if (iValue<numberIntegers) {
    318           CoinBigIndex kPos=position[kClique]+1;
    319           position[kClique]=kPos;
    320           kPos += cliqueStart[kClique];
    321           if (kPos==cliqueStart[kClique+1]) {
    322             iValue = numberIntegers;
    323           } else {
    324             iValue = sequenceInCliqueEntry(entry[kPos]);
    325           }
    326           value[kClique]=iValue;
    327         }
    328         sort[jClique]=iValue;
    329       }
    330       CoinSort_2(sort+jFirst,sort+jLast,which+jFirst);
     321      int jLast = jClique;
     322      for (jClique = jFirst; jClique < jLast; jClique++) {
     323        int kClique = which[jClique];
     324        int iValue = value[kClique];
     325        // put at end if finished
     326        if (iValue < numberIntegers) {
     327          CoinBigIndex kPos = position[kClique] + 1;
     328          position[kClique] = kPos;
     329          kPos += cliqueStart[kClique];
     330          if (kPos == cliqueStart[kClique + 1]) {
     331            iValue = numberIntegers;
     332          } else {
     333            iValue = sequenceInCliqueEntry(entry[kPos]);
     334          }
     335          value[kClique] = iValue;
     336        }
     337        sort[jClique] = iValue;
     338      }
     339      CoinSort_2(sort + jFirst, sort + jLast, which + jFirst);
    331340      // if duplicate mark and move on
    332       int iLowest=numberCliques;
    333       for (jClique=jFirst;jClique<jLast;jClique++) {
    334         int kClique = which [jClique];
    335         int iValue = value[kClique];
    336         if (iValue<numberIntegers)
    337           break;
    338         iLowest = CoinMin(iLowest,kClique);
    339       }
    340       if (jClique>jFirst) {
    341         // mark all apart from lowest number as duplicate and move on
    342         lastDone =jClique-1;
    343         for (jClique=jFirst;jClique<=lastDone;jClique++) {
    344           int kClique = which [jClique];
    345           if (kClique!=iLowest) {
    346             value[kClique]=-2;
    347             nDup++;
    348             nSave += cliqueStart[kClique+1]-cliqueStart[kClique];
    349           }
    350         }
     341      int iLowest = numberCliques;
     342      for (jClique = jFirst; jClique < jLast; jClique++) {
     343        int kClique = which[jClique];
     344        int iValue = value[kClique];
     345        if (iValue < numberIntegers)
     346          break;
     347        iLowest = CoinMin(iLowest, kClique);
     348      }
     349      if (jClique > jFirst) {
     350        // mark all apart from lowest number as duplicate and move on
     351        lastDone = jClique - 1;
     352        for (jClique = jFirst; jClique <= lastDone; jClique++) {
     353          int kClique = which[jClique];
     354          if (kClique != iLowest) {
     355            value[kClique] = -2;
     356            nDup++;
     357            nSave += cliqueStart[kClique + 1] - cliqueStart[kClique];
     358          }
     359        }
    351360      }
    352361    }
    353362  }
    354363  if (printit)
    355     printf("%d duplicates\n",nDup);
     364    printf("%d duplicates\n", nDup);
    356365  // Now see if any subset
    357   int nOut=0;
    358   for (int jClique=0;jClique<numberCliques;jClique++) {
    359     if (value[jClique]!=-2) {
    360       position[jClique]=cliqueStart[jClique];
    361       value[jClique]=sequenceInCliqueEntry(entry[cliqueStart[jClique]]);
    362     }
    363   }
    364   nSave=0;
    365   int startLooking=0;
    366   for (int jClique=0;jClique<numberCliques;jClique++) {
     366  int nOut = 0;
     367  for (int jClique = 0; jClique < numberCliques; jClique++) {
     368    if (value[jClique] != -2) {
     369      position[jClique] = cliqueStart[jClique];
     370      value[jClique] = sequenceInCliqueEntry(entry[cliqueStart[jClique]]);
     371    }
     372  }
     373  nSave = 0;
     374  int startLooking = 0;
     375  for (int jClique = 0; jClique < numberCliques; jClique++) {
    367376    int kClique = which[jClique];
    368     if (value[kClique]==-2) {
     377    if (value[kClique] == -2) {
    369378      nOut++;
    370       nSave += cliqueStart[kClique+1]-cliqueStart[kClique];
    371       if (jClique==startLooking)
    372         startLooking++;
     379      nSave += cliqueStart[kClique + 1] - cliqueStart[kClique];
     380      if (jClique == startLooking)
     381        startLooking++;
    373382      continue;
    374383    }
    375     int kValue =value[kClique];
    376     for (int iiClique=startLooking;iiClique<jClique;iiClique++) {
     384    int kValue = value[kClique];
     385    for (int iiClique = startLooking; iiClique < jClique; iiClique++) {
    377386      int iClique = which[iiClique];
    378387      int iValue = value[iClique];
    379       if (iValue==-2||iValue==numberIntegers) {
    380         if (iiClique==startLooking)
    381           startLooking++;
    382         continue;
     388      if (iValue == -2 || iValue == numberIntegers) {
     389        if (iiClique == startLooking)
     390          startLooking++;
     391        continue;
    383392      } else {
    384         if (kValue>static_cast<int> (sequenceInCliqueEntry(entry[cliqueStart[iClique+1]-1]))) {
    385           value[iClique]=numberIntegers;
    386           continue;
    387         }
    388       }
    389       if (iValue<kValue) {
    390         while (iValue<kValue) {
    391           CoinBigIndex iPos=position[iClique]+1;
    392           position[iClique]=iPos;
    393           if (iPos==cliqueStart[iClique+1]) {
    394             iValue = numberIntegers;
    395           } else {
    396             iValue = sequenceInCliqueEntry(entry[iPos]);
    397           }
    398           value[iClique]=iValue;
    399         }
    400       } 
    401       if (iValue>kValue)
    402         continue; // not a candidate
     393        if (kValue > static_cast< int >(sequenceInCliqueEntry(entry[cliqueStart[iClique + 1] - 1]))) {
     394          value[iClique] = numberIntegers;
     395          continue;
     396        }
     397      }
     398      if (iValue < kValue) {
     399        while (iValue < kValue) {
     400          CoinBigIndex iPos = position[iClique] + 1;
     401          position[iClique] = iPos;
     402          if (iPos == cliqueStart[iClique + 1]) {
     403            iValue = numberIntegers;
     404          } else {
     405            iValue = sequenceInCliqueEntry(entry[iPos]);
     406          }
     407          value[iClique] = iValue;
     408        }
     409      }
     410      if (iValue > kValue)
     411        continue; // not a candidate
    403412      // See if subset (remember duplicates have gone)
    404       if (cliqueStart[iClique+1]-position[iClique]>
    405           cliqueStart[kClique+1]-cliqueStart[kClique]) {
    406         // could be subset ?
    407         CoinBigIndex offset = cliqueStart[iClique]-position[kClique];
    408         CoinBigIndex j;
    409         bool subset=true;
    410         // what about different fixes bool odd=false;
    411         for (j=cliqueStart[kClique]+1;j<cliqueStart[kClique+1];j++) {
    412           int kColumn = sequenceInCliqueEntry(entry[j]);
    413           int iColumn = sequenceInCliqueEntry(entry[j+offset]);
    414           if (iColumn>kColumn) {
    415             subset=false;
    416           } else {
    417             while (iColumn<kColumn) {
    418               offset++;
    419               if (j+offset<cliqueStart[iClique+1]) {
    420                 iColumn = sequenceInCliqueEntry(entry[j+offset]);
    421               } else {
    422                 subset=false;
    423                 break;
    424               }
    425             }
    426           }
    427           if (!subset)
    428             break;
    429         }
    430         if (subset) {
    431           value[kClique]=-2;
    432           if (printit>1)
    433             printf("clique %d is subset of %d\n",kClique,iClique);
    434           nOut++;
    435           break;
    436         }
     413      if (cliqueStart[iClique + 1] - position[iClique] > cliqueStart[kClique + 1] - cliqueStart[kClique]) {
     414        // could be subset ?
     415        CoinBigIndex offset = cliqueStart[iClique] - position[kClique];
     416        CoinBigIndex j;
     417        bool subset = true;
     418        // what about different fixes bool odd=false;
     419        for (j = cliqueStart[kClique] + 1; j < cliqueStart[kClique + 1]; j++) {
     420          int kColumn = sequenceInCliqueEntry(entry[j]);
     421          int iColumn = sequenceInCliqueEntry(entry[j + offset]);
     422          if (iColumn > kColumn) {
     423            subset = false;
     424          } else {
     425            while (iColumn < kColumn) {
     426              offset++;
     427              if (j + offset < cliqueStart[iClique + 1]) {
     428                iColumn = sequenceInCliqueEntry(entry[j + offset]);
     429              } else {
     430                subset = false;
     431                break;
     432              }
     433            }
     434          }
     435          if (!subset)
     436            break;
     437        }
     438        if (subset) {
     439          value[kClique] = -2;
     440          if (printit > 1)
     441            printf("clique %d is subset of %d\n", kClique, iClique);
     442          nOut++;
     443          break;
     444        }
    437445      }
    438446    }
    439447  }
    440448  if (nOut) {
    441     if(printit)
    442       printf("Can get rid of %d cliques\n",nOut);
     449    if (printit)
     450      printf("Can get rid of %d cliques\n", nOut);
    443451    // make new copy
    444     int nNewC=numberCliques-nOut;
    445     int size = static_cast<int>(cliqueStart[numberCliques]-nSave);
    446     int n=0;
    447     CoinBigIndex * start = new CoinBigIndex [nNewC+1];
    448     char * type = new char [nNewC];
    449     start[0]=0;
    450     CliqueEntry * entryC = new CliqueEntry [size];
    451     CoinBigIndex nel=0;
     452    int nNewC = numberCliques - nOut;
     453    int size = static_cast< int >(cliqueStart[numberCliques] - nSave);
     454    int n = 0;
     455    CoinBigIndex *start = new CoinBigIndex[nNewC + 1];
     456    char *type = new char[nNewC];
     457    start[0] = 0;
     458    CliqueEntry *entryC = new CliqueEntry[size];
     459    CoinBigIndex nel = 0;
    452460    allNew = true;
    453     for (int jClique=0;jClique<numberCliques;jClique++) {
     461    for (int jClique = 0; jClique < numberCliques; jClique++) {
    454462      int kClique = which[jClique];
    455       if (value[kClique]!=-2&&kClique<numberMatrixCliques) {
    456         if (kClique>=numberLastTime)
    457           allNew=false;
    458         int nn=static_cast<int>(cliqueStart[kClique+1]-cliqueStart[kClique]);
    459         memcpy(entryC+nel,entry+cliqueStart[kClique],nn*sizeof(CliqueEntry));
    460         nel += nn;
    461         type[n++]=cliqueType[kClique];
    462         start[n]=nel;
    463       }
    464     }
    465     int nM=n;
    466     for (int jClique=0;jClique<numberCliques;jClique++) {
     463      if (value[kClique] != -2 && kClique < numberMatrixCliques) {
     464        if (kClique >= numberLastTime)
     465          allNew = false;
     466        int nn = static_cast< int >(cliqueStart[kClique + 1] - cliqueStart[kClique]);
     467        memcpy(entryC + nel, entry + cliqueStart[kClique], nn * sizeof(CliqueEntry));
     468        nel += nn;
     469        type[n++] = cliqueType[kClique];
     470        start[n] = nel;
     471      }
     472    }
     473    int nM = n;
     474    for (int jClique = 0; jClique < numberCliques; jClique++) {
    467475      int kClique = which[jClique];
    468       if (value[kClique]!=-2&&kClique>=numberMatrixCliques) {
    469         if (kClique>=numberLastTime)
    470           allNew=false;
    471         int nn=static_cast<int>(cliqueStart[kClique+1]-cliqueStart[kClique]);
    472         memcpy(entryC+nel,entry+cliqueStart[kClique],nn*sizeof(CliqueEntry));
    473         nel += nn;
    474         type[n++]=cliqueType[kClique];
    475         start[n]=nel;
     476      if (value[kClique] != -2 && kClique >= numberMatrixCliques) {
     477        if (kClique >= numberLastTime)
     478          allNew = false;
     479        int nn = static_cast< int >(cliqueStart[kClique + 1] - cliqueStart[kClique]);
     480        memcpy(entryC + nel, entry + cliqueStart[kClique], nn * sizeof(CliqueEntry));
     481        nel += nn;
     482        type[n++] = cliqueType[kClique];
     483        start[n] = nel;
    476484      }
    477485    }
    478486    // move
    479     numberCliques=n;
    480     numberMatrixCliques=nM;
    481     delete [] cliqueStart;
    482     cliqueStart=start;
    483     delete [] entry;
     487    numberCliques = n;
     488    numberMatrixCliques = nM;
     489    delete[] cliqueStart;
     490    cliqueStart = start;
     491    delete[] entry;
    484492    entry = entryC;
    485     delete [] cliqueType;
     493    delete[] cliqueType;
    486494    cliqueType = type;
    487     if (printit>1) {
    488       for (int jClique=0;jClique<numberCliques;jClique++) {
    489         printf("%d [ ",jClique);
    490         for (CoinBigIndex i=cliqueStart[jClique];i<cliqueStart[jClique+1];i++)
    491           printf("%d(%d) ",sequenceInCliqueEntry(entry[i]),oneFixesInCliqueEntry(entry[i]));
    492         printf("]\n");
     495    if (printit > 1) {
     496      for (int jClique = 0; jClique < numberCliques; jClique++) {
     497        printf("%d [ ", jClique);
     498        for (CoinBigIndex i = cliqueStart[jClique]; i < cliqueStart[jClique + 1]; i++)
     499          printf("%d(%d) ", sequenceInCliqueEntry(entry[i]), oneFixesInCliqueEntry(entry[i]));
     500        printf("]\n");
    493501      }
    494502    }
    495503    if (printit)
    496       printf("%d matrix cliques and %d found by probing\n",numberMatrixCliques,numberCliques-numberMatrixCliques);
    497   }
    498   delete [] value;
    499   delete [] sort;
    500   delete [] which;
    501   delete [] position;
    502   delete [] whichP;
     504      printf("%d matrix cliques and %d found by probing\n", numberMatrixCliques, numberCliques - numberMatrixCliques);
     505  }
     506  delete[] value;
     507  delete[] sort;
     508  delete[] which;
     509  delete[] position;
     510  delete[] whichP;
    503511  if (!allNew)
    504512    return nOut;
     
    507515}
    508516OsiSolverInterface *
    509 CglTreeProbingInfo::analyze(const OsiSolverInterface & si,int createSolver,
    510                             int numberExtraCliques,const CoinBigIndex * starts,
    511                             const CliqueEntry * entries,const char * type)
     517CglTreeProbingInfo::analyze(const OsiSolverInterface &si, int createSolver,
     518  int numberExtraCliques, const CoinBigIndex *starts,
     519  const CliqueEntry *entries, const char *type)
    512520{
    513521  if (!createSolver)
     
    516524  if (!numberIntegers_)
    517525    return NULL;
    518   bool alwaysDo=false;
    519   if (numberExtraCliques<0) {
    520     alwaysDo=true;
    521     numberExtraCliques=0;
    522   }
    523   bool printit=false;
    524   int numberCliques=0;
    525   CoinBigIndex numberEntries=0;
    526   CoinBigIndex * cliqueStart = NULL;
    527   CliqueEntry * entry = NULL;
    528   char * cliqueType=NULL;
    529   int * whichP = new int [numberIntegers_];
    530   int * whichM = new int [numberIntegers_];
    531   int *whichClique=NULL;
    532   int numberRows=si.getNumRows();
    533   int numberMatrixCliques=0;
    534   const CoinPackedMatrix * rowCopy = si.getMatrixByRow();
    535   assert(numberRows&&si.getNumCols());
     526  bool alwaysDo = false;
     527  if (numberExtraCliques < 0) {
     528    alwaysDo = true;
     529    numberExtraCliques = 0;
     530  }
     531  bool printit = false;
     532  int numberCliques = 0;
     533  CoinBigIndex numberEntries = 0;
     534  CoinBigIndex *cliqueStart = NULL;
     535  CliqueEntry *entry = NULL;
     536  char *cliqueType = NULL;
     537  int *whichP = new int[numberIntegers_];
     538  int *whichM = new int[numberIntegers_];
     539  int *whichClique = NULL;
     540  int numberRows = si.getNumRows();
     541  int numberMatrixCliques = 0;
     542  const CoinPackedMatrix *rowCopy = si.getMatrixByRow();
     543  assert(numberRows && si.getNumCols());
    536544  int iRow;
    537   const int * column = rowCopy->getIndices();
    538   const double * elementByRow = rowCopy->getElements();
    539   const CoinBigIndex * rowStart = rowCopy->getVectorStarts();
    540   const int * rowLength = rowCopy->getVectorLengths();
    541   const double * lower = si.getColLower();
    542   const double * upper = si.getColUpper();
    543   const double * rowLower = si.getRowLower();
    544   const double * rowUpper = si.getRowUpper();
    545   for (int iPass=0;iPass<2;iPass++) {
     545  const int *column = rowCopy->getIndices();
     546  const double *elementByRow = rowCopy->getElements();
     547  const CoinBigIndex *rowStart = rowCopy->getVectorStarts();
     548  const int *rowLength = rowCopy->getVectorLengths();
     549  const double *lower = si.getColLower();
     550  const double *upper = si.getColUpper();
     551  const double *rowLower = si.getRowLower();
     552  const double *rowUpper = si.getRowUpper();
     553  for (int iPass = 0; iPass < 2; iPass++) {
    546554    if (iPass) {
    547       CoinBigIndex numberExtraEntries=0;
    548       if (numberExtraCliques) 
    549         numberExtraEntries = starts[numberExtraCliques];
    550       cliqueStart = new CoinBigIndex [numberCliques+1+numberExtraCliques];
    551       cliqueStart[0]=0;
    552       entry = new CliqueEntry [numberEntries+numberExtraEntries];
    553       cliqueType = new char [numberCliques+numberExtraCliques];
    554       whichClique = new int [numberEntries+numberExtraEntries];
    555       numberCliques=0;
    556       numberEntries=0;
     555      CoinBigIndex numberExtraEntries = 0;
     556      if (numberExtraCliques)
     557        numberExtraEntries = starts[numberExtraCliques];
     558      cliqueStart = new CoinBigIndex[numberCliques + 1 + numberExtraCliques];
     559      cliqueStart[0] = 0;
     560      entry = new CliqueEntry[numberEntries + numberExtraEntries];
     561      cliqueType = new char[numberCliques + numberExtraCliques];
     562      whichClique = new int[numberEntries + numberExtraEntries];
     563      numberCliques = 0;
     564      numberEntries = 0;
    557565    }
    558566#if 1
    559     for (iRow=0;iRow<numberRows;iRow++) {
    560       int numberP1=0, numberM1=0;
    561       int numberTotal=0;
     567    for (iRow = 0; iRow < numberRows; iRow++) {
     568      int numberP1 = 0, numberM1 = 0;
     569      int numberTotal = 0;
    562570      CoinBigIndex j;
    563       double upperValue=rowUpper[iRow];
    564       double lowerValue=rowLower[iRow];
    565       bool good=true;
    566       for (j=rowStart[iRow];j<rowStart[iRow]+rowLength[iRow];j++) {
    567         int iColumn = column[j];
    568         double value = elementByRow[j];
    569         if (upper[iColumn]-lower[iColumn]<1.0e-8) {
    570           // fixed
    571           upperValue -= lower[iColumn]*value;
    572           lowerValue -= lower[iColumn]*value;
    573           continue;
    574         } else if (backward_[iColumn]<0) {
    575           good = false;
    576           break;
    577         } else {
    578           iColumn = backward_[iColumn];
    579           numberTotal++;
    580         }
    581         if (fabs(value)!=1.0) {
    582           good=false;
    583         } else if (value>0.0) {
    584           assert (numberP1<numberIntegers_);
    585           whichP[numberP1++]=iColumn;;
    586         } else {
    587           assert (numberM1<numberIntegers_);
    588           whichM[numberM1++]=iColumn;
    589         }
    590       }
    591       int iUpper = static_cast<int> (floor(upperValue+1.0e-5));
    592       int iLower = static_cast<int> (ceil(lowerValue-1.0e-5));
    593       int state=0;
    594       if (upperValue<1.0e6) {
    595         if (iUpper==1-numberM1)
    596           state=1;
    597         else if (iUpper==-numberM1)
    598           state=2;
    599         else if (iUpper<-numberM1)
    600           state=3;
    601         if (fabs(static_cast<double> (iUpper)-upperValue)>1.0e-9)
    602           state =-1;
    603       }
    604       if (!state&&lowerValue>-1.0e6) {
    605         if (-iLower==1-numberP1)
    606           state=-1;
    607         else if (-iLower==-numberP1)
    608           state=-2;
    609         else if (-iLower<-numberP1)
    610           state=-3;
    611         if (fabs(static_cast<double> (iLower)-lowerValue)>1.0e-9)
    612           state =-1;
    613       }
    614       if (numberP1+numberM1<2)
    615         state=-1;
    616       if (good&&state>0) {
    617         if (abs(state)==3) {
    618           // infeasible
    619           printf("FFF Infeasible\n");;
    620           //feasible=false;
    621           break;
    622         } else if (abs(state)==2) {
    623           // we can fix all
    624           //numberFixed += numberP1+numberM1;
    625           printf("FFF can fix %d\n",numberP1+numberM1);
    626         } else {
    627           for (j=0;j<numberP1;j++) {
    628             int iColumn = whichP[j];
    629             if (iPass) {
    630               CliqueEntry temp;
    631               setOneFixesInCliqueEntry(temp,true);
    632               setSequenceInCliqueEntry(temp,iColumn);
    633               entry[numberEntries]=temp;
    634             }
    635             numberEntries++;
    636           }
    637           for (j=0;j<numberM1;j++) {
    638             int iColumn = whichM[j];
    639             if (iPass) {
    640               CliqueEntry temp;
    641               setOneFixesInCliqueEntry(temp,false);
    642               setSequenceInCliqueEntry(temp,iColumn);
    643               entry[numberEntries]=temp;
    644             }
    645             numberEntries++;
    646           }
    647           if (iPass) {
    648             if (iLower!=iUpper) {
    649               // slack
    650               cliqueType[numberCliques]='S';
    651             } else {
    652               cliqueType[numberCliques]='E';
    653             }
    654             cliqueStart[numberCliques+1]=numberEntries;
    655           }
    656           numberCliques++;
    657         }
     571      double upperValue = rowUpper[iRow];
     572      double lowerValue = rowLower[iRow];
     573      bool good = true;
     574      for (j = rowStart[iRow]; j < rowStart[iRow] + rowLength[iRow]; j++) {
     575        int iColumn = column[j];
     576        double value = elementByRow[j];
     577        if (upper[iColumn] - lower[iColumn] < 1.0e-8) {
     578          // fixed
     579          upperValue -= lower[iColumn] * value;
     580          lowerValue -= lower[iColumn] * value;
     581          continue;
     582        } else if (backward_[iColumn] < 0) {
     583          good = false;
     584          break;
     585        } else {
     586          iColumn = backward_[iColumn];
     587          numberTotal++;
     588        }
     589        if (fabs(value) != 1.0) {
     590          good = false;
     591        } else if (value > 0.0) {
     592          assert(numberP1 < numberIntegers_);
     593          whichP[numberP1++] = iColumn;
     594          ;
     595        } else {
     596          assert(numberM1 < numberIntegers_);
     597          whichM[numberM1++] = iColumn;
     598        }
     599      }
     600      int iUpper = static_cast< int >(floor(upperValue + 1.0e-5));
     601      int iLower = static_cast< int >(ceil(lowerValue - 1.0e-5));
     602      int state = 0;
     603      if (upperValue < 1.0e6) {
     604        if (iUpper == 1 - numberM1)
     605          state = 1;
     606        else if (iUpper == -numberM1)
     607          state = 2;
     608        else if (iUpper < -numberM1)
     609          state = 3;
     610        if (fabs(static_cast< double >(iUpper) - upperValue) > 1.0e-9)
     611          state = -1;
     612      }
     613      if (!state && lowerValue > -1.0e6) {
     614        if (-iLower == 1 - numberP1)
     615          state = -1;
     616        else if (-iLower == -numberP1)
     617          state = -2;
     618        else if (-iLower < -numberP1)
     619          state = -3;
     620        if (fabs(static_cast< double >(iLower) - lowerValue) > 1.0e-9)
     621          state = -1;
     622      }
     623      if (numberP1 + numberM1 < 2)
     624        state = -1;
     625      if (good && state > 0) {
     626        if (abs(state) == 3) {
     627          // infeasible
     628          printf("FFF Infeasible\n");
     629          ;
     630          //feasible=false;
     631          break;
     632        } else if (abs(state) == 2) {
     633          // we can fix all
     634          //numberFixed += numberP1+numberM1;
     635          printf("FFF can fix %d\n", numberP1 + numberM1);
     636        } else {
     637          for (j = 0; j < numberP1; j++) {
     638            int iColumn = whichP[j];
     639            if (iPass) {
     640              CliqueEntry temp;
     641              setOneFixesInCliqueEntry(temp, true);
     642              setSequenceInCliqueEntry(temp, iColumn);
     643              entry[numberEntries] = temp;
     644            }
     645            numberEntries++;
     646          }
     647          for (j = 0; j < numberM1; j++) {
     648            int iColumn = whichM[j];
     649            if (iPass) {
     650              CliqueEntry temp;
     651              setOneFixesInCliqueEntry(temp, false);
     652              setSequenceInCliqueEntry(temp, iColumn);
     653              entry[numberEntries] = temp;
     654            }
     655            numberEntries++;
     656          }
     657          if (iPass) {
     658            if (iLower != iUpper) {
     659              // slack
     660              cliqueType[numberCliques] = 'S';
     661            } else {
     662              cliqueType[numberCliques] = 'E';
     663            }
     664            cliqueStart[numberCliques + 1] = numberEntries;
     665          }
     666          numberCliques++;
     667        }
    658668      }
    659669    }
     
    661671    if (numberExtraCliques) {
    662672      CoinBigIndex numberExtraEntries = starts[numberExtraCliques];
    663       memcpy(entry+numberEntries,entries,numberExtraEntries*sizeof(CliqueEntry));
    664       for (int iClique=0;iClique<numberExtraCliques;iClique++) {
    665         cliqueType[numberCliques] = type[iClique];
    666         numberCliques++;
    667         cliqueStart[numberCliques]=starts[iClique]+numberEntries;
     673      memcpy(entry + numberEntries, entries, numberExtraEntries * sizeof(CliqueEntry));
     674      for (int iClique = 0; iClique < numberExtraCliques; iClique++) {
     675        cliqueType[numberCliques] = type[iClique];
     676        numberCliques++;
     677        cliqueStart[numberCliques] = starts[iClique] + numberEntries;
    668678      }
    669679      numberEntries += numberExtraEntries;
    670680    }
    671     numberMatrixCliques=numberCliques;
     681    numberMatrixCliques = numberCliques;
    672682    //int size = toZero_[numberIntegers_];
    673683    //char * used = new char [size];
    674684    //memset(used,0,size);
    675685    // find two cliques
    676     int nFix=0;
    677     for (int iColumn=0;iColumn<static_cast<int> (numberIntegers_);iColumn++) {
     686    int nFix = 0;
     687    for (int iColumn = 0; iColumn < static_cast< int >(numberIntegers_); iColumn++) {
    678688      int j;
    679       for ( j=toZero_[iColumn];j<toOne_[iColumn];j++) {
    680         int jColumn=sequenceInCliqueEntry(fixEntry_[j]);
    681         // just look at ones beore (this also skips non 0-1)
    682         if (jColumn<iColumn) {
    683           int k;
    684           for ( k=toZero_[jColumn];k<toOne_[jColumn];k++) {
    685             if (sequenceInCliqueEntry(fixEntry_[k])== (iColumn)) {
    686               if (oneFixesInCliqueEntry(fixEntry_[j])) {
    687                 if (oneFixesInCliqueEntry(fixEntry_[k])) {
    688                   if (printit&&!iPass)
    689                     printf("%d to zero implies %d to one and %d to zero implies %d to one\n",
    690                            iColumn,jColumn,jColumn,iColumn);
    691                   //0-0 illegal
    692                   if (iPass) {
    693                     CliqueEntry temp;
    694                     setOneFixesInCliqueEntry(temp,false);
    695                     setSequenceInCliqueEntry(temp,iColumn);
    696                     entry[numberEntries]=temp;
    697                   }
    698                   numberEntries++;
    699                   if (iPass) {
    700                     CliqueEntry temp;
    701                     setOneFixesInCliqueEntry(temp,false);
    702                     setSequenceInCliqueEntry(temp,jColumn);
    703                     entry[numberEntries]=temp;
    704                   }
    705                   numberEntries++;
    706                   if (iPass) {
    707                     // slack
    708                     cliqueType[numberCliques]='S';
    709                     cliqueStart[numberCliques+1]=numberEntries;
    710                   }
    711                   numberCliques++;
    712                 } else {
    713                   if (printit&&!iPass)
    714                     printf("%d to zero implies %d to one and %d to zero implies %d to zero\n",
    715                            iColumn,jColumn,jColumn,iColumn);
    716                   nFix++; // jColumn is 1
    717                 }
    718               } else {
    719                 if (oneFixesInCliqueEntry(fixEntry_[k])) {
    720                   if (printit&&!iPass)
    721                     printf("%d to zero implies %d to zero and %d to zero implies %d to one\n",
    722                            iColumn,jColumn,jColumn,iColumn);
    723                   nFix++; // iColumn is 1
    724                 } else {
    725                   if (printit&&!iPass)
    726                     printf("%d to zero implies %d to zero and %d to zero implies %d to zero\n",
    727                            iColumn,jColumn,jColumn,iColumn);
    728                   nFix++; // jColumn=iColumn
    729                 }
    730               }
    731             }
    732           }
    733           for ( k=toOne_[jColumn];k<toZero_[jColumn+1];k++) {
    734             if (sequenceInCliqueEntry(fixEntry_[k])== (iColumn)) {
    735               if (oneFixesInCliqueEntry(fixEntry_[j])) {
    736                 if (oneFixesInCliqueEntry(fixEntry_[k])) {
    737                   if (printit&&!iPass)
    738                     printf("%d to zero implies %d to one and %d to one implies %d to one\n",
    739                            iColumn,jColumn,jColumn,iColumn);
    740                   nFix++; //iColumn is 1
    741                 } else {
    742                   if (printit&&!iPass)
    743                     printf("%d to zero implies %d to one and %d to one implies %d to zero\n",
    744                            iColumn,jColumn,jColumn,iColumn);
    745                   nFix++; // iColumn+jcolumn=1
    746                 }
    747               } else {
    748                 if (oneFixesInCliqueEntry(fixEntry_[k])) {
    749                   if (printit&&!iPass)
    750                     printf("%d to zero implies %d to zero and %d to one implies %d to one\n",
    751                            iColumn,jColumn,jColumn,iColumn);
    752                   // 0-1 illegal
    753                   if (iPass) {
    754                     CliqueEntry temp;
    755                     setOneFixesInCliqueEntry(temp,false);
    756                     setSequenceInCliqueEntry(temp,iColumn);
    757                     entry[numberEntries]=temp;
    758                   }
    759                   numberEntries++;
    760                   if (iPass) {
    761                     CliqueEntry temp;
    762                     setOneFixesInCliqueEntry(temp,true);
    763                     setSequenceInCliqueEntry(temp,jColumn);
    764                     entry[numberEntries]=temp;
    765                   }
    766                   numberEntries++;
    767                   if (iPass) {
    768                     // slack
    769                     cliqueType[numberCliques]='S';
    770                     cliqueStart[numberCliques+1]=numberEntries;
    771                   }
    772                   numberCliques++;
    773                 } else {
    774                   if (printit&&!iPass)
    775                     printf("%d to zero implies %d to zero and %d to one implies %d to zero\n",
    776                            iColumn,jColumn,jColumn,iColumn);
    777                   nFix++; // jColumn is 0
    778                 }
    779               }
    780             }
    781           }
    782         }
    783       }
    784       for ( j=toOne_[iColumn];j<toZero_[iColumn+1];j++) {
    785         int jColumn=sequenceInCliqueEntry(fixEntry_[j]);
    786         if (jColumn<iColumn) {
    787           int k;
    788           for ( k=toZero_[jColumn];k<toOne_[jColumn];k++) {
    789             if (sequenceInCliqueEntry(fixEntry_[k])== (iColumn)) {
    790               if (oneFixesInCliqueEntry(fixEntry_[j])) {
    791                 if (oneFixesInCliqueEntry(fixEntry_[k])) {
    792                   if (printit&&!iPass)
    793                     printf("%d to one implies %d to one and %d to zero implies %d to one\n",
    794                            iColumn,jColumn,jColumn,iColumn);
    795                   nFix++; // jColumn is 1
    796                 } else {
    797                   if (printit&&!iPass)
    798                     printf("%d to one implies %d to one and %d to zero implies %d to zero\n",
    799                            iColumn,jColumn,jColumn,iColumn);
    800                   // 1-0 illegal
    801                   if (iPass) {
    802                     CliqueEntry temp;
    803                     setOneFixesInCliqueEntry(temp,true);
    804                     setSequenceInCliqueEntry(temp,iColumn);
    805                     entry[numberEntries]=temp;
    806                   }
    807                   numberEntries++;
    808                   if (iPass) {
    809                     CliqueEntry temp;
    810                     setOneFixesInCliqueEntry(temp,false);
    811                     setSequenceInCliqueEntry(temp,jColumn);
    812                     entry[numberEntries]=temp;
    813                   }
    814                   numberEntries++;
    815                   if (iPass) {
    816                     // slack
    817                     cliqueType[numberCliques]='S';
    818                     cliqueStart[numberCliques+1]=numberEntries;
    819                   }
    820                   numberCliques++;
    821                 }
    822               } else {
    823                 if (oneFixesInCliqueEntry(fixEntry_[k])) {
    824                   if (printit&&!iPass)
    825                     printf("%d to one implies %d to zero and %d to zero implies %d to one\n",
    826                            iColumn,jColumn,jColumn,iColumn);
    827                   nFix++; // iColumn+jColumn=1
    828                 } else {
    829                   if (printit&&!iPass)
    830                     printf("%d to one implies %d to zero and %d to zero implies %d to zero\n",
    831                            iColumn,jColumn,jColumn,iColumn);
    832                   nFix++; // iColumn is 0
    833                 }
    834               }
    835             }
    836           }
    837           for ( k=toOne_[jColumn];k<toZero_[jColumn+1];k++) {
    838             if (sequenceInCliqueEntry(fixEntry_[k])== (iColumn)) {
    839               if (oneFixesInCliqueEntry(fixEntry_[j])) {
    840                 if (oneFixesInCliqueEntry(fixEntry_[k])) {
    841                   if (printit&&!iPass)
    842                     printf("%d to one implies %d to one and %d to one implies %d to one\n",
    843                            iColumn,jColumn,jColumn,iColumn);
    844                   nFix++; // iColumn == jColumn
    845                 } else {
    846                   if (printit&&!iPass)
    847                     printf("%d to one implies %d to one and %d to one implies %d to zero\n",
    848                            iColumn,jColumn,jColumn,iColumn);
    849                   nFix++; // iColumn is 0
    850                 }
    851               } else {
    852                 if (oneFixesInCliqueEntry(fixEntry_[k])) {
    853                   if (printit&&!iPass)
    854                     printf("%d to one implies %d to zero and %d to one implies %d to one\n",
    855                            iColumn,jColumn,jColumn,iColumn);
    856                   nFix++; // jColumn is 0
    857                 } else {
    858                   if (printit&&!iPass)
    859                     printf("%d to one implies %d to zero and %d to one implies %d to zero\n",
    860                            iColumn,jColumn,jColumn,iColumn);
    861                   // 1-1 illegal
    862                   if (iPass) {
    863                     CliqueEntry temp;
    864                     setOneFixesInCliqueEntry(temp,true);
    865                     setSequenceInCliqueEntry(temp,iColumn);
    866                     entry[numberEntries]=temp;
    867                   }
    868                   numberEntries++;
    869                   if (iPass) {
    870                     CliqueEntry temp;
    871                     setOneFixesInCliqueEntry(temp,true);
    872                     setSequenceInCliqueEntry(temp,jColumn);
    873                     entry[numberEntries]=temp;
    874                   }
    875                   numberEntries++;
    876                   if (iPass) {
    877                     // slack
    878                     cliqueType[numberCliques]='S';
    879                     cliqueStart[numberCliques+1]=numberEntries;
    880                   }
    881                   numberCliques++;
    882                 }
    883               }
    884             }
    885           }
    886         }
     689      for (j = toZero_[iColumn]; j < toOne_[iColumn]; j++) {
     690        int jColumn = sequenceInCliqueEntry(fixEntry_[j]);
     691        // just look at ones beore (this also skips non 0-1)
     692        if (jColumn < iColumn) {
     693          int k;
     694          for (k = toZero_[jColumn]; k < toOne_[jColumn]; k++) {
     695            if (sequenceInCliqueEntry(fixEntry_[k]) == (iColumn)) {
     696              if (oneFixesInCliqueEntry(fixEntry_[j])) {
     697                if (oneFixesInCliqueEntry(fixEntry_[k])) {
     698                  if (printit && !iPass)
     699                    printf("%d to zero implies %d to one and %d to zero implies %d to one\n",
     700                      iColumn, jColumn, jColumn, iColumn);
     701                  //0-0 illegal
     702                  if (iPass) {
     703                    CliqueEntry temp;
     704                    setOneFixesInCliqueEntry(temp, false);
     705                    setSequenceInCliqueEntry(temp, iColumn);
     706                    entry[numberEntries] = temp;
     707                  }
     708                  numberEntries++;
     709                  if (iPass) {
     710                    CliqueEntry temp;
     711                    setOneFixesInCliqueEntry(temp, false);
     712                    setSequenceInCliqueEntry(temp, jColumn);
     713                    entry[numberEntries] = temp;
     714                  }
     715                  numberEntries++;
     716                  if (iPass) {
     717                    // slack
     718                    cliqueType[numberCliques] = 'S';
     719                    cliqueStart[numberCliques + 1] = numberEntries;
     720                  }
     721                  numberCliques++;
     722                } else {
     723                  if (printit && !iPass)
     724                    printf("%d to zero implies %d to one and %d to zero implies %d to zero\n",
     725                      iColumn, jColumn, jColumn, iColumn);
     726                  nFix++; // jColumn is 1
     727                }
     728              } else {
     729                if (oneFixesInCliqueEntry(fixEntry_[k])) {
     730                  if (printit && !iPass)
     731                    printf("%d to zero implies %d to zero and %d to zero implies %d to one\n",
     732                      iColumn, jColumn, jColumn, iColumn);
     733                  nFix++; // iColumn is 1
     734                } else {
     735                  if (printit && !iPass)
     736                    printf("%d to zero implies %d to zero and %d to zero implies %d to zero\n",
     737                      iColumn, jColumn, jColumn, iColumn);
     738                  nFix++; // jColumn=iColumn
     739                }
     740              }
     741            }
     742          }
     743          for (k = toOne_[jColumn]; k < toZero_[jColumn + 1]; k++) {
     744            if (sequenceInCliqueEntry(fixEntry_[k]) == (iColumn)) {
     745              if (oneFixesInCliqueEntry(fixEntry_[j])) {
     746                if (oneFixesInCliqueEntry(fixEntry_[k])) {
     747                  if (printit && !iPass)
     748                    printf("%d to zero implies %d to one and %d to one implies %d to one\n",
     749                      iColumn, jColumn, jColumn, iColumn);
     750                  nFix++; //iColumn is 1
     751                } else {
     752                  if (printit && !iPass)
     753                    printf("%d to zero implies %d to one and %d to one implies %d to zero\n",
     754                      iColumn, jColumn, jColumn, iColumn);
     755                  nFix++; // iColumn+jcolumn=1
     756                }
     757              } else {
     758                if (oneFixesInCliqueEntry(fixEntry_[k])) {
     759                  if (printit && !iPass)
     760                    printf("%d to zero implies %d to zero and %d to one implies %d to one\n",
     761                      iColumn, jColumn, jColumn, iColumn);
     762                  // 0-1 illegal
     763                  if (iPass) {
     764                    CliqueEntry temp;
     765                    setOneFixesInCliqueEntry(temp, false);
     766                    setSequenceInCliqueEntry(temp, iColumn);
     767                    entry[numberEntries] = temp;
     768                  }
     769                  numberEntries++;
     770                  if (iPass) {
     771                    CliqueEntry temp;
     772                    setOneFixesInCliqueEntry(temp, true);
     773                    setSequenceInCliqueEntry(temp, jColumn);
     774                    entry[numberEntries] = temp;
     775                  }
     776                  numberEntries++;
     777                  if (iPass) {
     778                    // slack
     779                    cliqueType[numberCliques] = 'S';
     780                    cliqueStart[numberCliques + 1] = numberEntries;
     781                  }
     782                  numberCliques++;
     783                } else {
     784                  if (printit && !iPass)
     785                    printf("%d to zero implies %d to zero and %d to one implies %d to zero\n",
     786                      iColumn, jColumn, jColumn, iColumn);
     787                  nFix++; // jColumn is 0
     788                }
     789              }
     790            }
     791          }
     792        }
     793      }
     794      for (j = toOne_[iColumn]; j < toZero_[iColumn + 1]; j++) {
     795        int jColumn = sequenceInCliqueEntry(fixEntry_[j]);
     796        if (jColumn < iColumn) {
     797          int k;
     798          for (k = toZero_[jColumn]; k < toOne_[jColumn]; k++) {
     799            if (sequenceInCliqueEntry(fixEntry_[k]) == (iColumn)) {
     800              if (oneFixesInCliqueEntry(fixEntry_[j])) {
     801                if (oneFixesInCliqueEntry(fixEntry_[k])) {
     802                  if (printit && !iPass)
     803                    printf("%d to one implies %d to one and %d to zero implies %d to one\n",
     804                      iColumn, jColumn, jColumn, iColumn);
     805                  nFix++; // jColumn is 1
     806                } else {
     807                  if (printit && !iPass)
     808                    printf("%d to one implies %d to one and %d to zero implies %d to zero\n",
     809                      iColumn, jColumn, jColumn, iColumn);
     810                  // 1-0 illegal
     811                  if (iPass) {
     812                    CliqueEntry temp;
     813                    setOneFixesInCliqueEntry(temp, true);
     814                    setSequenceInCliqueEntry(temp, iColumn);
     815                    entry[numberEntries] = temp;
     816                  }
     817                  numberEntries++;
     818                  if (iPass) {
     819                    CliqueEntry temp;
     820                    setOneFixesInCliqueEntry(temp, false);
     821                    setSequenceInCliqueEntry(temp, jColumn);
     822                    entry[numberEntries] = temp;
     823                  }
     824                  numberEntries++;
     825                  if (iPass) {
     826                    // slack
     827                    cliqueType[numberCliques] = 'S';
     828                    cliqueStart[numberCliques + 1] = numberEntries;
     829                  }
     830                  numberCliques++;
     831                }
     832              } else {
     833                if (oneFixesInCliqueEntry(fixEntry_[k])) {
     834                  if (printit && !iPass)
     835                    printf("%d to one implies %d to zero and %d to zero implies %d to one\n",
     836                      iColumn, jColumn, jColumn, iColumn);
     837                  nFix++; // iColumn+jColumn=1
     838                } else {
     839                  if (printit && !iPass)
     840                    printf("%d to one implies %d to zero and %d to zero implies %d to zero\n",
     841                      iColumn, jColumn, jColumn, iColumn);
     842                  nFix++; // iColumn is 0
     843                }
     844              }
     845            }
     846          }
     847          for (k = toOne_[jColumn]; k < toZero_[jColumn + 1]; k++) {
     848            if (sequenceInCliqueEntry(fixEntry_[k]) == (iColumn)) {
     849              if (oneFixesInCliqueEntry(fixEntry_[j])) {
     850                if (oneFixesInCliqueEntry(fixEntry_[k])) {
     851                  if (printit && !iPass)
     852                    printf("%d to one implies %d to one and %d to one implies %d to one\n",
     853                      iColumn, jColumn, jColumn, iColumn);
     854                  nFix++; // iColumn == jColumn
     855                } else {
     856                  if (printit && !iPass)
     857                    printf("%d to one implies %d to one and %d to one implies %d to zero\n",
     858                      iColumn, jColumn, jColumn, iColumn);
     859                  nFix++; // iColumn is 0
     860                }
     861              } else {
     862                if (oneFixesInCliqueEntry(fixEntry_[k])) {
     863                  if (printit && !iPass)
     864                    printf("%d to one implies %d to zero and %d to one implies %d to one\n",
     865                      iColumn, jColumn, jColumn, iColumn);
     866                  nFix++; // jColumn is 0
     867                } else {
     868                  if (printit && !iPass)
     869                    printf("%d to one implies %d to zero and %d to one implies %d to zero\n",
     870                      iColumn, jColumn, jColumn, iColumn);
     871                  // 1-1 illegal
     872                  if (iPass) {
     873                    CliqueEntry temp;
     874                    setOneFixesInCliqueEntry(temp, true);
     875                    setSequenceInCliqueEntry(temp, iColumn);
     876                    entry[numberEntries] = temp;
     877                  }
     878                  numberEntries++;
     879                  if (iPass) {
     880                    CliqueEntry temp;
     881                    setOneFixesInCliqueEntry(temp, true);
     882                    setSequenceInCliqueEntry(temp, jColumn);
     883                    entry[numberEntries] = temp;
     884                  }
     885                  numberEntries++;
     886                  if (iPass) {
     887                    // slack
     888                    cliqueType[numberCliques] = 'S';
     889                    cliqueStart[numberCliques + 1] = numberEntries;
     890                  }
     891                  numberCliques++;
     892                }
     893              }
     894            }
     895          }
     896        }
    887897      }
    888898    }
    889899    if (!iPass)
    890900      printf("%d cliques and %d fixed (%d already from matrix))\n",
    891              numberCliques-numberMatrixCliques,nFix,numberMatrixCliques);
     901        numberCliques - numberMatrixCliques, nFix, numberMatrixCliques);
    892902  }
    893903  int iClique;
    894904  outDupsEtc(numberIntegers_, numberCliques, numberMatrixCliques,
    895              cliqueStart, cliqueType, entry, -1, printit ? 2 : 1);
    896   printf("%d matrix cliques and %d found by probing\n",numberMatrixCliques,numberCliques-numberMatrixCliques);
    897   int * zeroStart = new int [numberIntegers_+1];
    898   int * oneStart = new int [numberIntegers_];
    899   int * zeroCount = new int [numberIntegers_];
    900   int * oneCount = new int [numberIntegers_];
    901   char * mark = new char [numberIntegers_];
    902   memset(mark,0,numberIntegers_);
    903   int nStrengthen=-1;
    904   int iPass=0;
    905   while (nStrengthen&&iPass<20) {
     905    cliqueStart, cliqueType, entry, -1, printit ? 2 : 1);
     906  printf("%d matrix cliques and %d found by probing\n", numberMatrixCliques, numberCliques - numberMatrixCliques);
     907  int *zeroStart = new int[numberIntegers_ + 1];
     908  int *oneStart = new int[numberIntegers_];
     909  int *zeroCount = new int[numberIntegers_];
     910  int *oneCount = new int[numberIntegers_];
     911  char *mark = new char[numberIntegers_];
     912  memset(mark, 0, numberIntegers_);
     913  int nStrengthen = -1;
     914  int iPass = 0;
     915  while (nStrengthen && iPass < 20) {
    906916    iPass++;
    907917    int numberLastTime = numberCliques;
    908     int * count = new int [numberCliques];
    909     int i,iColumn;
    910     for (i=0;i<numberCliques;i++) {
    911       count[i]=0;
    912     }
    913     int * whichCount = new int [numberCliques];
    914     CoinZeroN(zeroCount,numberIntegers_);
    915     CoinZeroN(oneCount,numberIntegers_);
    916     for (iClique=0;iClique<numberCliques;iClique++) {
    917       for (CoinBigIndex j=cliqueStart[iClique];j<cliqueStart[iClique+1];j++) {
    918         int iColumn = static_cast<int> (sequenceInCliqueEntry(entry[j]));
    919         if (oneFixesInCliqueEntry(entry[j])) {
    920           oneCount[iColumn]++;
    921         } else {
    922           zeroCount[iColumn]++;
    923         }
     918    int *count = new int[numberCliques];
     919    int i, iColumn;
     920    for (i = 0; i < numberCliques; i++) {
     921      count[i] = 0;
     922    }
     923    int *whichCount = new int[numberCliques];
     924    CoinZeroN(zeroCount, numberIntegers_);
     925    CoinZeroN(oneCount, numberIntegers_);
     926    for (iClique = 0; iClique < numberCliques; iClique++) {
     927      for (CoinBigIndex j = cliqueStart[iClique]; j < cliqueStart[iClique + 1]; j++) {
     928        int iColumn = static_cast< int >(sequenceInCliqueEntry(entry[j]));
     929        if (oneFixesInCliqueEntry(entry[j])) {
     930          oneCount[iColumn]++;
     931        } else {
     932          zeroCount[iColumn]++;
     933        }
    924934      }
    925935    }
    926936    int j;
    927     zeroStart[0]=0;
    928     cliqueStart[0]=0;
    929     for (j=0;j<numberIntegers_;j++) {
     937    zeroStart[0] = 0;
     938    cliqueStart[0] = 0;
     939    for (j = 0; j < numberIntegers_; j++) {
    930940      int n;
    931       n=zeroCount[j];
    932       zeroCount[j]=0;
    933       oneStart[j] = zeroStart[j]+n;
    934       n=oneCount[j];
    935       oneCount[j]=0;
    936       zeroStart[j+1] = oneStart[j]+n;
    937     }
    938     for (iClique=0;iClique<numberCliques;iClique++) {
    939       for (CoinBigIndex j=cliqueStart[iClique];j<cliqueStart[iClique+1];j++) {
    940         int iColumn = static_cast<int> (sequenceInCliqueEntry(entry[j]));
    941         if (oneFixesInCliqueEntry(entry[j])) {
    942           int k=oneCount[iColumn];
    943           oneCount[iColumn]++;
    944           int put = oneStart[iColumn]+k;
    945           whichClique[put]=iClique;
    946         } else {
    947           int k=zeroCount[iColumn];
    948           zeroCount[iColumn]++;
    949           int put = zeroStart[iColumn]+k;
    950           whichClique[put]=iClique;
    951         }
    952       }
    953     }
    954     nStrengthen=0;
    955     CoinBigIndex numberEntries=cliqueStart[numberCliques];
    956     CoinBigIndex maximumEntries=numberEntries;
    957     int maximumCliques=numberCliques;
    958     for (iColumn=0;iColumn<numberIntegers_;iColumn++) {
     941      n = zeroCount[j];
     942      zeroCount[j] = 0;
     943      oneStart[j] = zeroStart[j] + n;
     944      n = oneCount[j];
     945      oneCount[j] = 0;
     946      zeroStart[j + 1] = oneStart[j] + n;
     947    }
     948    for (iClique = 0; iClique < numberCliques; iClique++) {
     949      for (CoinBigIndex j = cliqueStart[iClique]; j < cliqueStart[iClique + 1]; j++) {
     950        int iColumn = static_cast< int >(sequenceInCliqueEntry(entry[j]));
     951        if (oneFixesInCliqueEntry(entry[j])) {
     952          int k = oneCount[iColumn];
     953          oneCount[iColumn]++;
     954          int put = oneStart[iColumn] + k;
     955          whichClique[put] = iClique;
     956        } else {
     957          int k = zeroCount[iColumn];
     958          zeroCount[iColumn]++;
     959          int put = zeroStart[iColumn] + k;
     960          whichClique[put] = iClique;
     961        }
     962      }
     963    }
     964    nStrengthen = 0;
     965    CoinBigIndex numberEntries = cliqueStart[numberCliques];
     966    CoinBigIndex maximumEntries = numberEntries;
     967    int maximumCliques = numberCliques;
     968    for (iColumn = 0; iColumn < numberIntegers_; iColumn++) {
    959969      int i;
    960970      int n;
    961       int nCount=0;
    962       n=0;
    963       for (i=zeroStart[iColumn];i<oneStart[iColumn];i++) {
    964         int jClique = whichClique[i];
    965         //if (jClique<numberMatrixCliques)
    966         //continue;
    967         CoinBigIndex j = cliqueStart[jClique];
    968         //assert (cliqueStart[jClique+1]==j+2);
    969         for (;j<cliqueStart[jClique+1];j++) {
    970           CliqueEntry eJ = entry[j];
    971           int jColumn = sequenceInCliqueEntry(eJ);
    972           if (jColumn>iColumn&&!mark[jColumn]) {
    973             mark[jColumn]=1;
    974             whichP[n++]=jColumn;
    975             assert (n<numberIntegers_);
    976             if (oneFixesInCliqueEntry(eJ)) {
    977               for (int k=oneStart[jColumn];k<zeroStart[jColumn+1];k++) {
    978                 int jClique = whichClique[k];
    979                 if (!count[jClique])
    980                   whichCount[nCount++]=jClique;
    981                 count[jClique]++;
    982               }
    983             } else {
    984               for (int k=zeroStart[jColumn];k<oneStart[jColumn];k++) {
    985                 int jClique = whichClique[k];
    986                 if (!count[jClique])
    987                   whichCount[nCount++]=jClique;
    988                 count[jClique]++;
    989               }
    990             }
    991           }
    992         }
    993       }
    994       std::sort(whichP,whichP+n);
    995       for (i=0;i<nCount;i++) {
    996         int jClique = whichCount[i];
    997         int jCount = count[jClique];
    998         count[jClique]=0;
    999         if (jCount==cliqueStart[jClique+1]-cliqueStart[jClique]) {
    1000           printf("Zero can extend %d [ ",jClique);
    1001           for (CoinBigIndex i=cliqueStart[jClique];i<cliqueStart[jClique+1];i++)
    1002             printf("%d(%d) ",sequenceInCliqueEntry(entry[i]),oneFixesInCliqueEntry(entry[i]));
    1003           printf("] by %d(0)\n",iColumn);
    1004           nStrengthen++;
    1005           if (numberEntries+jCount+1>maximumEntries) {
    1006             maximumEntries = CoinMax(numberEntries+jCount+1,(maximumEntries*12)/10+100);
    1007             CliqueEntry * temp = new CliqueEntry [maximumEntries];
    1008             memcpy(temp,entry,numberEntries*sizeof(CliqueEntry));
    1009             delete [] entry;
    1010             entry=temp;
    1011             int * tempI = new int [maximumEntries];
    1012             memcpy(tempI,whichClique,numberEntries*sizeof(int));
    1013             delete [] whichClique;
    1014             whichClique=tempI;
    1015           }
    1016           if (numberCliques==maximumCliques) {
    1017             maximumCliques = (maximumCliques*12)/10+100;
    1018             CoinBigIndex * temp = new CoinBigIndex [maximumCliques+1];
    1019             memcpy(temp,cliqueStart,(numberCliques+1)*sizeof(CoinBigIndex));
    1020             delete [] cliqueStart;
    1021             cliqueStart=temp;
    1022             char * tempT = new char [maximumCliques];
    1023             memcpy(tempT,cliqueType,numberCliques);
    1024             delete [] cliqueType;
    1025             cliqueType=tempT;
    1026           }
    1027           CliqueEntry eI;
    1028           eI.fixes=0;
    1029           setSequenceInCliqueEntry(eI,iColumn);
    1030           setOneFixesInCliqueEntry(eI,false);
    1031           entry[numberEntries++]=eI;
    1032           whichM[0]=iColumn;
    1033           int n=1;
    1034           for (CoinBigIndex i=cliqueStart[jClique];i<cliqueStart[jClique+1];i++) {
    1035             entry[numberEntries++]=entry[i];
    1036             whichM[n++]=sequenceInCliqueEntry(entry[i]);
    1037           }
    1038           CoinSort_2(whichM,whichM+n,(reinterpret_cast<int *>(entry))+numberEntries-n);
    1039           cliqueType[numberCliques]='S';
    1040           numberCliques++;
    1041           cliqueStart[numberCliques]=numberEntries;
    1042         }
    1043       }
    1044       for (i=0;i<n;i++)
    1045         mark[whichP[i]]=0;
    1046       nCount=0;
    1047       n=0;
    1048       for (i=oneStart[iColumn];i<zeroStart[iColumn+1];i++) {
    1049         int jClique = whichClique[i];
    1050         //if (jClique<numberMatrixCliques)
    1051         //continue;
    1052         CoinBigIndex j = cliqueStart[jClique];
    1053         //assert (cliqueStart[jClique+1]==j+2);
    1054         for (;j<cliqueStart[jClique+1];j++) {
    1055           CliqueEntry eJ = entry[j];
    1056           int jColumn = sequenceInCliqueEntry(eJ);
    1057           if (jColumn>iColumn&&!mark[jColumn]) {
    1058             mark[jColumn]=1;
    1059             whichP[n++]=jColumn;
    1060             assert (n<numberIntegers_);
    1061             if (oneFixesInCliqueEntry(eJ)) {
    1062               for (int k=oneStart[jColumn];k<zeroStart[jColumn+1];k++) {
    1063                 int jClique = whichClique[k];
    1064                 if (!count[jClique])
    1065                   whichCount[nCount++]=jClique;
    1066                 count[jClique]++;
    1067               }
    1068             } else {
    1069               for (int k=zeroStart[jColumn];k<oneStart[jColumn];k++) {
    1070                 int jClique = whichClique[k];
    1071                 if (!count[jClique])
    1072                   whichCount[nCount++]=jClique;
    1073                 count[jClique]++;
    1074               }
    1075             }
    1076           }
    1077         }
    1078       }
    1079       std::sort(whichP,whichP+n);
    1080       for (i=0;i<nCount;i++) {
    1081         int jClique = whichCount[i];
    1082         int jCount = count[jClique];
    1083         count[jClique]=0;
    1084         if (jCount==cliqueStart[jClique+1]-cliqueStart[jClique]) {
     971      int nCount = 0;
     972      n = 0;
     973      for (i = zeroStart[iColumn]; i < oneStart[iColumn]; i++) {
     974        int jClique = whichClique[i];
     975        //if (jClique<numberMatrixCliques)
     976        //continue;
     977        CoinBigIndex j = cliqueStart[jClique];
     978        //assert (cliqueStart[jClique+1]==j+2);
     979        for (; j < cliqueStart[jClique + 1]; j++) {
     980          CliqueEntry eJ = entry[j];
     981          int jColumn = sequenceInCliqueEntry(eJ);
     982          if (jColumn > iColumn && !mark[jColumn]) {
     983            mark[jColumn] = 1;
     984            whichP[n++] = jColumn;
     985            assert(n < numberIntegers_);
     986            if (oneFixesInCliqueEntry(eJ)) {
     987              for (int k = oneStart[jColumn]; k < zeroStart[jColumn + 1]; k++) {
     988                int jClique = whichClique[k];
     989                if (!count[jClique])
     990                  whichCount[nCount++] = jClique;
     991                count[jClique]++;
     992              }
     993            } else {
     994              for (int k = zeroStart[jColumn]; k < oneStart[jColumn]; k++) {
     995                int jClique = whichClique[k];
     996                if (!count[jClique])
     997                  whichCount[nCount++] = jClique;
     998                count[jClique]++;
     999              }
     1000            }
     1001          }
     1002        }
     1003      }
     1004      std::sort(whichP, whichP + n);
     1005      for (i = 0; i < nCount; i++) {
     1006        int jClique = whichCount[i];
     1007        int jCount = count[jClique];
     1008        count[jClique] = 0;
     1009        if (jCount == cliqueStart[jClique + 1] - cliqueStart[jClique]) {
     1010          printf("Zero can extend %d [ ", jClique);
     1011          for (CoinBigIndex i = cliqueStart[jClique]; i < cliqueStart[jClique + 1]; i++)
     1012            printf("%d(%d) ", sequenceInCliqueEntry(entry[i]), oneFixesInCliqueEntry(entry[i]));
     1013          printf("] by %d(0)\n", iColumn);
     1014          nStrengthen++;
     1015          if (numberEntries + jCount + 1 > maximumEntries) {
     1016            maximumEntries = CoinMax(numberEntries + jCount + 1, (maximumEntries * 12) / 10 + 100);
     1017            CliqueEntry *temp = new CliqueEntry[maximumEntries];
     1018            memcpy(temp, entry, numberEntries * sizeof(CliqueEntry));
     1019            delete[] entry;
     1020            entry = temp;
     1021            int *tempI = new int[maximumEntries];
     1022            memcpy(tempI, whichClique, numberEntries * sizeof(int));
     1023            delete[] whichClique;
     1024            whichClique = tempI;
     1025          }
     1026          if (numberCliques == maximumCliques) {
     1027            maximumCliques = (maximumCliques * 12) / 10 + 100;
     1028            CoinBigIndex *temp = new CoinBigIndex[maximumCliques + 1];
     1029            memcpy(temp, cliqueStart, (numberCliques + 1) * sizeof(CoinBigIndex));
     1030            delete[] cliqueStart;
     1031            cliqueStart = temp;
     1032            char *tempT = new char[maximumCliques];
     1033            memcpy(tempT, cliqueType, numberCliques);
     1034            delete[] cliqueType;
     1035            cliqueType = tempT;
     1036          }
     1037          CliqueEntry eI;
     1038          eI.fixes = 0;
     1039          setSequenceInCliqueEntry(eI, iColumn);
     1040          setOneFixesInCliqueEntry(eI, false);
     1041          entry[numberEntries++] = eI;
     1042          whichM[0] = iColumn;
     1043          int n = 1;
     1044          for (CoinBigIndex i = cliqueStart[jClique]; i < cliqueStart[jClique + 1]; i++) {
     1045            entry[numberEntries++] = entry[i];
     1046            whichM[n++] = sequenceInCliqueEntry(entry[i]);
     1047          }
     1048          CoinSort_2(whichM, whichM + n, (reinterpret_cast< int * >(entry)) + numberEntries - n);
     1049          cliqueType[numberCliques] = 'S';
     1050          numberCliques++;
     1051          cliqueStart[numberCliques] = numberEntries;
     1052        }
     1053      }
     1054      for (i = 0; i < n; i++)
     1055        mark[whichP[i]] = 0;
     1056      nCount = 0;
     1057      n = 0;
     1058      for (i = oneStart[iColumn]; i < zeroStart[iColumn + 1]; i++) {
     1059        int jClique = whichClique[i];
     1060        //if (jClique<numberMatrixCliques)
     1061        //continue;
     1062        CoinBigIndex j = cliqueStart[jClique];
     1063        //assert (cliqueStart[jClique+1]==j+2);
     1064        for (; j < cliqueStart[jClique + 1]; j++) {
     1065          CliqueEntry eJ = entry[j];
     1066          int jColumn = sequenceInCliqueEntry(eJ);
     1067          if (jColumn > iColumn && !mark[jColumn]) {
     1068            mark[jColumn] = 1;
     1069            whichP[n++] = jColumn;
     1070            assert(n < numberIntegers_);
     1071            if (oneFixesInCliqueEntry(eJ)) {
     1072              for (int k = oneStart[jColumn]; k < zeroStart[jColumn + 1]; k++) {
     1073                int jClique = whichClique[k];
     1074                if (!count[jClique])
     1075                  whichCount[nCount++] = jClique;
     1076                count[jClique]++;
     1077              }
     1078            } else {
     1079              for (int k = zeroStart[jColumn]; k < oneStart[jColumn]; k++) {
     1080                int jClique = whichClique[k];
     1081                if (!count[jClique])
     1082                  whichCount[nCount++] = jClique;
     1083                count[jClique]++;
     1084              }
     1085            }
     1086          }
     1087        }
     1088      }
     1089      std::sort(whichP, whichP + n);
     1090      for (i = 0; i < nCount; i++) {
     1091        int jClique = whichCount[i];
     1092        int jCount = count[jClique];
     1093        count[jClique] = 0;
     1094        if (jCount == cliqueStart[jClique + 1] - cliqueStart[jClique]) {
    10851095#if 1
    1086                 if (printit) {
    1087             printf("One can extend %d [ ",jClique);
    1088             for (CoinBigIndex i=cliqueStart[jClique];i<cliqueStart[jClique+1];i++)
    1089               printf("%d(%d) ",sequenceInCliqueEntry(entry[i]),oneFixesInCliqueEntry(entry[i]));
    1090             printf("] by %d(1)\n",iColumn);
    1091           }
     1096          if (printit) {
     1097            printf("One can extend %d [ ", jClique);
     1098            for (CoinBigIndex i = cliqueStart[jClique]; i < cliqueStart[jClique + 1]; i++)
     1099              printf("%d(%d) ", sequenceInCliqueEntry(entry[i]), oneFixesInCliqueEntry(entry[i]));
     1100            printf("] by %d(1)\n", iColumn);
     1101          }
    10921102#endif
    1093           nStrengthen++;
    1094           if (numberEntries+jCount+1>maximumEntries) {
    1095             maximumEntries = CoinMax(numberEntries+jCount+1,(maximumEntries*12)/10+100);
    1096             CliqueEntry * temp = new CliqueEntry [maximumEntries];
    1097             memcpy(temp,entry,numberEntries*sizeof(CliqueEntry));
    1098             delete [] entry;
    1099             entry=temp;
    1100             int * tempI = new int [maximumEntries];
    1101             memcpy(tempI,whichClique,numberEntries*sizeof(int));
    1102             delete [] whichClique;
    1103             whichClique=tempI;
    1104           }
    1105           if (numberCliques==maximumCliques) {
    1106             maximumCliques = (maximumCliques*12)/10+100;
    1107             CoinBigIndex * temp = new CoinBigIndex [maximumCliques+1];
    1108             memcpy(temp,cliqueStart,(numberCliques+1)*sizeof(CoinBigIndex));
    1109             delete [] cliqueStart;
    1110             cliqueStart=temp;
    1111             char * tempT = new char [maximumCliques];
    1112             memcpy(tempT,cliqueType,numberCliques);
    1113             delete [] cliqueType;
    1114             cliqueType=tempT;
    1115           }
    1116           CliqueEntry eI;
    1117           eI.fixes=0;
    1118           setSequenceInCliqueEntry(eI,iColumn);
    1119           setOneFixesInCliqueEntry(eI,true);
    1120           entry[numberEntries++]=eI;
    1121           whichM[0]=iColumn;
    1122           int n=1;
    1123           for (CoinBigIndex i=cliqueStart[jClique];i<cliqueStart[jClique+1];i++) {
    1124             entry[numberEntries++]=entry[i];
    1125             whichM[n++]=sequenceInCliqueEntry(entry[i]);
    1126           }
    1127           CoinSort_2(whichM,whichM+n,(reinterpret_cast<int *>(entry))+numberEntries-n);
    1128           cliqueType[numberCliques]='S';
    1129           numberCliques++;
    1130           cliqueStart[numberCliques]=numberEntries;
    1131         }
    1132       }
    1133       for (i=0;i<n;i++)
    1134         mark[whichP[i]]=0;
     1103          nStrengthen++;
     1104          if (numberEntries + jCount + 1 > maximumEntries) {
     1105            maximumEntries = CoinMax(numberEntries + jCount + 1, (maximumEntries * 12) / 10 + 100);
     1106            CliqueEntry *temp = new CliqueEntry[maximumEntries];
     1107            memcpy(temp, entry, numberEntries * sizeof(CliqueEntry));
     1108            delete[] entry;
     1109            entry = temp;
     1110            int *tempI = new int[maximumEntries];
     1111            memcpy(tempI, whichClique, numberEntries * sizeof(int));
     1112            delete[] whichClique;
     1113            whichClique = tempI;
     1114          }
     1115          if (numberCliques == maximumCliques) {
     1116            maximumCliques = (maximumCliques * 12) / 10 + 100;
     1117            CoinBigIndex *temp = new CoinBigIndex[maximumCliques + 1];
     1118            memcpy(temp, cliqueStart, (numberCliques + 1) * sizeof(CoinBigIndex));
     1119            delete[] cliqueStart;
     1120            cliqueStart = temp;
     1121            char *tempT = new char[maximumCliques];
     1122            memcpy(tempT, cliqueType, numberCliques);
     1123            delete[] cliqueType;
     1124            cliqueType = tempT;
     1125          }
     1126          CliqueEntry eI;
     1127          eI.fixes = 0;
     1128          setSequenceInCliqueEntry(eI, iColumn);
     1129          setOneFixesInCliqueEntry(eI, true);
     1130          entry[numberEntries++] = eI;
     1131          whichM[0] = iColumn;
     1132          int n = 1;
     1133          for (CoinBigIndex i = cliqueStart[jClique]; i < cliqueStart[jClique + 1]; i++) {
     1134            entry[numberEntries++] = entry[i];
     1135            whichM[n++] = sequenceInCliqueEntry(entry[i]);
     1136          }
     1137          CoinSort_2(whichM, whichM + n, (reinterpret_cast< int * >(entry)) + numberEntries - n);
     1138          cliqueType[numberCliques] = 'S';
     1139          numberCliques++;
     1140          cliqueStart[numberCliques] = numberEntries;
     1141        }
     1142      }
     1143      for (i = 0; i < n; i++)
     1144        mark[whichP[i]] = 0;
    11351145    }
    11361146    if (nStrengthen) {
    11371147      int numberDeleted = outDupsEtc(numberIntegers_, numberCliques, numberMatrixCliques,
    1138                  cliqueStart, cliqueType, entry, numberLastTime,printit ? 2 : 1);
    1139       if (numberDeleted<0||(iPass>1&&numberCliques-numberDeleted>5000))
    1140         nStrengthen=0;
    1141     }
    1142     delete [] count;
    1143     delete [] whichCount;
     1148        cliqueStart, cliqueType, entry, numberLastTime, printit ? 2 : 1);
     1149      if (numberDeleted < 0 || (iPass > 1 && numberCliques - numberDeleted > 5000))
     1150        nStrengthen = 0;
     1151    }
     1152    delete[] count;
     1153    delete[] whichCount;
    11441154  }
    11451155#if 0
     
    11661176  }
    11671177#endif
    1168   OsiSolverInterface * newSolver=NULL;
    1169   if (numberCliques>numberMatrixCliques||alwaysDo) {
     1178  OsiSolverInterface *newSolver = NULL;
     1179  if (numberCliques > numberMatrixCliques || alwaysDo) {
    11701180    newSolver = si.clone();
    11711181    // Delete all rows
    1172     CoinBigIndex * start = new CoinBigIndex [ CoinMax(numberRows,numberCliques+1)];
     1182    CoinBigIndex *start = new CoinBigIndex[CoinMax(numberRows, numberCliques + 1)];
    11731183    int i;
    1174     int * start2 = reinterpret_cast<int *>(start);
    1175     for (i=0;i<numberRows;i++)
    1176       start2[i]=i;
    1177     newSolver->deleteRows(numberRows,start2);
    1178     start[0]=0;
     1184    int *start2 = reinterpret_cast< int * >(start);
     1185    for (i = 0; i < numberRows; i++)
     1186      start2[i] = i;
     1187    newSolver->deleteRows(numberRows, start2);
     1188    start[0] = 0;
    11791189    CoinBigIndex numberElements = cliqueStart[numberCliques];
    1180     int * column = new int [numberElements];
    1181     double * element = new double [numberElements];
    1182     double * lower = new double [numberCliques];
    1183     double * upper = new double [numberCliques];
    1184     numberElements=0;
    1185     for (iClique=0;iClique<numberCliques;iClique++) {
    1186       double rhs=1.0;
    1187       for (CoinBigIndex i=cliqueStart[iClique];i<cliqueStart[iClique+1];i++) {
    1188         CliqueEntry eI=entry[i];
    1189         int iColumn = integerVariable_[sequenceInCliqueEntry(eI)];
    1190         column[numberElements]=iColumn;
    1191         if (oneFixesInCliqueEntry(eI)) {
    1192           element[numberElements++]=1.0;
    1193         } else {
    1194           element[numberElements++]=-1.0;
    1195           rhs -= 1.0;
    1196         }
    1197       }
    1198       start[iClique+1]=numberElements;
    1199       assert (cliqueType[iClique]=='S'||
    1200               cliqueType[iClique]=='E');
    1201       if (cliqueType[iClique]=='S')
    1202         lower[iClique]=-COIN_DBL_MAX;
     1190    int *column = new int[numberElements];
     1191    double *element = new double[numberElements];
     1192    double *lower = new double[numberCliques];
     1193    double *upper = new double[numberCliques];
     1194    numberElements = 0;
     1195    for (iClique = 0; iClique < numberCliques; iClique++) {
     1196      double rhs = 1.0;
     1197      for (CoinBigIndex i = cliqueStart[iClique]; i < cliqueStart[iClique + 1]; i++) {
     1198        CliqueEntry eI = entry[i];
     1199        int iColumn = integerVariable_[sequenceInCliqueEntry(eI)];
     1200        column[numberElements] = iColumn;
     1201        if (oneFixesInCliqueEntry(eI)) {
     1202          element[numberElements++] = 1.0;
     1203        } else {
     1204          element[numberElements++] = -1.0;
     1205          rhs -= 1.0;
     1206        }
     1207      }
     1208      start[iClique + 1] = numberElements;
     1209      assert(cliqueType[iClique] == 'S' || cliqueType[iClique] == 'E');
     1210      if (cliqueType[iClique] == 'S')
     1211        lower[iClique] = -COIN_DBL_MAX;
    12031212      else
    1204         lower[iClique] = rhs;
    1205       upper[iClique]=rhs;
    1206     }
    1207     newSolver->addRows(numberCliques,start,column,element,lower,upper);
    1208     delete [] start;
    1209     delete [] column;
    1210     delete [] element;
    1211     delete [] lower;
    1212     delete [] upper;
    1213   }
    1214   delete [] mark;
    1215   delete [] whichP;
    1216   delete [] whichM;
    1217   delete [] cliqueStart;
    1218   delete [] entry;
    1219   delete [] cliqueType;
    1220   delete [] zeroStart;
    1221   delete [] oneStart;
    1222   delete [] zeroCount;
    1223   delete [] oneCount;
    1224   delete [] whichClique;
     1213        lower[iClique] = rhs;
     1214      upper[iClique] = rhs;
     1215    }
     1216    newSolver->addRows(numberCliques, start, column, element, lower, upper);
     1217    delete[] start;
     1218    delete[] column;
     1219    delete[] element;
     1220    delete[] lower;
     1221    delete[] upper;
     1222  }
     1223  delete[] mark;
     1224  delete[] whichP;
     1225  delete[] whichM;
     1226  delete[] cliqueStart;
     1227  delete[] entry;
     1228  delete[] cliqueType;
     1229  delete[] zeroStart;
     1230  delete[] oneStart;
     1231  delete[] zeroCount;
     1232  delete[] oneCount;
     1233  delete[] whichClique;
    12251234  return newSolver;
    12261235}
    12271236// Take action if cut generator can fix a variable (toValue -1 for down, +1 for up)
    1228 bool
    1229 CglTreeProbingInfo::fixes(int variable, int toValue, int fixedVariable,bool fixedToLower)
     1237bool CglTreeProbingInfo::fixes(int variable, int toValue, int fixedVariable, bool fixedToLower)
    12301238{
    12311239  //printf("%d going to %d fixes %d at %g\n",variable,toValue,fixedVariable,fixedToValue);
    12321240  int intVariable = backward_[variable];
    1233   if (intVariable<0) // off as no longer in order FIX
     1241  if (intVariable < 0) // off as no longer in order FIX
    12341242    return true; // not 0-1 (well wasn't when constructor was called)
    12351243  int intFix = backward_[fixedVariable];
    1236   if (intFix<0)
    1237     intFix = numberIntegers_+fixedVariable; // not 0-1
     1244  if (intFix < 0)
     1245    intFix = numberIntegers_ + fixedVariable; // not 0-1
    12381246  int fixedTo = fixedToLower ? 0 : 1;
    1239   if (numberEntries_==maximumEntries_) {
     1247  if (numberEntries_ == maximumEntries_) {
    12401248    // See if taking too much memory
    1241     if (maximumEntries_>=CoinMax(1000000,10*numberIntegers_))
     1249    if (maximumEntries_ >= CoinMax(1000000, 10 * numberIntegers_))
    12421250      return false;
    1243     maximumEntries_ += 100 +maximumEntries_/2;
    1244     CliqueEntry * temp1 = new CliqueEntry [maximumEntries_];
    1245     memcpy(temp1,fixEntry_,numberEntries_*sizeof(CliqueEntry));
    1246     delete [] fixEntry_;
     1251    maximumEntries_ += 100 + maximumEntries_ / 2;
     1252    CliqueEntry *temp1 = new CliqueEntry[maximumEntries_];
     1253    memcpy(temp1, fixEntry_, numberEntries_ * sizeof(CliqueEntry));
     1254    delete[] fixEntry_;
    12471255    fixEntry_ = temp1;
    1248     int * temp2 = new int [maximumEntries_];
    1249     memcpy(temp2,fixingEntry_,numberEntries_*sizeof(int));
    1250     delete [] fixingEntry_;
     1256    int *temp2 = new int[maximumEntries_];
     1257    memcpy(temp2, fixingEntry_, numberEntries_ * sizeof(int));
     1258    delete[] fixingEntry_;
    12511259    fixingEntry_ = temp2;
    12521260  }
    12531261  CliqueEntry entry1;
    1254   entry1.fixes=0;
    1255   setOneFixesInCliqueEntry(entry1,fixedTo!=0);
    1256   setSequenceInCliqueEntry(entry1,intFix);
     1262  entry1.fixes = 0;
     1263  setOneFixesInCliqueEntry(entry1, fixedTo != 0);
     1264  setSequenceInCliqueEntry(entry1, intFix);
    12571265  fixEntry_[numberEntries_] = entry1;
    1258   assert (toValue==-1||toValue==1);
    1259   assert (fixedTo==0||fixedTo==1);
    1260   if (toValue<0)
     1266  assert(toValue == -1 || toValue == 1);
     1267  assert(fixedTo == 0 || fixedTo == 1);
     1268  if (toValue < 0)
    12611269    fixingEntry_[numberEntries_++] = intVariable << 1;
    12621270  else
     
    12651273}
    12661274// Initalizes fixing arrays etc - returns true if we want to save info
    1267 int
    1268 CglTreeProbingInfo::initializeFixing(const OsiSolverInterface * model)
    1269 {
    1270   if (numberEntries_>=0)
     1275int CglTreeProbingInfo::initializeFixing(const OsiSolverInterface *model)
     1276{
     1277  if (numberEntries_ >= 0)
    12711278    return 2; // already got arrays
    1272   else if (numberEntries_==-2)
     1279  else if (numberEntries_ == -2)
    12731280    return numberEntries_;
    1274   delete [] fixEntry_;
    1275   delete [] toZero_;
    1276   delete [] toOne_;
    1277   delete [] integerVariable_;
    1278   delete [] backward_;
    1279   delete [] fixingEntry_;
    1280   numberVariables_=model->getNumCols();
     1281  delete[] fixEntry_;
     1282  delete[] toZero_;
     1283  delete[] toOne_;
     1284  delete[] integerVariable_;
     1285  delete[] backward_;
     1286  delete[] fixingEntry_;
     1287  numberVariables_ = model->getNumCols();
    12811288  // Too many ... but
    1282   integerVariable_ = new int [numberVariables_];
    1283   backward_ = new int [numberVariables_];
    1284   numberIntegers_=0;
     1289  integerVariable_ = new int[numberVariables_];
     1290  backward_ = new int[numberVariables_];
     1291  numberIntegers_ = 0;
    12851292  int i;
    12861293  // Get integer types
    1287   const char * columnType = model->getColType (true);
    1288   for (i=0;i<numberVariables_;i++) {
    1289     backward_[i]=-1;
     1294  const char *columnType = model->getColType(true);
     1295  for (i = 0; i < numberVariables_; i++) {
     1296    backward_[i] = -1;
    12901297    if (columnType[i]) {
    1291       if (columnType[i]==1) {
    1292         backward_[i]=numberIntegers_;
    1293         integerVariable_[numberIntegers_++]=i;
     1298      if (columnType[i] == 1) {
     1299        backward_[i] = numberIntegers_;
     1300        integerVariable_[numberIntegers_++] = i;
    12941301      } else {
    1295         backward_[i]=-2;
     1302        backward_[i] = -2;
    12961303      }
    12971304    }
     
    13011308  fixEntry_ = NULL;
    13021309  fixingEntry_ = NULL;
    1303   maximumEntries_ =0;
     1310  maximumEntries_ = 0;
    13041311  numberEntries_ = 0;
    13051312  return 1;
    13061313}
    13071314// Converts to ordered and takes out duplicates
    1308 void
    1309 CglTreeProbingInfo::convert()
    1310 {
    1311   if (numberEntries_>=0) {
    1312     CoinSort_2( fixingEntry_, fixingEntry_+numberEntries_, fixEntry_);
    1313     assert (!toZero_);
    1314     toZero_ = new int [numberIntegers_+1];
    1315     toOne_ = new int [numberIntegers_];
    1316     toZero_[0]=0;
    1317     int n=0;
    1318     int put=0;
    1319     for (int intVariable = 0;intVariable<numberIntegers_;intVariable++) {
     1315void CglTreeProbingInfo::convert()
     1316{
     1317  if (numberEntries_ >= 0) {
     1318    CoinSort_2(fixingEntry_, fixingEntry_ + numberEntries_, fixEntry_);
     1319    assert(!toZero_);
     1320    toZero_ = new int[numberIntegers_ + 1];
     1321    toOne_ = new int[numberIntegers_];
     1322    toZero_[0] = 0;
     1323    int n = 0;
     1324    int put = 0;
     1325    for (int intVariable = 0; intVariable < numberIntegers_; intVariable++) {
    13201326      int last = n;
    1321       for (;n<numberEntries_;n++) {
    1322         int value = fixingEntry_[n];
    1323         int iVar = value>>1;
    1324         int way = value &1;
    1325         if (intVariable!=iVar||way)
    1326           break;
    1327       }
    1328       if (n>last) {
    1329         // sort
    1330         assert (sizeof(int)==4);
    1331         std::sort(reinterpret_cast<unsigned int *> (fixEntry_)+last,
    1332                   reinterpret_cast<unsigned int *> (fixEntry_)+n);
    1333         CliqueEntry temp2;
    1334         temp2.fixes=0;
    1335         setSequenceInCliqueEntry(temp2,numberVariables_+1);
    1336         for (int i=last;i<n;i++) {
    1337           if (sequenceInCliqueEntry(temp2)!=sequenceInCliqueEntry(fixEntry_[i])||oneFixesInCliqueEntry(temp2)||oneFixesInCliqueEntry(fixEntry_[i])) {
    1338             temp2 = fixEntry_[i];
    1339             fixEntry_[put++]=temp2;
    1340           }
    1341         }
    1342       }
    1343       toOne_[intVariable]=put;
     1327      for (; n < numberEntries_; n++) {
     1328        int value = fixingEntry_[n];
     1329        int iVar = value >> 1;
     1330        int way = value & 1;
     1331        if (intVariable != iVar || way)
     1332          break;
     1333      }
     1334      if (n > last) {
     1335        // sort
     1336        assert(sizeof(int) == 4);
     1337        std::sort(reinterpret_cast< unsigned int * >(fixEntry_) + last,
     1338          reinterpret_cast< unsigned int * >(fixEntry_) + n);
     1339        CliqueEntry temp2;
     1340        temp2.fixes = 0;
     1341        setSequenceInCliqueEntry(temp2, numberVariables_ + 1);
     1342        for (int i = last; i < n; i++) {
     1343          if (sequenceInCliqueEntry(temp2) != sequenceInCliqueEntry(fixEntry_[i]) || oneFixesInCliqueEntry(temp2) || oneFixesInCliqueEntry(fixEntry_[i])) {
     1344            temp2 = fixEntry_[i];
     1345            fixEntry_[put++] = temp2;
     1346          }
     1347        }
     1348      }
     1349      toOne_[intVariable] = put;
    13441350      last = n;
    1345       for (;n<numberEntries_;n++) {
    1346         int value = fixingEntry_[n];
    1347         int iVar = value>>1;
    1348         if (intVariable!=iVar)
    1349           break;
    1350       }
    1351       if (n>last) {
    1352         // sort
    1353         assert (sizeof(int)==4);
    1354         std::sort(reinterpret_cast<unsigned int *> (fixEntry_)+last,
    1355                   reinterpret_cast<unsigned int *> (fixEntry_)+n);
    1356         CliqueEntry temp2;
    1357         temp2.fixes=0;
    1358         setSequenceInCliqueEntry(temp2,numberVariables_+1);
    1359         for (int i=last;i<n;i++) {
    1360           if (sequenceInCliqueEntry(temp2)!=sequenceInCliqueEntry(fixEntry_[i])||oneFixesInCliqueEntry(temp2)||oneFixesInCliqueEntry(fixEntry_[i])) {
    1361             temp2 = fixEntry_[i];
    1362             fixEntry_[put++]=temp2;
    1363           }
    1364         }
    1365         last=n;
    1366       }
    1367       toZero_[intVariable+1]=put;
    1368     }
    1369     delete [] fixingEntry_;
     1351      for (; n < numberEntries_; n++) {
     1352        int value = fixingEntry_[n];
     1353        int iVar = value >> 1;
     1354        if (intVariable != iVar)
     1355          break;
     1356      }
     1357      if (n > last) {
     1358        // sort
     1359        assert(sizeof(int) == 4);
     1360        std::sort(reinterpret_cast< unsigned int * >(fixEntry_) + last,
     1361          reinterpret_cast< unsigned int * >(fixEntry_) + n);
     1362        CliqueEntry temp2;
     1363        temp2.fixes = 0;
     1364        setSequenceInCliqueEntry(temp2, numberVariables_ + 1);
     1365        for (int i = last; i < n; i++) {
     1366          if (sequenceInCliqueEntry(temp2) != sequenceInCliqueEntry(fixEntry_[i]) || oneFixesInCliqueEntry(temp2) || oneFixesInCliqueEntry(fixEntry_[i])) {
     1367            temp2 = fixEntry_[i];
     1368            fixEntry_[put++] = temp2;
     1369          }
     1370        }
     1371        last = n;
     1372      }
     1373      toZero_[intVariable + 1] = put;
     1374    }
     1375    delete[] fixingEntry_;
    13701376    fixingEntry_ = NULL;
    13711377    numberEntries_ = -2;
     
    13731379}
    13741380// Fix entries in a solver using implications
    1375 int
    1376 CglTreeProbingInfo::fixColumns(OsiSolverInterface & si) const
    1377 {
    1378   int nFix=0;
    1379   const double * lower = si.getColLower();
    1380   const double * upper = si.getColUpper();
    1381   bool feasible=true;
    1382   for (int jColumn=0;jColumn<static_cast<int> (numberIntegers_);jColumn++) {
     1381int CglTreeProbingInfo::fixColumns(OsiSolverInterface &si) const
     1382{
     1383  int nFix = 0;
     1384  const double *lower = si.getColLower();
     1385  const double *upper = si.getColUpper();
     1386  bool feasible = true;
     1387  for (int jColumn = 0; jColumn < static_cast< int >(numberIntegers_); jColumn++) {
    13831388    int iColumn = integerVariable_[jColumn];
    1384     if (upper[iColumn]==0.0) {
     1389    if (upper[iColumn] == 0.0) {
    13851390      int j;
    1386       for ( j=toZero_[jColumn];j<toOne_[jColumn];j++) {
    1387         int kColumn=sequenceInCliqueEntry(fixEntry_[j]);
    1388         kColumn = integerVariable_[kColumn];
    1389         bool fixToOne = oneFixesInCliqueEntry(fixEntry_[j]);
    1390         if (fixToOne) {
    1391           if (lower[kColumn]==0.0) {
    1392             if (upper[kColumn]==1.0) {
    1393               si.setColLower(kColumn,1.0);
    1394               nFix++;
    1395             } else {
    1396               // infeasible!
    1397               feasible=false;
    1398             }
    1399           }
    1400         } else {
    1401           if (upper[kColumn]==1.0) {
    1402             if (lower[kColumn]==0.0) {
    1403               si.setColUpper(kColumn,0.0);
    1404               nFix++;
    1405             } else {
    1406               // infeasible!
    1407               feasible=false;
    1408             }
    1409           }
    1410         }
    1411       }
    1412     } else if (lower[iColumn]==1.0) {
     1391      for (j = toZero_[jColumn]; j < toOne_[jColumn]; j++) {
     1392        int kColumn = sequenceInCliqueEntry(fixEntry_[j]);
     1393        kColumn = integerVariable_[kColumn];
     1394        bool fixToOne = oneFixesInCliqueEntry(fixEntry_[j]);
     1395        if (fixToOne) {
     1396          if (lower[kColumn] == 0.0) {
     1397            if (upper[kColumn] == 1.0) {
     1398              si.setColLower(kColumn, 1.0);
     1399              nFix++;
     1400            } else {
     1401              // infeasible!
     1402              feasible = false;
     1403            }
     1404          }
     1405        } else {
     1406          if (upper[kColumn] == 1.0) {
     1407            if (lower[kColumn] == 0.0) {
     1408              si.setColUpper(kColumn, 0.0);
     1409              nFix++;
     1410            } else {
     1411              // infeasible!
     1412              feasible = false;
     1413            }
     1414          }
     1415        }
     1416      }
     1417    } else if (lower[iColumn] == 1.0) {
    14131418      int j;
    1414       for ( j=toOne_[jColumn];j<toZero_[jColumn+1];j++) {
    1415         int kColumn=sequenceInCliqueEntry(fixEntry_[j]);
    1416         kColumn = integerVariable_[kColumn];
    1417         bool fixToOne = oneFixesInCliqueEntry(fixEntry_[j]);
    1418         if (fixToOne) {
    1419           if (lower[kColumn]==0.0) {
    1420             if (upper[kColumn]==1.0) {
    1421               si.setColLower(kColumn,1.0);
    1422               nFix++;
    1423             } else {
    1424               // infeasible!
    1425               feasible=false;
    1426             }
    1427           }
    1428         } else {
    1429           if (upper[kColumn]==1.0) {
    1430             if (lower[kColumn]==0.0) {
    1431               si.setColUpper(kColumn,0.0);
    1432               nFix++;
    1433             } else {
    1434               // infeasible!
    1435               feasible=false;
    1436             }
    1437           }
    1438         }
     1419      for (j = toOne_[jColumn]; j < toZero_[jColumn + 1]; j++) {
     1420        int kColumn = sequenceInCliqueEntry(fixEntry_[j]);
     1421        kColumn = integerVariable_[kColumn];
     1422        bool fixToOne = oneFixesInCliqueEntry(fixEntry_[j]);
     1423        if (fixToOne) {
     1424          if (lower[kColumn] == 0.0) {
     1425            if (upper[kColumn] == 1.0) {
     1426              si.setColLower(kColumn, 1.0);
     1427              nFix++;
     1428            } else {
     1429              // infeasible!
     1430              feasible = false;
     1431            }
     1432          }
     1433        } else {
     1434          if (upper[kColumn] == 1.0) {
     1435            if (lower[kColumn] == 0.0) {
     1436              si.setColUpper(kColumn, 0.0);
     1437              nFix++;
     1438            } else {
     1439              // infeasible!
     1440              feasible = false;
     1441            }
     1442          }
     1443        }
    14391444      }
    14401445    }
     
    14441449    printf("treeprobing says infeasible!\n");
    14451450#endif
    1446     nFix=-1;
     1451    nFix = -1;
    14471452  }
    14481453  return nFix;
    14491454}
    14501455// Fix entries in a solver using implications for one variable
    1451 int
    1452 CglTreeProbingInfo::fixColumns(int iColumn,int value, OsiSolverInterface & si) const
    1453 {
    1454   assert (value==0||value==1);
    1455   int nFix=0;
    1456   const double * lower = si.getColLower();
    1457   const double * upper = si.getColUpper();
    1458   bool feasible=true;
     1456int CglTreeProbingInfo::fixColumns(int iColumn, int value, OsiSolverInterface &si) const
     1457{
     1458  assert(value == 0 || value == 1);
     1459  int nFix = 0;
     1460  const double *lower = si.getColLower();
     1461  const double *upper = si.getColUpper();
     1462  bool feasible = true;
    14591463  int jColumn = backward_[iColumn];
    1460   if (jColumn<0 || !toZero_)
     1464  if (jColumn < 0 || !toZero_)
    14611465    return 0;
    14621466  if (!value) {
    14631467    int j;
    1464     for ( j=toZero_[jColumn];j<toOne_[jColumn];j++) {
    1465       int kColumn=sequenceInCliqueEntry(fixEntry_[j]);
     1468    for (j = toZero_[jColumn]; j < toOne_[jColumn]; j++) {
     1469      int kColumn = sequenceInCliqueEntry(fixEntry_[j]);
    14661470      kColumn = integerVariable_[kColumn];
    14671471      bool fixToOne = oneFixesInCliqueEntry(fixEntry_[j]);
    14681472      if (fixToOne) {
    1469         if (lower[kColumn]==0.0) {
    1470           if (upper[kColumn]==1.0) {
    1471             si.setColLower(kColumn,1.0);
    1472             nFix++;
    1473           } else {
    1474             // infeasible!
    1475             feasible=false;
    1476           }
    1477         }
     1473        if (lower[kColumn] == 0.0) {
     1474          if (upper[kColumn] == 1.0) {
     1475            si.setColLower(kColumn, 1.0);
     1476            nFix++;
     1477          } else {
     1478            // infeasible!
     1479            feasible = false;
     1480          }
     1481        }
    14781482      } else {
    1479         if (upper[kColumn]==1.0) {
    1480           if (lower[kColumn]==0.0) {
    1481             si.setColUpper(kColumn,0.0);
    1482             nFix++;
    1483           } else {
    1484             // infeasible!
    1485             feasible=false;
    1486           }
    1487         }
     1483        if (upper[kColumn] == 1.0) {
     1484          if (lower[kColumn] == 0.0) {
     1485            si.setColUpper(kColumn, 0.0);
     1486            nFix++;
     1487          } else {
     1488            // infeasible!
     1489            feasible = false;
     1490          }
     1491        }
    14881492      }
    14891493    }
    14901494  } else {
    14911495    int j;
    1492     for ( j=toOne_[jColumn];j<toZero_[jColumn+1];j++) {
    1493       int kColumn=sequenceInCliqueEntry(fixEntry_[j]);
     1496    for (j = toOne_[jColumn]; j < toZero_[jColumn + 1]; j++) {
     1497      int kColumn = sequenceInCliqueEntry(fixEntry_[j]);
    14941498      kColumn = integerVariable_[kColumn];
    14951499      bool fixToOne = oneFixesInCliqueEntry(fixEntry_[j]);
    14961500      if (fixToOne) {
    1497         if (lower[kColumn]==0.0) {
    1498           if (upper[kColumn]==1.0) {
    1499             si.setColLower(kColumn,1.0);
    1500             nFix++;
    1501           } else {
    1502             // infeasible!
    1503             feasible=false;
    1504           }
    1505         }
     1501        if (lower[kColumn] == 0.0) {
     1502          if (upper[kColumn] == 1.0) {
     1503            si.setColLower(kColumn, 1.0);
     1504            nFix++;
     1505          } else {
     1506            // infeasible!
     1507            feasible = false;
     1508          }
     1509        }
    15061510      } else {
    1507         if (upper[kColumn]==1.0) {
    1508           if (lower[kColumn]==0.0) {
    1509             si.setColUpper(kColumn,0.0);
    1510             nFix++;
    1511           } else {
    1512             // infeasible!
    1513             feasible=false;
    1514           }
    1515         }
     1511        if (upper[kColumn] == 1.0) {
     1512          if (lower[kColumn] == 0.0) {
     1513            si.setColUpper(kColumn, 0.0);
     1514            nFix++;
     1515          } else {
     1516            // infeasible!
     1517            feasible = false;
     1518          }
     1519        }
    15161520      }
    15171521    }
     
    15211525    printf("treeprobing says infeasible!\n");
    15221526#endif
    1523     nFix=-1;
     1527    nFix = -1;
    15241528  }
    15251529  return nFix;
    15261530}
    15271531// Packs down entries
    1528 int
    1529 CglTreeProbingInfo::packDown()
     1532int CglTreeProbingInfo::packDown()
    15301533{
    15311534  convert();
    1532   int iPut=0;
    1533   int iLast=0;
    1534   for (int jColumn=0;jColumn<static_cast<int> (numberIntegers_);jColumn++) {
     1535  int iPut = 0;
     1536  int iLast = 0;
     1537  for (int jColumn = 0; jColumn < static_cast< int >(numberIntegers_); jColumn++) {
    15351538    int j;
    1536     for ( j=iLast;j<toOne_[jColumn];j++) {
    1537       int kColumn=sequenceInCliqueEntry(fixEntry_[j]);
    1538       if (kColumn<numberIntegers_)
    1539         fixEntry_[iPut++]=fixEntry_[j];
    1540     }
    1541     iLast=toOne_[jColumn];
    1542     toOne_[jColumn]=iPut;
    1543     for ( j=iLast;j<toZero_[jColumn+1];j++) {
    1544       int kColumn=sequenceInCliqueEntry(fixEntry_[j]);
    1545       if (kColumn<numberIntegers_)
    1546         fixEntry_[iPut++]=fixEntry_[j];
    1547     }
    1548     iLast=toZero_[jColumn+1];
    1549     toZero_[jColumn+1]=iPut;
     1539    for (j = iLast; j < toOne_[jColumn]; j++) {
     1540      int kColumn = sequenceInCliqueEntry(fixEntry_[j]);
     1541      if (kColumn < numberIntegers_)
     1542        fixEntry_[iPut++] = fixEntry_[j];
     1543    }
     1544    iLast = toOne_[jColumn];
     1545    toOne_[jColumn] = iPut;
     1546    for (j = iLast; j < toZero_[jColumn + 1]; j++) {
     1547      int kColumn = sequenceInCliqueEntry(fixEntry_[j]);
     1548      if (kColumn < numberIntegers_)
     1549        fixEntry_[iPut++] = fixEntry_[j];
     1550    }
     1551    iLast = toZero_[jColumn + 1];
     1552    toZero_[jColumn + 1] = iPut;
    15501553  }
    15511554  return iPut;
    15521555}
    1553 void
    1554 CglTreeProbingInfo::generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
    1555                                  const CglTreeInfo /*info*/) const
    1556 {
    1557   const double * lower = si.getColLower();
    1558   const double * upper = si.getColUpper();
    1559   const double * colsol =si.getColSolution();
     1556void CglTreeProbingInfo::generateCuts(const OsiSolverInterface &si, OsiCuts &cs,
     1557  const CglTreeInfo /*info*/) const
     1558{
     1559  const double *lower = si.getColLower();
     1560  const double *upper = si.getColUpper();
     1561  const double *colsol = si.getColSolution();
    15601562  CoinPackedVector lbs(false);
    15611563  CoinPackedVector ubs(false);
    1562   int numberFixed=0;
    1563   char * fixed = NULL;
    1564   for (int jColumn=0;jColumn<static_cast<int> (numberIntegers_);jColumn++) {
     1564  int numberFixed = 0;
     1565  char *fixed = NULL;
     1566  for (int jColumn = 0; jColumn < static_cast< int >(numberIntegers_); jColumn++) {
    15651567    int iColumn = integerVariable_[jColumn];
    1566     assert (iColumn>=0&&iColumn<si.getNumCols());
    1567     if (lower[iColumn]==0.0&&upper[iColumn]==1.0) {
     1568    assert(iColumn >= 0 && iColumn < si.getNumCols());
     1569    if (lower[iColumn] == 0.0 && upper[iColumn] == 1.0) {
    15681570      double value1 = colsol[iColumn];
    15691571      int j;
    1570       for ( j=toZero_[jColumn];j<toOne_[jColumn];j++) {
    1571         int kColumn=sequenceInCliqueEntry(fixEntry_[j]);
    1572         kColumn = integerVariable_[kColumn];
    1573         assert (kColumn>=0&&kColumn<si.getNumCols());
    1574         assert (kColumn!=iColumn);
    1575         if (lower[kColumn]==0.0&&upper[kColumn]==1.0) {
    1576           double value2 = colsol[kColumn];
    1577           bool fixToOne = oneFixesInCliqueEntry(fixEntry_[j]);
    1578           if (fixToOne) {
    1579             if (value1+value2<0.99999) {
    1580               OsiRowCut rc;
    1581               int index[2];
    1582               double element[2];
    1583               index[0]=iColumn;
    1584               element[0]=1.0;
    1585               index[1]=kColumn;
    1586               element[1]= 1.0;
    1587               rc.setLb(1.0);
    1588               rc.setUb(COIN_DBL_MAX);   
    1589               rc.setRow(2,index,element,false);
    1590               cs.insert(rc);
    1591             }
    1592           } else {
    1593             if (value1-value2<-0.00001) {
    1594               OsiRowCut rc;
    1595               int index[2];
    1596               double element[2];
    1597               index[0]=iColumn;
    1598               element[0]=1.0;
    1599               index[1]=kColumn;
    1600               element[1]= -1.0;
    1601               rc.setLb(0.0);
    1602               rc.setUb(COIN_DBL_MAX);   
    1603               rc.setRow(2,index,element,false);
    1604               cs.insert(rc);
    1605             }
    1606           }
    1607         }
    1608       }
    1609       for ( j=toOne_[jColumn];j<toZero_[jColumn+1];j++) {
    1610         int kColumn=sequenceInCliqueEntry(fixEntry_[j]);
    1611         kColumn = integerVariable_[kColumn];
    1612         assert (kColumn>=0&&kColumn<si.getNumCols());
    1613         assert (kColumn!=iColumn);
    1614         if (lower[kColumn]==0.0&&upper[kColumn]==1.0) {
    1615           double value2 = colsol[kColumn];
    1616           bool fixToOne = oneFixesInCliqueEntry(fixEntry_[j]);
    1617           if (fixToOne) {
    1618             if (value1-value2>0.00001) {
    1619               OsiRowCut rc;
    1620               int index[2];
    1621               double element[2];
    1622               index[0]=iColumn;
    1623               element[0]=1.0;
    1624               index[1]=kColumn;
    1625               element[1]= -1.0;
    1626               rc.setLb(-COIN_DBL_MAX);
    1627               rc.setUb(0.0);   
    1628               rc.setRow(2,index,element,false);
    1629               cs.insert(rc);
    1630             }
    1631           } else {
    1632             if (value1+value2>1.00001) {
    1633               OsiRowCut rc;
    1634               int index[2];
    1635               double element[2];
    1636               index[0]=iColumn;
    1637               element[0]=1.0;
    1638               index[1]=kColumn;
    1639               element[1]= 1.0;
    1640               rc.setLb(-COIN_DBL_MAX);
    1641               rc.setUb(1.0);   
    1642               rc.setRow(2,index,element,false);
    1643               cs.insert(rc);
    1644             }
    1645           }
    1646         }
    1647       }
    1648     } else if (upper[iColumn]==0.0) {
    1649       for (int j=toZero_[jColumn];j<toOne_[jColumn];j++) {
    1650         int kColumn01=sequenceInCliqueEntry(fixEntry_[j]);
    1651         int kColumn = integerVariable_[kColumn01];
    1652         assert (kColumn>=0&&kColumn<si.getNumCols());
    1653         bool fixToOne = oneFixesInCliqueEntry(fixEntry_[j]);
    1654         if (lower[kColumn]==0.0&&upper[kColumn]==1.0) {
    1655           if (!fixed) {
    1656             fixed = new char [numberIntegers_];
    1657             memset(fixed,0,numberIntegers_);
    1658           }
    1659           if (fixToOne) {
    1660             if ((fixed[kColumn01]&1)==0) {
    1661               fixed[kColumn01] |= 1;
    1662               lbs.insert(kColumn,1.0);
    1663             }
    1664           } else {
    1665             if ((fixed[kColumn01]&2)==0) {
    1666               fixed[kColumn01] |= 2;
    1667               ubs.insert(kColumn,0.0);
    1668             }
    1669           }
    1670           numberFixed++;
    1671         } else if ((fixToOne&&upper[kColumn]==0.0)||
    1672                    (!fixToOne&&lower[kColumn]==1.0)) {
    1673           // infeasible!
    1674           // generate infeasible cut and return
    1675           OsiRowCut rc;
    1676           rc.setLb(COIN_DBL_MAX);
    1677           rc.setUb(0.0);   
    1678           cs.insert(rc);
    1679           //printf("IMPINFEAS!\n");
    1680           return;
    1681         }
     1572      for (j = toZero_[jColumn]; j < toOne_[jColumn]; j++) {
     1573        int kColumn = sequenceInCliqueEntry(fixEntry_[j]);
     1574        kColumn = integerVariable_[kColumn];
     1575        assert(kColumn >= 0 && kColumn < si.getNumCols());
     1576        assert(kColumn != iColumn);
     1577        if (lower[kColumn] == 0.0 && upper[kColumn] == 1.0) {
     1578          double value2 = colsol[kColumn];
     1579          bool fixToOne = oneFixesInCliqueEntry(fixEntry_[j]);
     1580          if (fixToOne) {
     1581            if (value1 + value2 < 0.99999) {
     1582              OsiRowCut rc;
     1583              int index[2];
     1584              double element[2];
     1585              index[0] = iColumn;
     1586              element[0] = 1.0;
     1587              index[1] = kColumn;
     1588              element[1] = 1.0;
     1589              rc.setLb(1.0);
     1590              rc.setUb(COIN_DBL_MAX);
     1591              rc.setRow(2, index, element, false);
     1592              cs.insert(rc);
     1593            }
     1594          } else {
     1595            if (value1 - value2 < -0.00001) {
     1596              OsiRowCut rc;
     1597              int index[2];
     1598              double element[2];
     1599              index[0] = iColumn;
     1600              element[0] = 1.0;
     1601              index[1] = kColumn;
     1602              element[1] = -1.0;
     1603              rc.setLb(0.0);
     1604              rc.setUb(COIN_DBL_MAX);
     1605              rc.setRow(2, index, element, false);
     1606              cs.insert(rc);
     1607            }
     1608          }
     1609        }
     1610      }
     1611      for (j = toOne_[jColumn]; j < toZero_[jColumn + 1]; j++) {
     1612        int kColumn = sequenceInCliqueEntry(fixEntry_[j]);
     1613        kColumn = integerVariable_[kColumn];
     1614        assert(kColumn >= 0 && kColumn < si.getNumCols());
     1615        assert(kColumn != iColumn);
     1616        if (lower[kColumn] == 0.0 && upper[kColumn] == 1.0) {
     1617          double value2 = colsol[kColumn];
     1618          bool fixToOne = oneFixesInCliqueEntry(fixEntry_[j]);
     1619          if (fixToOne) {
     1620            if (value1 - value2 > 0.00001) {
     1621              OsiRowCut rc;
     1622              int index[2];
     1623              double element[2];
     1624              index[0] = iColumn;
     1625              element[0] = 1.0;
     1626              index[1] = kColumn;
     1627              element[1] = -1.0;
     1628              rc.setLb(-COIN_DBL_MAX);
     1629              rc.setUb(0.0);
     1630              rc.setRow(2, index, element, false);
     1631              cs.insert(rc);
     1632            }
     1633          } else {
     1634            if (value1 + value2 > 1.00001) {
     1635              OsiRowCut rc;
     1636              int index[2];
     1637              double element[2];
     1638              index[0] = iColumn;
     1639              element[0] = 1.0;
     1640              index[1] = kColumn;
     1641              element[1] = 1.0;
     1642              rc.setLb(-COIN_DBL_MAX);
     1643              rc.setUb(1.0);
     1644              rc.setRow(2, index, element, false);
     1645              cs.insert(rc);
     1646            }
     1647          }
     1648        }
     1649      }
     1650    } else if (upper[iColumn] == 0.0) {
     1651      for (int j = toZero_[jColumn]; j < toOne_[jColumn]; j++) {
     1652        int kColumn01 = sequenceInCliqueEntry(fixEntry_[j]);
     1653        int kColumn = integerVariable_[kColumn01];
     1654        assert(kColumn >= 0 && kColumn < si.getNumCols());
     1655        bool fixToOne = oneFixesInCliqueEntry(fixEntry_[j]);
     1656        if (lower[kColumn] == 0.0 && upper[kColumn] == 1.0) {
     1657          if (!fixed) {
     1658            fixed = new char[numberIntegers_];
     1659            memset(fixed, 0, numberIntegers_);
     1660          }
     1661          if (fixToOne) {
     1662            if ((fixed[kColumn01] & 1) == 0) {
     1663              fixed[kColumn01] |= 1;
     1664              lbs.insert(kColumn, 1.0);
     1665            }
     1666          } else {
     1667            if ((fixed[kColumn01] & 2) == 0) {
     1668              fixed[kColumn01] |= 2;
     1669              ubs.insert(kColumn, 0.0);
     1670            }
     1671          }
     1672          numberFixed++;
     1673        } else if ((fixToOne && upper[kColumn] == 0.0) || (!fixToOne && lower[kColumn] == 1.0)) {
     1674          // infeasible!
     1675          // generate infeasible cut and return
     1676          OsiRowCut rc;
     1677          rc.setLb(COIN_DBL_MAX);
     1678          rc.setUb(0.0);
     1679          cs.insert(rc);
     1680          //printf("IMPINFEAS!\n");
     1681          return;
     1682        }
    16821683      }
    16831684    } else {
    1684       for (int j=toOne_[jColumn];j<toZero_[jColumn+1];j++) {
    1685         int kColumn01=sequenceInCliqueEntry(fixEntry_[j]);
    1686         int kColumn = integerVariable_[kColumn01];
    1687         assert (kColumn>=0&&kColumn<si.getNumCols());
    1688         bool fixToOne = oneFixesInCliqueEntry(fixEntry_[j]);
    1689         if (lower[kColumn]==0.0&&upper[kColumn]==1.0) {
    1690           if (!fixed) {
    1691             fixed = new char [numberIntegers_];
    1692             memset(fixed,0,numberIntegers_);
    1693           }
    1694           if (fixToOne) {
    1695             if ((fixed[kColumn01]&1)==0) {
    1696               fixed[kColumn01] |= 1;
    1697               lbs.insert(kColumn,1.0);
    1698             }
    1699           } else {
    1700             if ((fixed[kColumn01]&2)==0) {
    1701               fixed[kColumn01] |= 2;
    1702               ubs.insert(kColumn,0.0);
    1703             }
    1704           }
    1705           numberFixed++;
    1706         } else if ((fixToOne&&upper[kColumn]==0.0)||
    1707                    (!fixToOne&&lower[kColumn]==1.0)) {
    1708           // infeasible!
    1709           // generate infeasible cut and return
    1710           OsiRowCut rc;
    1711           rc.setLb(COIN_DBL_MAX);
    1712           rc.setUb(0.0);   
    1713           cs.insert(rc);
    1714           //printf("IMPINFEAS!\n");
    1715           return;
    1716         }
     1685      for (int j = toOne_[jColumn]; j < toZero_[jColumn + 1]; j++) {
     1686        int kColumn01 = sequenceInCliqueEntry(fixEntry_[j]);
     1687        int kColumn = integerVariable_[kColumn01];
     1688        assert(kColumn >= 0 && kColumn < si.getNumCols());
     1689        bool fixToOne = oneFixesInCliqueEntry(fixEntry_[j]);
     1690        if (lower[kColumn] == 0.0 && upper[kColumn] == 1.0) {
     1691          if (!fixed) {
     1692            fixed = new char[numberIntegers_];
     1693            memset(fixed, 0, numberIntegers_);
     1694          }
     1695          if (fixToOne) {
     1696            if ((fixed[kColumn01] & 1) == 0) {
     1697              fixed[kColumn01] |= 1;
     1698              lbs.insert(kColumn, 1.0);
     1699            }
     1700          } else {
     1701            if ((fixed[kColumn01] & 2) == 0) {
     1702              fixed[kColumn01] |= 2;
     1703              ubs.insert(kColumn, 0.0);
     1704            }
     1705          }
     1706          numberFixed++;
     1707        } else if ((fixToOne && upper[kColumn] == 0.0) || (!fixToOne && lower[kColumn] == 1.0)) {
     1708          // infeasible!
     1709          // generate infeasible cut and return
     1710          OsiRowCut rc;
     1711          rc.setLb(COIN_DBL_MAX);
     1712          rc.setUb(0.0);
     1713          cs.insert(rc);
     1714          //printf("IMPINFEAS!\n");
     1715          return;
     1716        }
    17171717      }
    17181718    }
    17191719  }
    17201720  if (numberFixed) {
    1721     int feasible=true;
    1722     for (int i=0;i<numberIntegers_;i++) {
    1723       if (fixed[i]==3) {
    1724         feasible=false;
    1725         break;
    1726       }
    1727     }
    1728     delete [] fixed;
     1721    int feasible = true;
     1722    for (int i = 0; i < numberIntegers_; i++) {
     1723      if (fixed[i] == 3) {
     1724        feasible = false;
     1725        break;
     1726      }
     1727    }
     1728    delete[] fixed;
    17291729    if (feasible) {
    17301730      //printf("IMP fixed %d\n",numberFixed);
     
    17391739      OsiRowCut rc;
    17401740      rc.setLb(COIN_DBL_MAX);
    1741       rc.setUb(0.0);   
     1741      rc.setUb(0.0);
    17421742      cs.insert(rc);
    17431743      //printf("IMPINFEAS!\n");
     
    17451745  }
    17461746}
     1747
     1748/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
     1749*/
  • branches/autotools-update/Cgl/src/CglCommon/CglTreeInfo.hpp

    r1414 r1481  
    1515class CglTreeInfo {
    1616public:
    17   /// The level of the search tree node 
     17  /// The level of the search tree node
    1818  int level;
    1919  /** How many times the cut generator was already invoked in this search tree
     
    4545  int hasParent;
    4646  /// parent solver
    47   OsiSolverInterface * parentSolver;
     47  OsiSolverInterface *parentSolver;
    4848  /// Original columns (if preprocessed)
    49   int * originalColumns;
     49  int *originalColumns;
    5050  /** Replacement array.  Before Branch and Cut it may be beneficial to strengthen rows
    5151      rather than adding cuts.  If this array is not NULL then the cut generator can
     
    5757      The calling function can then replace those rows.
    5858  */
    59   OsiRowCut ** strengthenRow;
     59  OsiRowCut **strengthenRow;
    6060  /// Optional pointer to thread specific random number generator
    61   CoinThreadRandom * randomNumberGenerator;
    62   /// Default constructor 
    63   CglTreeInfo ();
    64  
    65   /// Copy constructor 
    66   CglTreeInfo (
     61  CoinThreadRandom *randomNumberGenerator;
     62  /// Default constructor
     63  CglTreeInfo();
     64
     65  /// Copy constructor
     66  CglTreeInfo(
    6767    const CglTreeInfo &);
    6868&