Changes from releases/5.6.14 at r2707 to releases/5.6.15 at r2707


Ignore:
Location:
releases/5.6.15
Files:
24 edited

Legend:

Unmodified
Added
Removed
  • releases/5.6.15/.travis.yml

    r2707 r2707  
    11language: cpp
    2 
     2env:
     3  global:
     4    - secure: "KXrNrSs66/J5fb8pRYTUhIjEiXizlZ7p0xVROPla+GWfwyLJIAiswbwYOBpR1kSTn51E+j6j14UWL36GC31TK5WXRJoWoyVXi1RH+zZfvESAwqI6OmhzTWQd84fyXJ+vx5Yg0qEhPGH0HFGaNrpAvsBtr8lmsoLgocEaMikqxQ8="
     5   
    36matrix:
    47  include:
     8    - os: linux
     9      addons:
     10        apt:
     11          packages:
     12            - gfortran
    513    - os: osx
    6       osx_image: osx10.11
     14      osx_image: xcode8.2
     15      env: OSX=10.12
     16      compiler: clang
     17    - os: osx
     18      osx_image: xcode8
    719      env: OSX=10.11
    820      compiler: clang
    921    - os: osx
    10       osx_image: xcode7
     22      osx_image: xcode6.4
    1123      env: OSX=10.10
    1224      compiler: clang
     
    1527      env: OSX=10.9
    1628      compiler: clang
    17     - os: linux
    18       addons:
    19         apt:
    20           packages:
    21           - gfortran
    2229  allow_failures:
    2330    - os: osx
    2431
    2532before_script:
    26   - if [[ "$TRAVIS_OS_NAME" == "osx" ]] && [[ "$OSX" != "10.9" ]]; then brew update; fi
    27   - if [[ "$TRAVIS_OS_NAME" == "osx" ]] && [[ "$OSX" != "10.9" ]]; then brew install gcc; fi
     33  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then  export PLATFORM=osx$OSX-x86_64-clang`clang -dumpversion`; fi
     34  - if [[ "$TRAVIS_OS_NAME" == "osx" ]] && [[ "$OSX" == "10.10" ]]; then brew update; brew install gcc; export PLATFORM=osx10.10-x86_64-clang`clang -dumpversion`; fi
     35  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then export PLATFORM=linux-x86_64-gcc`gcc -dumpversion`; fi
    2836  - git clone --branch=stable/0.8 https://github.com/coin-or-tools/BuildTools
    2937  - bash BuildTools/get.dependencies.sh fetch > /dev/null
     
    3139script:
    3240  - patch -p0 < SYMPHONY/Osi.patch
    33   - bash BuildTools/get.dependencies.sh build --quiet --test
     41  - bash BuildTools/get.dependencies.sh build --quiet --test
     42
     43after_script:
     44  - if [ $TRAVIS_BRANCH = "master" ]; then export VERSION=trunk; else export VERSION=`echo $TRAVIS_BRANCH | cut -d "/" -f 2`; fi
     45  - export PROJECT=`echo $TRAVIS_REPO_SLUG | cut -d "/" -f 2`
     46  - export TGZ_FILE=$PROJECT-$VERSION-$PLATFORM.tgz
     47  - echo $TGZ_FILE
     48  - tar -czvf $TGZ_FILE build/lib/* build/bin/* build/include/* build/share/*
     49  - curl -T $TGZ_FILE -utkralphs:$BINTRAY_API -H "X-Bintray-Publish:1" -H "X-Bintray-Override:1" https://api.bintray.com/content/coin-or/download/$PROJECT/$VERSION/$TGZ_FILE
  • releases/5.6.15/INSTALL

    r2707 r2707  
    1111please see the SYMPHONY [ user's manual].
    1212
    13 == Building SYMPHONY in Unix-like environments (UNIX/LINUX/CYGWIN/MINGW/OSX) ==
     13== Building SYMPHONY in Unix-like environments (UNIX / LINUX / CYGWIN / MSys / OSX) ==
     14
     15For more detailed information on MSys and CYGWIN installs, see below.
    1416
    1517SYMPHONY uses the COIN-OR build system and the GNU autotools to automate the
     
    2527provided below.
    2628
    27 === DOWNLOADING ===
    28 
    29 You can obtain the SYMPHONY source code either via the subversion repository
    30 or in the form of archived release. The recommended method in Unix is to use
    31 subversion because it makes it easier to obtain updates. In a Unix-like
     29=== DOWNLOADING SOURCE ===
     30
     31You can obtain the SYMPHONY source code either via the subversion repository,
     32via Github, or in the form of archived release. The recommended method in Unix
     33is to use subversion because it makes it easier to obtain updates and to
     34download the correct versions of dependencies. In a Unix-like
    3235environment (such as Linux or CYGWIN), the following command may be used to
    3336obtain SYMPHONY from source using SVN in most cases:
    3437
    3538{{{svn co https://projects.coin-or.org/svn/SYMPHONY/stable/5.6 SYMPHONY-5.6}}}
     39
     40To obtain via git from github, you can do
     41
     42{{{git clone --branch=stable/5.6 https://github.com/coin-or/SYMPHONY/ SYMPHONY-5.6}}}
    3643
    3744Alternatively, you can download release versions of the source code from the
     
    4754
    4855The first step is to run a configuration script that will allow the
    49 compilation process to be customized for your environment. to perform this
    50 step, switch into the root directory of the distribution and type
    51 
    52 {{{./configure}}}
     56compilation process to be customized for your environment. To perform this
     57step, first switch into the root directory
     58
     59{{{
     60cd SYMPHONY-5.6
     61}}}
     62
     63of the distribution and type.
     64
     65If you checked out the git repo, you can then obtain the dependencies by
     66typing the following (this is unnecessary with SVN).
     67
     68{{{
     69git clone --branch=stable/0.8 https://github.com/coin-or-tools/BuildTools/
     70BuildTools/get.dependencies fetch
     71}}}
     72
     73The finally, do
     74
     75{{{
     76./configure
     77}}}
     78
     79With git, you need to fetch the dependencies first.
    5380
    5481This will set up the default configuration files. If you want to override the
     
    5986explanations can be seen both in the file 'share/config.site' and by typing
    6087
    61 {{{./configure --help=recursive}}}
     88{{{
     89./configure --help=recursive
     90}}}
    6291
    6392In order to enable or disable an option, either update the file
     
    6594script. As an instance for the second case, running
    6695
    67 {{{./configure --enable-debug}}}
     96{{{
     97./configure --enable-debug
     98}}}
    6899
    69100will set the configuration to compile the source files with debugging flag.
     
    79110{{{cl}}} with GNU autotools in the CYGWIN environment configure with
    80111
    81 {{{./configure --enable-msvc}}}
    82 
    83 Please see further details on building in this configuration [ here]
     112{{{
     113./configure --enable-msvc
     114}}}
     115
     116Please see further details on building in this configuration below.
    84117
    85118=== BUILDING ===
     
    87120  1. After configuring, the code can be built by typing the commands
    88121
    89 {{{
    90 make
    91 make install
    92 }}}
    93 
    94 This will first create the required libraries and binaries and then will
    95 install SYMPHONY. By default, the library 'libSym' and the executable
    96 {{{symphony}}} will be installed to the {{{lib/}}} and {{{bin/}}} directories.
     122   {{{
     123   make
     124   make install
     125   }}}
     126
     127  This will first create the required libraries and binaries and then will
     128  install SYMPHONY. By default, the library 'libSym' and the executable
     129  {{{symphony}}} will be installed to the {{{lib/}}} and {{{bin/}}} directories.
    97130
    98131  2. The SYMPHONY library, together with the header files in the subdirectory
     
    105138  enabling the ability to read GMPL files.
    106139
    107 For a more powerful modeling interface, FlopC++ can also be used to obtain a
    108 capability similar to ILOG's Concert technology for building math programming
    109 models (see SYMPHONY/Examples/FLOPC++).
    110 
    111 If you are planning to use the interactive optimizer, it is recommended to run
    112 the configuration script with
    113 
    114 {{{./configure --enable-gnu-packages}}}
    115 
    116 This will allow the interactive shell to be able to behave exactly like a
    117 Linux terminal command line, i.e., it will keep the history of the used
    118 commands, will complete the input word to possible commands, etc. Make sure
    119 that you have the needed package ({{{readline.h}}} and {{{history.h}}} include
    120 files and their libraries) on the system files path.
     140  For a more powerful modeling interface, FlopC++ can also be used to obtain a
     141  capability similar to ILOG's Concert technology for building math programming
     142  models (see SYMPHONY/Examples/FLOPC++).
     143
     144  If you are planning to use the interactive optimizer, it is recommended to run
     145  the configuration script with
     146
     147  {{{./configure --enable-gnu-packages}}}
     148
     149  This will allow the interactive shell to be able to behave exactly like a
     150  Linux terminal command line, i.e., it will keep the history of the used
     151  commands, will complete the input word to possible commands, etc. Make sure
     152  that you have the needed package ({{{readline.h}}} and {{{history.h}}} include
     153  files and their libraries) on the system files path.
    121154
    122155  3. To test SYMPHONY after building, type
    123156
    124 {{{make test}}}
    125 
    126 to execute an automated unit test. To test out the optimizer manually. a
    127 sample MPS file called {{{sample.mps}}} and a sample GMPL/AMPL file called
    128 {{{sample.mod}}} together with its data file {{{sample.dat}}} are included
    129 with the distribution. You can use either the command-line or the interactive
    130 optimizer. To solve the sample MPS model, type
    131 
    132 {{{bin/symphony -F SYMPHONY/Datasets/sample.mps}}}
    133 
    134 To solve the GMPL model, use the "-F" switch to specify the file name and the
    135 "-D" for the data file name if the input is in GMPL/AMPL format, i.e., type
    136 
    137 {{{bin/symphony -F SYMPHONY/Datasets/sample.mod -D SYMPHONY/Datasets/sample.dat}}}
    138 
    139 For more MPS data files for further testing, see the MIPLIB library in the
    140 {{{Data/Sample}}} subdirectory. To run the interactive optimizer, execute
    141 SYMPHONY without any command-line arguments, i.e., type
    142 
    143 {{{bin/symphony}}}
    144 
    145 and then type {{{help}}} or {{{?}}} to see a list of available commands.
     157  {{{make test}}}
     158
     159  to execute an automated unit test. To test out the optimizer manually. a
     160  sample MPS file called {{{sample.mps}}} and a sample GMPL/AMPL file called
     161  {{{sample.mod}}} together with its data file {{{sample.dat}}} are included
     162  with the distribution. You can use either the command-line or the interactive
     163  optimizer. To solve the sample MPS model, type
     164
     165  {{{bin/symphony -F SYMPHONY/Datasets/sample.mps}}}
     166
     167  To solve the GMPL model, use the "-F" switch to specify the file name and the
     168  "-D" for the data file name if the input is in GMPL/AMPL format, i.e., type
     169
     170  {{{bin/symphony -F SYMPHONY/Datasets/sample.mod -D SYMPHONY/Datasets/sample.dat}}}
     171
     172  For more MPS data files for further testing, see the MIPLIB library in the
     173  {{{Data/Sample}}} subdirectory. To run the interactive optimizer, execute
     174  SYMPHONY without any command-line arguments, i.e., type
     175
     176  {{{bin/symphony}}}
     177
     178  and then type {{{help}}} or {{{?}}} to see a list of available commands.
    146179
    147180  4. After the SYMPHONY library and the executable are compiled and tested,
    148181  you can type
    149182
    150 {{{make clean}}}
    151 
    152 if you want to save disk space.
     183  {{{make clean}}}
     184
     185  if you want to save disk space.
    153186
    154187  5. That's it! Now you are ready to use SYMPHONY callable library or solve
     
    157190=== SHARED MEMORY PARALLEL ===
    158191
    159  1. To compile a shared memory version of SYMPHONY, simply use an OpenMP compliant
    160  compiler. Version \VER\  builds with OpenMP support enabled automatically when
    161  the compiler provides it. This should be the case for all recent versions of
    162  gcc and recent Microsoft compilers. Clang on OS X does not support OpenMP,
    163  though it is possible to build a version that does yourself. You can manually
    164  enable or disable OpenMP support with configure options by doing, e.g.,
    165 
    166  {{{./configure --enable-openmp}}}
    167 
    168  In the Microsoft Visual Studio, enable OpenMP
    169  support in the properties for the SYMPHONY projects (it doesn't need to be
    170  enabled for the dependent projects). In a future version, this will also be
    171  made the default.
    172 
    173  2. Follow the instructions above for building and testing.
    174 
    175  3. To invoke SYMPHONY from the command-line with multiple threads, specify the
    176  number of \emph{additional} worker threads with the \code{-p} option, i.e.,
    177  invoking SYMPHONY with
    178 
    179  {{{bin/symphony -p 2 -F SYMPHONY/Datasets/sample.mps}}}
    180 
    181  will utilize two worker threads to process subproblems in parallel.
    182  When more than 1 thread is used, the first thread is the ``master''
    183  thread and only prints out periodic status messages, as well as doing some
    184  bookkeeping work. Therefore, it is recommended to always use at least one
    185  worker thread (\code{-p 1}}). Starting in version 5.6.0, the number of
    186  threads used is automatically set equal to the number of available cores if no
    187  option is specified. For a fully sequential run with just one thread, invoke
    188  SYMPHONY with
    189 
    190  {{{bin/symphony -p 2 -F SYMPHONY/Datasets/sample.mps}}}
     192  1. To compile a shared memory version of SYMPHONY, simply use an OpenMP compliant
     193  compiler. Version \VER\  builds with OpenMP support enabled automatically when
     194  the compiler provides it. This should be the case for all recent versions of
     195  gcc and recent Microsoft compilers. Clang on OS X does not support OpenMP,
     196  though it is possible to build a version that does yourself. You can manually
     197  enable or disable OpenMP support with configure options by doing, e.g.,
     198
     199  {{{./configure --enable-openmp}}}
     200
     201  In the Microsoft Visual Studio, enable OpenMP
     202  support in the properties for the SYMPHONY projects (it doesn't need to be
     203  enabled for the dependent projects). In a future version, this will also be
     204  made the default.
     205
     206  2. Follow the instructions above for building and testing.
     207
     208  3. To invoke SYMPHONY from the command-line with multiple threads, specify the
     209  number of \emph{additional} worker threads with the \code{-p} option, i.e.,
     210  invoking SYMPHONY with
     211
     212  {{{bin/symphony -p 2 -F SYMPHONY/Datasets/sample.mps}}}
     213
     214  will utilize two worker threads to process subproblems in parallel.
     215  When more than 1 thread is used, the first thread is the ``master''
     216  thread and only prints out periodic status messages, as well as doing some
     217  bookkeeping work. Therefore, it is recommended to always use at least one
     218  worker thread (\code{-p 1}}). Starting in version 5.6.0, the number of
     219  threads used is automatically set equal to the number of available cores if no
     220  option is specified. For a fully sequential run with just one thread, invoke
     221  SYMPHONY with
     222
     223  {{{bin/symphony -p 2 -F SYMPHONY/Datasets/sample.mps}}}
    191224
    192225=== DISTRIBUTED PARALLEL ===
    193226
    194  1. If you wish to compile a distributed version of the code, first make sure
    195  you have PVM installed. You can obtain it from http://www.csm.ornl.gov/pvm/.
    196 
    197  2. To configure for a parallel build, invoke the configuration script as
    198  follows:
    199 
    200 {{{./configure --with-pvm}}}
    201 
    202 Be sure that PVM is installed either in system path or that you have the
    203 environment variable PVM_ROOT set properly. Note that there are a number of
    204 different parallel configurations. The default configuration is to build two
    205 parallel modules. The first one consists of the master, tree management, and
    206 cut management modules, while the second one consists of the node processing,
    207 and cut generation modules. For other configuration options, see the
    208 {{{share/config.site file}}}
    209 
    210  3. Follow the build instructions above to build the code. Note that this will
    211  also compile the sequential version.
    212 
    213  4. Make sure there are links from your {{{$HOME/pvm3/bin/$PVM_ARCH/}}}
    214  subdirectory to each of the executables in your {{{bin/' directory}}} This is
    215  required by PVM.
    216 
    217  5. Start the PVM daemon by typing {{{pvm}}} on the command line and then
    218  typing {{{quit}}}.
    219 
    220  6. As above, test SYMPHONY using the sample MPS file called {{{sample.mps}}}
    221  included with the distribution. To specify the file name, use the {{{-F}}}
    222  command-line option, i.e., in the root directory, type
    223 
    224 {{{bin/symphony_m$(EXT) -F SYMPHONY/Datasets/sample.mps}}}
    225 
    226 where {{{$(EXT)}}} is an extension to be added according to the chosen module
    227 dependencies. To obtain more MPS data files for further testing, download the
    228 MIPLIB library.
     227  1. If you wish to compile a distributed version of the code, first make sure
     228  you have PVM installed. You can obtain it from http://www.csm.ornl.gov/pvm/.
     229
     230  2. To configure for a parallel build, invoke the configuration script as
     231  follows:
     232
     233  {{{./configure --with-pvm}}}
     234
     235  Be sure that PVM is installed either in system path or that you have the
     236  environment variable PVM_ROOT set properly. Note that there are a number of
     237  different parallel configurations. The default configuration is to build two
     238  parallel modules. The first one consists of the master, tree management, and
     239  cut management modules, while the second one consists of the node processing,
     240  and cut generation modules. For other configuration options, see the
     241  {{{share/config.site file}}}
     242
     243  3. Follow the build instructions above to build the code. Note that this will
     244  also compile the sequential version.
     245
     246  4. Make sure there are links from your {{{$HOME/pvm3/bin/$PVM_ARCH/}}}
     247  subdirectory to each of the executables in your {{{bin/' directory}}} This is
     248  required by PVM.
     249
     250  5. Start the PVM daemon by typing {{{pvm}}} on the command line and then
     251  typing {{{quit}}}.
     252
     253  6. As above, test SYMPHONY using the sample MPS file called {{{sample.mps}}}
     254  included with the distribution. To specify the file name, use the {{{-F}}}
     255  command-line option, i.e., in the root directory, type
     256
     257  {{{bin/symphony_m$(EXT) -F SYMPHONY/Datasets/sample.mps}}}
     258
     259  where {{{$(EXT)}}} is an extension to be added according to the chosen module
     260  dependencies. To obtain more MPS data files for further testing, download the
     261  MIPLIB library.
    229262
    230263=== BUILDING APPLICATIONS ===
    231264
    232  1. In order to compile SYMPHONY's applications, you must first compile the
    233  application-specific library with
    234 
    235 {{{ ./configure --with-application make make install }}}
    236 
    237 This will create the application library called {{{libSymAppl}}} to be used
    238 while building custom applications. Note that the sequential version library
    239 and executable will also be made and installed.
    240 
    241  2. After building the library, go to one of the application subdirectories in
    242 the {{{SYMPHONY/Applications/}}} directory and type {{{make}}} there. For more
    243 information, including the parallel configuration instructions, see the
    244 INSTALL file of the corresponding application.
     265  1. In order to compile SYMPHONY's applications, you must first compile the
     266  application-specific library with
     267
     268  {{{
     269  ./configure --with-application
     270  make
     271  make install
     272  }}}
     273
     274  This will create the application library called {{{libSymAppl}}} to be used
     275  while building custom applications. Note that the sequential version library
     276  and executable will also be made and installed.
     277
     278  2. After building the library, go to one of the application subdirectories in
     279  the {{{SYMPHONY/Applications/}}} directory and type {{{make}}} there. For more
     280  information, including the parallel configuration instructions, see the
     281  INSTALL file of the corresponding application.
    245282
    246283== COMPILING The SYMPHONY Library and Executable (Microsoft Windows) ==
    247284
    248 Here is a sketch outline of how to compile SYMPHONY in Microsoft Windows.
    249 These instructions will lead you through the steps required to compile
    250 SYMPHONY as a generic MILP solver. This process will create * a generic
    251 callable library that allows SYMPHONY to be called from an application and *
    252 an executable that can be used as a stand-alone application to solve MILPs
    253 written in either MPS, LP, or GMPL file format. SYMPHONY can be further
    254 customized by implementing one of more than 50 callback functions that change
    255 SYMPHONY's default execution of its algorithm. For information on customizing
    256 SYMPHONY using callbacks, a quick start guide is provided below. Note that in
    257 the Windows version, detailed timing information is not currently provided.
    258 
    259 First, obtain the source code as described above. Unpack the archive to create
    260 the directory SYMPHONY-XX. You now have three options. You can either build
    261 using the MSVC++ IDE, build on the command-line with MSVC++ executable, or use
    262 the NMAKE utility.
    263 
    264 == Building With the MSVC++ IDE ==
    265 
     285  Here is a sketch outline of how to compile SYMPHONY in Microsoft Windows.
     286  These instructions will lead you through the steps required to compile
     287  SYMPHONY as a generic MILP solver. This process will create * a generic
     288  callable library that allows SYMPHONY to be called from an application and *
     289  an executable that can be used as a stand-alone application to solve MILPs
     290  written in either MPS, LP, or GMPL file format. SYMPHONY can be further
     291  customized by implementing one of more than 50 callback functions that change
     292  SYMPHONY's default execution of its algorithm. For information on customizing
     293  SYMPHONY using callbacks, a quick start guide is provided below. Note that in
     294  the Windows version, detailed timing information is not currently provided.
     295
     296  First, obtain the source code as described above. Unpack the archive to create
     297  the directory SYMPHONY-XX. You now have three options. You can either build
     298  using the MSVC++ IDE, build on the command-line with MSVC++ executable, or use
     299  the NMAKE utility.
     300
     301  The recommended and best-supported way of building in Windows is from a command
     302  prompt using the MSys2 shell. You can build with either the MSVC++ or the MinGW
     303  compilers in this way. This gives you the most flexibility and power over the
     304  build options.
     305
     306=== BUILDING WITH MSys2 or CYGWIN ===
     307
     308  1. First, install either MSys2 or CYGWIN
     309    * To install MSys2, download and unzip/tar http://kent.dl.sourceforge.net/project/msys2/Base/x86_64/msys2-base-x86_64-20150512.tar.xz
     310    * To install CYGWIN, go [https://cygwin.com/install.html here]
     311  2. Modify your Windows path.
     312    * For Msys2 Add {{{msys64\usr\bin}}}, {{{msys64\mingw32\bin}}}, and
     313    {{{msys64\mingw32\bin}}} to your Windows path.
     314    * For CYGWIN, add the CYGWIN bin directory to your Windows path (probably
     315    {{{cygwin64\bin}}}).
     316
     317  3. Open a Windows terminal.
     318 
     319  4. If building with the Visual Studio compiler, execute {{{vcvarsall.bat}}}.
     320   
     321  5. At the command prompt, type {{{bash}}}.
     322
     323  6. At the {{{bash}}} prompt, do
     324  {{{
     325  pacman -S make wget tar patch dos2unix diffutils svn
     326  svn co https://projects.coin-or.org/svn/SYMPHONY/stable/5.6 SYMPHONY-5.6
     327  }}}
     328  Then next
     329    * To build with the Visual Studio compiler, do
     330    {{{
     331    ./configure --build=x86_64-w64-mingw32 --enable-msvc
     332    make
     333    make install
     334    }}}
     335    * To build with the MinGW 32-bit compiler, do
     336    {{{
     337    pacman -S mingw-w64-i686-gcc mingw-w64-i686-gcc-fortran   
     338    ./configure --build=x86_64-w64-mingw32 --host=i686-w64-mingw32
     339    make
     340    make install
     341    }}}
     342    * To build with the Visual Studio compiler, do
     343    {{{
     344    pacman -S mingw-w64-x86_64-gcc mingw-w64-x86_64-gcc-fortran
     345    ./configure --build=x86_64-w64-mingw32 --host=x86_64-w64-mingw32
     346    make
     347    make install
     348    }}}
     349  Note that it is also possible to obtain SYMPHONY with git. See *Nix
     350  instructions above for details on how to modify these instructions
     351  for that case.
     352
     353  4. To test SYMPHONY after building, type
     354
     355  {{{make test}}}
     356
     357  to execute an automated unit test. To test out the optimizer manually. a
     358  sample MPS file called {{{sample.mps}}} and a sample GMPL/AMPL file called
     359  {{{sample.mod}}} together with its data file {{{sample.dat}}} are included
     360  with the distribution. You can use either the command-line or the interactive
     361  optimizer. To solve the sample MPS model, type
     362
     363  {{{bin/symphony -F SYMPHONY/Datasets/sample.mps}}}
     364
     365  For more MPS data files for further testing, see the MIPLIB library in the
     366  {{{Data/Sample}}} subdirectory. To run the interactive optimizer, execute
     367  SYMPHONY without any command-line arguments, i.e., type
     368
     369  {{{bin/symphony}}}
     370
     371  and then type {{{help}}} or {{{?}}} to see a list of available commands.
     372
     373=== BUILDING WITH the MSVC++ IDE ===
     374
     375  These instructions are for MSVC++ Version 10. Instructions for other versions
     376  should be similar. '''The MSVC++ are not regularly tested so please let us know
     377  if they are broken.'''
     378
     379  1. Go to {{{SYMPHONY/MSVisualStudio/v10}}} directory and open the solution
     380  file {{{symphony.sln}}}.
     381
     382  1. Note that there are a number of additional preprocessor definitions that
     383  control the functionality of SYMPHONY. These definitions are described in
     384  {{{sym.mak}}}, a Unix-style makefile included in the distribution. To enable
     385  the functionality associated with a particular definition, simply add it to
     386  the list of definitions of {{{libSymphony}}} project together with the
     387  required libraries and paths. For instance, if you want to enable GMPL reader
     388  option, you need to * add the directory of the header files of GLPK to the
     389  include files path * add {{{USE_GLPMPL}}} to the defines * add the GLPK
     390  library to the solution
     391
     392  1. Make sure that the project {{{symphony}}} is set as the startup project by
     393  choosing "Set as Startup Project" from the Project menu after selecting the
     394  symphony project in the Solution Explorer. Choose {{{Build Solution}}} from
     395  the {{{Build}}} menu. This should successfully build the SYMPHONY library and
     396  the corresponding executable.
     397
     398  1. To test the executable, go to the {{{Debug}}} tab and choose {{{Start
     399  Without Debugging.}}} and then type {{{help}}} or {{{?}}} to see a list of
     400  available commands.
     401
     402=== BUILDING WITH VISUAL STUDIO FROM COMMAND LINE (deprecated) ===
     403 
    266404These instructions are for MSVC++ Version 10. Instructions for other versions
    267405should be similar.
    268406
    269  1. Go to {{{SYMPHONY/MSVisualStudio/v10}}} directory and open the solution
    270  file {{{symphony.sln}}}.
    271 
    272  1. Note that there are a number of additional preprocessor definitions that
    273  control the functionality of SYMPHONY. These definitions are described in
    274  {{{sym.mak}}}, a Unix-style makefile included in the distribution. To enable
    275  the functionality associated with a particular definition, simply add it to
    276  the list of definitions of {{{libSymphony}}} project together with the
    277  required libraries and paths. For instance, if you want to enable GMPL reader
    278  option, you need to * add the directory of the header files of GLPK to the
    279  include files path * add {{{USE_GLPMPL}}} to the defines * add the GLPK
    280  library to the solution
    281 
    282  1. Make sure that the project {{{symphony}}} is set as the startup project by
    283  choosing "Set as Startup Project" from the Project menu after selecting the
    284  symphony project in the Solution Explorer. Choose {{{Build Solution}}} from
    285  the {{{Build}}} menu. This should successfully build the SYMPHONY library and
    286  the corresponding executable.
    287 
    288  1. To test the executable, go to the {{{Debug}}} tab and choose {{{Start
    289  Without Debugging.}}} and then type {{{help}}} or {{{?}}} to see a list of
    290  available commands.
    291 
    292 == Building in a Windows Terminal ==
    293 
    294 These instructions are for MSVC++ Version 10. Instructions for other versions
    295 should be similar.
    296 
    297  1. Open a command line terminal. Go to 'SYMPHONY/MSVisualStudio/v10'
    298  directory and type
    299 
    300  {{{devenv symphony.sln /Build "Debug|Win32}}}
    301 
    302 This will create the 32-bit debug version of SYMPHONY. You can build 64-bit
    303 with
    304 
    305 {{{devenv symphony.sln /Build "Debug|x64"}}}
    306 
    307 For each command, the library {{{libSymphony.lib}}} and the executable
    308 {{{symphony}}} will be created in directories according to platform and
    309 configuration. The library, together with the header files in
    310 {{{SYMPHONY\include\}}}, can then be used to call SYMPHONY from any C/C++
    311 code. The API for calling SYMPHONY is described in the user's manual.
    312 
    313  1. To test the executable, type
    314 
    315  {{{symphony.exe -F ..\..\SYMPHONY\Datasets\sample.mps}}}
    316 
    317 In the appropriate directory. If you want to use the interactive optimizer,
    318 simply type
    319 
    320 {{{symphony.exe}}}
    321 
    322 and then type {{{help}}} or {{{?}}} to see a list of available commands.
    323 
    324 3. If SYMPHONY is modified, type
    325 
    326  {{{devenv symphony.sln /Rebuild "Debug|Win32"}}}
    327 
    328 in order to clean and rebuild everything.
    329 
    330 == Building With the MSVC++ compiler in CYGWIN ==
    331 
    332 It is possible to perform at automated build of SYMPHONY using the MSVC++
    333 compiler {{{cl}}} with GNU autotools in the CYGWIN environment. To do so,
    334 follow the instructions for building in Unix-like environments, except when
    335 configuring, use the command
    336 
    337  ./configure --enable-msvc
    338 
    339 == Building With the NMAKE Utility ==
    340 
    341 Note: the {{{sym.mak}}} file is no longer maintained, but may work.
    342 
    343  1. Go to {{{MSVisualStudio}}} directory and edit the {{{sym.mak}}} makefile
    344 to reflect your environment. This involves specifying the LP solver to be
    345 used, assigning some variables and setting various paths. Only minor edits
    346 should be required. An explanation of what has to be set is contained in the
    347 comments in the makefile. Note that, you have to first create the COIN
    348 libraries Cgl, Clp, Osi, OsiClp and CoinUtils.
    349 
    350  1. Once configuration is done, open a command line terminal and type
    351 
    352 {{{nmake sym.mak}}}
    353 
    354 This will make the SYMPHONY library {{{libSymphony.lib}}} and the executable
    355 {{{symphony}}} in {{{Debug}}} directory. The library, together with the header
    356 files in {{{SYMPHONY\include\}}}, can then be used to call SYMPHONY from any
    357 C/C++ code. The API for calling SYMPHONY is described in the user's manual.
    358 
    359  3. To test the executable, type
    360 
    361  {{{symphony.exe -F ..\..\SYMPHONY\Datasets\sample.mps}}}
    362 
    363 in the output directory. If you want to use the interactive optimizer, simply
    364 type
    365 
    366  {{{symphony.exe}}}
    367 
    368 and then type {{{help}}} or {{{?}}} to see a list of available commands.
     407  1. Open a command line terminal. Go to 'SYMPHONY/MSVisualStudio/v10'
     408  directory and type
     409
     410  {{{devenv symphony.sln /Build "Debug|Win32}}}
     411
     412  This will create the 32-bit debug version of SYMPHONY. You can build 64-bit
     413  with
     414
     415  {{{devenv symphony.sln /Build "Debug|x64"}}}
     416
     417  For each command, the library {{{libSymphony.lib}}} and the executable
     418  {{{symphony}}} will be created in directories according to platform and
     419  configuration. The library, together with the header files in
     420  {{{SYMPHONY\include\}}}, can then be used to call SYMPHONY from any C/C++
     421  code. The API for calling SYMPHONY is described in the user's manual.
     422
     423  1. To test the executable, type
     424
     425  {{{symphony.exe -F ..\..\SYMPHONY\Datasets\sample.mps}}}
     426
     427  In the appropriate directory. If you want to use the interactive optimizer,
     428  simply type
     429
     430  {{{symphony.exe}}}
     431
     432  and then type {{{help}}} or {{{?}}} to see a list of available commands.
     433
     434  3. If SYMPHONY is modified, type
     435
     436  {{{devenv symphony.sln /Rebuild "Debug|Win32"}}}
     437
     438  in order to clean and rebuild everything.
     439
     440== BUILDING WITH THE NMAKE Utility (deprecated) ==
     441
     442  Note: the {{{sym.mak}}} file is no longer maintained, but may work.
     443
     444  1. Go to {{{MSVisualStudio}}} directory and edit the {{{sym.mak}}} makefile
     445  to reflect your environment. This involves specifying the LP solver to be
     446  used, assigning some variables and setting various paths. Only minor edits
     447  should be required. An explanation of what has to be set is contained in the
     448  comments in the makefile. Note that, you have to first create the COIN
     449  libraries Cgl, Clp, Osi, OsiClp and CoinUtils.
     450
     451  1. Once configuration is done, open a command line terminal and type
     452
     453  {{{nmake sym.mak}}}
     454
     455  This will make the SYMPHONY library {{{libSymphony.lib}}} and the executable
     456  {{{symphony}}} in {{{Debug}}} directory. The library, together with the header
     457  files in {{{SYMPHONY\include\}}}, can then be used to call SYMPHONY from any
     458  C/C++ code. The API for calling SYMPHONY is described in the user's manual.
     459
     460  3. To test the executable, type
     461
     462  {{{symphony.exe -F ..\..\SYMPHONY\Datasets\sample.mps}}}
     463
     464  in the output directory. If you want to use the interactive optimizer, simply
     465  type
     466
     467  {{{symphony.exe}}}
     468
     469  and then type {{{help}}} or {{{?}}} to see a list of available commands.
    369470 
  • releases/5.6.15/README

    r2707 r2707  
    88Enjoy!
    99
    10 The SYMPHONY Development Team
     10The SYMPHONY Development Team 
  • releases/5.6.15/README.md

    r2707 r2707  
    1 # SYMPHONY Version 5.6.10 README
     1# SYMPHONY Version 5.6.15 README
    22
    33Welcome to SYMPHONY. SYMPHONY is distributed under the Eclipse Public License
     
    552000-2015 by Ted Ralphs and others. This README may be redistributed freely.
    66
     7# CURRENT BUILD STATUS
     8
     9[![Build Status](https://travis-ci.org/coin-or/SYMPHONY.svg?branch=master)](https://travis-ci.org/coin-or/SYMPHONY)
     10
     11[![Build status](https://ci.appveyor.com/api/projects/status/220ltxwv2w2ac51s/branch/master?svg=true)](https://ci.appveyor.com/project/tkralphs/symphony/branch/master)
     12
     13[ ![Download](https://api.bintray.com/packages/coin-or/download/SYMPHONY/images/download.svg?version=5.6) ](https://bintray.com/coin-or/download/SYMPHONY/5.6)
     14
     15[![DOI](https://zenodo.org/badge/23689820.svg)](https://zenodo.org/badge/latestdoi/23689820)
     16
    717# DOCUMENTATION
    818
     
    1929
    2030## INSTALLATION
     31
     32Binaries for most platforms are available for download from [Bintray](https://bintray.com/coin-or/download/SYMPHONY)
    2133
    2234If you downloaded a source distribution and would like instructions on
     
    5466        [-j 0/1 ] [ -e n ] [ -i iters ] [ -t time ] [ -g gap ] [ -n nodes ]
    5567        [ -u ub ] [ -p procs ] [ -k rule ] [ -v level ] [ -c rule ]
    56         [ -m max ] [ -z n ] [-o tree_out_file]
     68        [ -m max ] [ -z n ] [-o tree_out_file] [-w 0/1]
    5769
    5870
     
    7284        -r 0/1: whether or not to do reduced cost tightening
    7385        -j 0/1: whether or not to generate cgl cuts
     86        -w 0/1: whether or not to use hot starting in strong branching
    7487        -e n: set pre-processing level to 'n'
    7588        -i iters: allow a max of 'iters' iterations in presolve
     
    151164### SEQUENTIAL
    152165
    153 Known configurations that build and pass unit test
    154 
    155 - gcc 4.* on LINUX
    156 - MSVC++ Version 9-11 compiler in CYGWIN using the autotools
    157 - MSVC++ Version 9-11 IDE
    158 - gcc 4.* on Mac OSX 10.4.8
    159 - clang
     166Sequential configurations are now automatically built and tested on Linux, OS X, and Windows using
     167 * [Travis-CI](https://travis-ci.org/coin-or/symphony)
     168 * [Appveyor](https://ci.appveyor.com/project/tkralphs/symphony)
    160169
    161170### SHARED MEMORY PARLLEL (OpenMP)
    162171
    163 Builds and passes unit test with gcc 4.* and CLP on LINUX.
     172Builds and passes unit test with gcc 4 and 5 and CLP on LINUX.
    164173
    165174### DISTRIBUTED MEMORY PARALLEL (PVM)
     
    227236Please note the version of SYMPHONY you are using when filing the ticket.
    228237
     238### ACKNOWLEDGEMENTS
     239
     240SYMPHONY was developed with support from
     241
     242* National Science Foundation (Grants CMMI-1435453, CMMI-0728011, DMI-0522796, DMI-0534862, DMS-9527124, CMMI-1130914)
     243* Texas ATP Grant 97-3604-010
     244* Cornell University
     245* Lehigh University
     246* Zuse Institute Berlin
     247* Research Campus Modal "Mathematical Optimization and Data Analysis
     248Laboratories" funded by the German Federal Ministry of Education and Research
     249(BMBF Grant 05M14ZAM) and by the DFG SFB/Transregio 154
     250
    229251## CHANGELOG
    230252
     253### Release 5.6.15
     254  * Fix for configuration issue with OpenMP when building with Visual Studio
     255    compiler under Msys2
     256
     257### Release 5.6.14
     258  * Fixing small bug with re-setting environment in user applications.
     259  * Fixing some memory errors arising with applications when extra variables are used.
     260  * Fixing small bug with tracking variable indices in branching.
     261  * Moving code inside critical block to prevent memory access errors in shared memory parallel mode.
     262  * Added switches for turning hot starting on and off
     263  * Updates to documentation
     264  * Small fixes
     265  * Added support for Travis and Appveyor
     266
    231267### Release 5.6.13
    232   * Updating externals to get relevant bug fixes
     268  * Release to update externals and pick up bug fixes in other projects
    233269
    234270### Release 5.6.12
  • releases/5.6.15/SYMPHONY

  • releases/5.6.15/SYMPHONY/Doc/man-start.tex

    r2707 r2707  
    180180\subsubsection{Downloading}
    181181
    182 You can obtain the SYMPHONY source code either via the subversion repository
    183 or in the form of archived releases. The recommended method in Unix is to use
    184 subversion because it makes it easier to obtain updates. In a Unix-like
    185 environment (such as Linux or CYGWIN), the following command may be used to
    186 obtain SYMPHONY from source using SVN in most cases: {\color{Brown}
     182You can obtain the SYMPHONY source code either via the subversion repository,
     183or via the mirror on github using git, or in the form of archived releases.
     184The recommended method in Unix is to use subversion because it makes it easier
     185to obtain updates. In a Unix-like environment (such as Linux or CYGWIN), the
     186following command may be used to obtain SYMPHONY from source using SVN in most
     187cases:
     188{\color{Brown}
    187189\begin{verbatim}
    188190 svn checkout https://projects.coin-or.org/svn/SYMPHONY/stable/5.6 SYMPHONY-5.6
     191\end{verbatim}
     192}
     193To obtain via git from github, you can do
     194{\color{Brown}
     195\begin{verbatim}
     196git clone --branch=stable/5.6 https://github.com/coin-or/SYMPHONY/ SYMPHONY-5.6
    189197\end{verbatim}
    190198}
     
    206214\subsubsection{Configuring}\label{configuring}
    207215
    208 The first step is to run a configuration script that will allow the
     216First, switch into the root of the SYMPHONY source checkout.
     217If you obtained SYMPHONY via git, the the next step is to fetch the
     218externals, as follows (this is unnecessary with SVN).
     219{\color{Brown}
     220\begin{verbatim}
     221git clone --branch=stable/5.6 https://github.com/coin-or-tools/BuildTools/
     222BuildTools/get.dependencies fetch
     223\end{verbatim}
     224}
     225Next, you will run a configuration script that will allow the
    209226compilation process to be customized for your environment. to perform this
    210227step, switch into the root directory of the distribution and type
     
    213230 ./configure
    214231\end{verbatim}
    215 } This will set up the default configuration files. If you want to override
     232}
     233This will set up the default configuration files. If you want to override
    216234the default settings, you can either run the configuration script with
    217235command-line options or else modify the options in the file
  • releases/5.6.15/SYMPHONY/Doc/man.tex

    r2707 r2707  
    9797\def\CP{{Cut Pool Parameters}}
    9898\def\CGP{{Cut Generator Parameters}}
    99 \def\VER{{5.6.13}}
     99\def\VER{{5.6.15}}
    100100\lstloadlanguages{C++}
    101101
     
    161161\begin{rawhtml} <H1 ALIGN="CENTER">
    162162\end{rawhtml}
    163 \title{\huge {\bf \BB\ \VER\  User's Manual} \thanks{This research was partially
    164 supported by NSF Grants DMS-9527124, DMI-0534862, DMI-0522796, CMMI-0728011,
    165 CMMI-1130914, as well as
    166 Texas ATP Grant 97-3604-010. A revised version of Chapters
     163\title{\huge {\bf \BB\ \VER\  User's Manual} \thanks{This research was
     164    partially supported by NSF Grants CMMI-1435453, CMMI-0728011, DMI-0522796,
     165    DMI-0534862, DMS-9527124, CMMI-1130914, and Texas ATP Grant 97-3604-010. A revised version of Chapters
    167166\ref{SYMPHONY-design} of this manual now appears
    168167in the Springer-Verlag book {\em Computational Combinatorial Optimization}
     
    217216\begin{rawhtml} <P ALIGN="CENTER"> <STRONG> <FONT SIZE="3">
    218217PDF version available <A
    219 HREF="http://www.coin-or.org/doc/SYMPHONY-5.6.9-Manual.pdf">here</A>
     218HREF="http://www.coin-or.org/doc/SYMPHONY-5.6.15-Manual.pdf">here</A>
    220219</FONT></STRONG></P>
    221220\end{rawhtml}
  • releases/5.6.15/SYMPHONY/README

    r2707 r2707  
    1 SYMPHONY Version 5.6.13 README
     1SYMPHONY Version 5.6.15 README
    22=============================
    33
     
    2626*                              INSTALLATION                                  *
    2727******************************************************************************
     28
     29Binaries for most platforms are available for download from Bintray:
     30
     31https://bintray.com/coin-or/download/SYMPHONY
    2832
    2933If you downloaded a source distribution and would like instructions on
     
    6266        [-j 0/1 ] [ -e n ] [ -i iters ] [ -t time ] [ -g gap ] [ -n nodes ]
    6367        [ -u ub ] [ -p procs ] [ -k rule ] [ -v level ] [ -c rule ]
    64         [ -m max ] [ -z n ] [-o tree_out_file]
     68        [ -m max ] [ -z n ] [-o tree_out_file] [-w 0/1]
    6569
    6670
     
    8084        -r 0/1: whether or not to do reduced cost tightening
    8185        -j 0/1: whether or not to generate cgl cuts
     86        -w 0/1: whether or not to use hot starting in strong branching
    8287        -e n: set pre-processing level to 'n'
    8388        -i iters: allow a max of 'iters' iterations in presolve
     
    164169Known configurations that build and pass unit test
    165170
    166 - gcc 4.* on LINUX
    167 - MSVC++ Version 9-11 compiler in CYGWIN using the autotools
    168 - MSVC++ Version 9-11 IDE
    169 - gcc 4.* on Mac OSX 10.4.8
    170 - clang
     171Sequential configurations are now automatically built and tested on Linux, OS X, and Windows using
     172 * [Travis-CI](https://travis-ci.org/coin-or/symphony)
     173 * [Appveyor](https://ci.appveyor.com/project/tkralphs/symphony)
    171174
    172175SHARED MEMORY PARLLEL (OpenMP)
    173176
    174 Builds and passes unit test with gcc 4.* and CLP on LINUX.
     177Builds and passes unit test with gcc 4 and 5 and CLP on LINUX.
    175178
    176179DISTRIBUTED MEMORY PARALLEL (PVM)
     
    243246Please note the version of SYMPHONY you are using when filing the ticket.
    244247
     248ACKNOWLEDGEMENTS
     249
     250SYMPHONY was developed with support from
     251
     252* National Science Foundation (Grants CMMI-1435453, CMMI-0728011, DMI-0522796, DMI-0534862, DMS-9527124, CMMI-1130914)
     253* Texas ATP Grant 97-3604-010
     254* Cornell University
     255* Lehigh University
     256* Zuse Institute Berlin
     257* Research Campus Modal "Mathematical Optimization and Data Analysis
     258Laboratories" funded by the German Federal Ministry of Education and Research
     259(BMBF Grant 05M14ZAM) and by the DFG SFB/Transregio 154
     260
    245261WHAT'S NEW
    246262==========
    247263
    248 ### Release 5.6.13
    249   * Updating externals to get relevant bug fixes
     264# Release 5.6.15
     265  * Fix for configuration issue with OpenMP when building with Visual Studio
     266    compiler under Msys2
     267
     268# Release 5.6.14
     269  * Fixing small bug with re-setting environment in user applications.
     270  * Fixing some memory errors arising with applications when extra variables are used.
     271  * Fixing small bug with tracking variable indices in branching.
     272  * Moving code inside critical block to prevent memory access errors in shared memory parallel mode.
     273  * Added switches for turning hot starting on and off
     274  * Updates to documentation
     275  * Small fixes
     276  * Added support for Travis and Appveyor
     277
     278# Release 5.6.13
     279  * Release to update externals and pick up bug fixes in other projects
    250280
    251281# Release 5.6.12
  • releases/5.6.15/SYMPHONY/configure

    r2707 r2707  
    11#! /bin/sh
    22# Guess values for system-dependent variables and create Makefiles.
    3 # Generated by GNU Autoconf 2.59 for SYMPHONY 5.6.14.
     3# Generated by GNU Autoconf 2.59 for SYMPHONY 5.6.15.
    44#
    55# Report bugs to <symphony@list.coin-or.org>.
     
    440440PACKAGE_NAME='SYMPHONY'
    441441PACKAGE_TARNAME='symphony'
    442 PACKAGE_VERSION='5.6.14'
    443 PACKAGE_STRING='SYMPHONY 5.6.14'
     442PACKAGE_VERSION='5.6.15'
     443PACKAGE_STRING='SYMPHONY 5.6.15'
    444444PACKAGE_BUGREPORT='symphony@list.coin-or.org'
    445445
     
    10161016  # This message is too long to be a string in the A/UX 3.1 sh.
    10171017  cat <<_ACEOF
    1018 \`configure' configures SYMPHONY 5.6.14 to adapt to many kinds of systems.
     1018\`configure' configures SYMPHONY 5.6.15 to adapt to many kinds of systems.
    10191019
    10201020Usage: $0 [OPTION]... [VAR=VALUE]...
     
    10821082if test -n "$ac_init_help"; then
    10831083  case $ac_init_help in
    1084      short | recursive ) echo "Configuration of SYMPHONY 5.6.14:";;
     1084     short | recursive ) echo "Configuration of SYMPHONY 5.6.15:";;
    10851085   esac
    10861086  cat <<\_ACEOF
     
    13361336if $ac_init_version; then
    13371337  cat <<\_ACEOF
    1338 SYMPHONY configure 5.6.14
     1338SYMPHONY configure 5.6.15
    13391339generated by GNU Autoconf 2.59
    13401340
     
    13661366running configure, to aid debugging if configure makes a mistake.
    13671367
    1368 It was created by SYMPHONY $as_me 5.6.14, which was
     1368It was created by SYMPHONY $as_me 5.6.15, which was
    13691369generated by GNU Autoconf 2.59.  Invocation command line was
    13701370
     
    18921892
    18931893# Capture libtool library version, if given.
    1894  coin_libversion=9:14:6
     1894 coin_libversion=9:15:6
    18951895
    18961896
     
    46214621# Define the identity of the package.
    46224622 PACKAGE='symphony'
    4623  VERSION='5.6.14'
     4623 VERSION='5.6.15'
    46244624
    46254625
     
    2894028940
    2894128941if test $sym_openmp = true; then
    28942   SYM_OPENMP_FLAGS=-fopenmp
    28943   SYM_OPENMP_LIBS=-lgomp
     28942  if test x$coin_cxx_is_cl = xtrue; then
     28943    SYM_OPENMP_FLAGS=-openmp
     28944    SYM_OPENMP_LIBS=
     28945  else
     28946    SYM_OPENMP_FLAGS=-fopenmp
     28947    SYM_OPENMP_LIBS=-lgomp
     28948  fi
    2894428949else
    2894528950  SYM_OPENMP_FLAGS=
     
    2899829003     CXXFLAGS="$CXXFLAGS -TP"
    2899929004     if test $sym_openmp = true; then
    29000          CXXFLAGS="$CXXFLAGS /openmp"
     29005         CXXFLAGS="$CXXFLAGS -openmp"
    2900129006     fi
    2900229007  ;;
     
    2996629971cat >&5 <<_CSEOF
    2996729972
    29968 This file was extended by SYMPHONY $as_me 5.6.14, which was
     29973This file was extended by SYMPHONY $as_me 5.6.15, which was
    2996929974generated by GNU Autoconf 2.59.  Invocation command line was
    2997029975
     
    3002930034cat >>$CONFIG_STATUS <<_ACEOF
    3003030035ac_cs_version="\\
    30031 SYMPHONY config.status 5.6.14
     30036SYMPHONY config.status 5.6.15
    3003230037configured by $0, generated by GNU Autoconf 2.59,
    3003330038  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
  • releases/5.6.15/SYMPHONY/configure.ac

    r2707 r2707  
    2323AC_PREREQ(2.59)
    2424
    25 AC_INIT([SYMPHONY],[5.6.14],[symphony@list.coin-or.org])
     25AC_INIT([SYMPHONY],[5.6.15],[symphony@list.coin-or.org])
    2626
    2727AC_COPYRIGHT([
     
    6262# externals.  The following macro ensures that those externals are
    6363# retrieved by svn if they are not there yet.
    64 AC_COIN_PROJECTDIR_INIT(SYMPHONY,9:14:6)
     64AC_COIN_PROJECTDIR_INIT(SYMPHONY,9:15:6)
    6565
    6666# Check if user wants to produce debugging code
     
    829829AC_SUBST(SYM_OPENMP_LIBS)
    830830if test $sym_openmp = true; then
    831   SYM_OPENMP_FLAGS=-fopenmp
    832   SYM_OPENMP_LIBS=-lgomp
     831  if test x$coin_cxx_is_cl = xtrue; then
     832    SYM_OPENMP_FLAGS=-openmp
     833    SYM_OPENMP_LIBS=
     834  else
     835    SYM_OPENMP_FLAGS=-fopenmp
     836    SYM_OPENMP_LIBS=-lgomp
     837  fi
    833838else
    834839  SYM_OPENMP_FLAGS=
     
    887892     CXXFLAGS="$CXXFLAGS -TP"
    888893     if test $sym_openmp = true; then
    889          CXXFLAGS="$CXXFLAGS /openmp"
     894         CXXFLAGS="$CXXFLAGS -openmp"
    890895     fi
    891896  ;;
  • releases/5.6.15/SYMPHONY/include/config_sym_default.h

    r2707 r2707  
    66
    77/* Version number of project */
    8 #define SYMPHONY_VERSION "5.6.14"
     8#define SYMPHONY_VERSION "5.6.15"
    99
    1010/* Major Version number of project */
     
    1515
    1616/* Release Version number of project */
    17 #define SYMPHONY_VERSION_RELEASE 14
     17#define SYMPHONY_VERSION_RELEASE 15
    1818
    1919
  • releases/5.6.15/SYMPHONY/include/sym_tm.h

    r2707 r2707  
    6060   char            has_ub_estimate;
    6161   double          start_time;
    62    double          ub;       /* the best global upper bound found */
    63    double          lb;       /* the best global lower bound known */
     62   double          ub;         /* the best global upper bound found */
     63   double          lb;         /* the best global lower bound known */
     64   double          printed_lb; /* the lower bound we print for user */
    6465   lp_sol          best_sol;
    6566   double          obj_offset; /* constant to be added to the objective value*/
  • releases/5.6.15/SYMPHONY/include/sym_types.h

    r2707 r2707  
    286286
    287287typedef struct STR_INT{
    288 #ifdef _OPENMP
    289    char      *str;
    290 #else
    291288   char       str[MAX_LINE_LENGTH +1];
    292 #endif
    293289   int        code;
    294290}str_int;
  • releases/5.6.15/SYMPHONY/src/LP/lp_branch.c

    r2707 r2707  
    272272      int *bnd_ind = lp_data->tmp2.i1; //(int *)malloc (2*lp_data->n*ISIZE);
    273273      char *bnd_sense = lp_data->tmp2.c; //(char *)malloc (2*lp_data->n*CSIZE);
    274       int *up_violation_cnt = NULL, *down_violation_cnt = NULL, *violation_col_size = NULL;             
     274      int *up_violation_cnt = NULL, *down_violation_cnt = NULL;
     275      int *violation_col_size = NULL;             
    275276      int num_bnd_changes = 0;
    276277      double xval, floorx, ceilx, var_score;
    277       int full_solves = 0, down_is_est, up_is_est, best_down_is_est, best_up_is_est,
     278      int full_solves = 0, down_is_est, up_is_est, best_down_is_est,
     279          best_up_is_est,
    278280          max_solves_since_impr = p->par.rel_br_cand_threshold,
    279281          stop_solving = FALSE, both_children_inf = FALSE, rel_up,
    280          rel_down, solves_since_impr = 0, best_one_child_inf = FALSE;
     282          rel_down, solves_since_impr = 0, best_one_child_inf = FALSE;
    281283      int max_solves = p->par.rel_br_max_solves;
    282284      double alpha = p->par.strong_branching_high_low_weight;
     
    295297
    296298      // experimental - node-presolve
    297       if(p->par.use_branching_prep && cand_num > 1){
     299      if (p->par.use_branching_prep && cand_num > 1){
    298300         //prep_tighten_bounds(lp_data, &num_bnd_changes, bnd_val, bnd_ind, bnd_sense,
    299301         //         row_ub, row_lb, &cand_fixed);
     
    20132015   node_desc *desc;
    20142016   int termcode;
    2015    bc_node *node = p->tm->active_nodes[p->proc_index];
    2016    branch_obj *bobj = &node->bobj;
    2017    
     2017#if defined(DO_TESTS) && defined(COMPILE_IN_LP)
     2018   branch_obj *bobj = &(p->tm->active_nodes[p->proc_index]->bobj);
     2019#endif
     2020
    20182021   termcode = select_branching_object(p, &cuts, &can);
    20192022   
     
    20532056      should dive */
    20542057   p->comp_times.strong_branching += used_time(&p->tt);
     2058   /* 'keep' may be modified if children are pruned, but we need the original
     2059      value */
     2060   int old_keep = keep;
    20552061   send_branching_info(p, can, action, &keep);
    20562062   p->comp_times.communication += used_time(&p->tt);
     
    20622068   }
    20632069
     2070#if defined(DO_TESTS) && defined(COMPILE_IN_LP)
     2071   assert(can->rhs[old_keep] == bobj->rhs[keep]);
     2072#endif
     2073   
    20642074   desc = p->desc;
    2065    switch (bobj->type){
     2075   switch (can->type){
    20662076    case CANDIDATE_VARIABLE:
    2067       p->branch_var = bobj->position;
    2068       p->branch_dir = bobj->sense[keep];
    2069       var = lp_data->vars[branch_var = bobj->position];
    2070       switch (bobj->sense[keep]){
     2077      p->branch_var = can->position;
     2078      p->branch_dir = can->sense[old_keep];
     2079      var = lp_data->vars[branch_var = can->position];
     2080      switch (can->sense[old_keep]){
    20712081       case 'E':
    2072          var->new_lb = var->new_ub = bobj->rhs[keep];
    2073          var->lb = var->ub = bobj->rhs[keep];                             break;
     2082         var->new_lb = var->new_ub = can->rhs[old_keep];
     2083         var->lb = var->ub = can->rhs[old_keep];                             break;
    20742084       case 'R':
    2075          var->new_lb = bobj->rhs[keep];
    2076          var->new_ub = var->lb + bobj->range[keep];
    2077          var->lb = bobj->rhs[keep]; var->ub = var->lb + bobj->range[keep]; break;
     2085         var->new_lb = can->rhs[old_keep];
     2086         var->new_ub = var->lb + can->range[old_keep];
     2087         var->lb = can->rhs[old_keep]; var->ub = var->lb + can->range[old_keep]; break;
    20782088       case 'L':
    2079          var->new_ub = bobj->rhs[keep];
    2080          var->ub = bobj->rhs[keep];                                       break;
     2089         var->new_ub = can->rhs[old_keep];
     2090         var->ub = can->rhs[old_keep];                                       break;
    20812091       case 'G':
    2082          var->new_lb = bobj->rhs[keep];
    2083          var->lb = bobj->rhs[keep];                                       break;
    2084       }
    2085       //printf("branching on %i %c %f %f\n", branch_var, bobj->sense[keep], var->lb, var->ub);
    2086       change_col(lp_data, branch_var, bobj->sense[keep], var->lb, var->ub);
     2092         var->new_lb = can->rhs[old_keep];
     2093         var->lb = can->rhs[old_keep];                                       break;
     2094      }
     2095      //printf("branching on %i %c %f %f\n", branch_var, can->sense[old_keep], var->lb, var->ub);
     2096      change_col(lp_data, branch_var, can->sense[old_keep], var->lb, var->ub);
    20872097      lp_data->status[branch_var] |= VARIABLE_BRANCHED_ON;
    20882098      break;
    20892099    case SOS1_IMPLICIT:
    2090       for(int j = 0; j < bobj->sos_cnt[keep]; j++){
    2091          branch_var = bobj->sos_ind[keep][j];
     2100      for(int j = 0; j < can->sos_cnt[old_keep]; j++){
     2101         branch_var = can->sos_ind[old_keep][j];
    20922102         change_ub(lp_data, branch_var, 0.0);
    20932103         lp_data->vars[branch_var]->new_ub = 0.0;
     
    20992109      break;
    21002110    case CANDIDATE_CUT_IN_MATRIX:
    2101       branch_row = bobj->position;
     2111      branch_row = can->position;
    21022112      cut = lp_data->rows[branch_row].cut;
    21032113      /* To maintain consistency with TM we have to fix a few more things if
     
    21632173         }
    21642174      }
    2165       cut->rhs = bobj->rhs[keep];
    2166       if ((cut->sense = bobj->sense[keep]) == 'R')
    2167          cut->range = bobj->range[keep];
    2168       cut->branch = CUT_BRANCHED_ON | bobj->branch[keep];
     2175      cut->rhs = can->rhs[old_keep];
     2176      if ((cut->sense = can->sense[old_keep]) == 'R')
     2177         cut->range = can->range[old_keep];
     2178      cut->branch = CUT_BRANCHED_ON | can->branch[old_keep];
    21692179      constrain_row_set(lp_data, 1, &branch_row);
    21702180      lp_data->rows[branch_row].free = FALSE;
  • releases/5.6.15/SYMPHONY/src/LP/lp_genfunc.c

    r2707 r2707  
    462462         }else{ /* optimal and not too high cost */
    463463#ifdef COMPILE_IN_LP
     464#ifdef DO_TESTS
     465            if (lp_data->objval < p->tm->lb - .001 && p->bc_index > 0){
     466               printf("#####Warning: lower bound corruption detected\n");
     467            }
     468#endif
    464469            p->tm->active_nodes[p->proc_index]->lower_bound = lp_data->objval;
    465470            if (p->node_iter_num < 2 && p->bc_index > 0 &&
  • releases/5.6.15/SYMPHONY/src/LP/lp_proccomm.c

    r2707 r2707  
    519519      tm->active_nodes[p->proc_index];
    520520   node_desc *tm_desc = &n->desc;   
     521#ifdef DO_TESTS
     522   if (n->bc_index && (n->lower_bound < p->tm->lb - .001 ||
     523                       n->lower_bound < n->parent->lower_bound - .001)){
     524      printf("#####Warning: lower bound decrease detected\n");
     525      printf("     From parent: %f\n", n->parent->lower_bound - n->lower_bound);
     526      printf("     From global: %f\n", p->tm->lb - n->lower_bound);
     527   }
     528#endif
     529
    521530   p->tm->stat.analyzed++;
    522531   
     
    656665      n->node_status = (node_type == TIME_LIMIT ?
    657666                        NODE_STATUS__TIME_LIMIT:NODE_STATUS__ITERATION_LIMIT);
    658       n->lower_bound = lp_data->objval;
     667      //I think lp_data->objval is the latest objective value from branching subproblem
     668      //here and thus is not valid
     669      //n->lower_bound = lp_data->objval;
    659670      insert_new_node(tm, n);
    660671      if (!repricing)
     
    664675   if (!repricing || n->node_status != NODE_STATUS__PRUNED){
    665676
    666       n->lower_bound = lp_data->objval;
     677#ifdef DO_TESTS
     678      if (n->bc_index && (n->lower_bound < p->tm->lb - .001 ||
     679                          n->lower_bound < n->parent->lower_bound - .001)){
     680         printf("#####Warning: lower bound decrease detected\n");
     681         printf("     From parent: %f\n", n->parent->lower_bound - n->lower_bound);
     682         printf("     From global: %f\n", p->tm->lb - n->lower_bound);
     683      }
     684#endif
     685      //I think lp_data->objval is the latest objective value from branching subproblem
     686      //here and thus is not valid
     687      //n->lower_bound = lp_data->objval;
    667688
    668689      new_lp_desc = create_explicit_node_desc(p);
     
    15841605      }while (! r_bufid);
    15851606      receive_char_array(&dive, 1);
     1607      receive_int_array(keep, 1);
    15861608      /* get the new nodenum (and the index of the branching cut if unknown)
    15871609       * if we dive */
  • releases/5.6.15/SYMPHONY/src/LP/lp_solver.c

    r2707 r2707  
    26182618         get_slacks(lp_data);
    26192619      }
     2620     
    26202621      get_x(lp_data);
    26212622     
     
    27292730      get_x(lp_data);
    27302731     
     2732#ifdef CHECK_DUAL_SOLUTION
     2733      if (term == LP_D_INFEASIBLE || term == LP_OPTIMAL) {
     2734        //This code checks the dual solution values
     2735        int t;
     2736        double intercept = 0;
     2737        double lb = 0;
     2738       
     2739        for (t=0; t < lp_data->n; t++){
     2740          intercept += lp_data->x[t]* lp_data->dj[t];
     2741        }
     2742        for (int i = 0; i <lp_data->m; i++){
     2743          if (si->getRowUpper()[i] < 1000000){
     2744            lb += si->getRowUpper()[i]*lp_data->dualsol[i];
     2745          }else{
     2746            lb += si->getRowLower()[i]*lp_data->dualsol[i];
     2747          }
     2748        }
     2749       
     2750        if (fabs(intercept + lb - lp_data->objval) > 0.1){
     2751          write_mps(lp_data, "lp.assert");
     2752        }
     2753       
     2754        assert(fabs(intercept + lb - lp_data->objval) <= 0.1);
     2755      }
     2756#endif
     2757     
    27312758      lp_data->lp_is_modified = LP_HAS_NOT_BEEN_MODIFIED;
    27322759   }   
     
    27972824      get_x(lp_data);
    27982825     
     2826#ifdef CHECK_DUAL_SOLUTION
     2827      if (term == LP_D_INFEASIBLE || term == LP_OPTIMAL) {
     2828        //This code checks the dual solution values
     2829        int t;
     2830        double intercept = 0;
     2831        double lb = 0;
     2832       
     2833        for (t=0; t < lp_data->n; t++){
     2834          intercept += lp_data->x[t]* lp_data->dj[t];
     2835        }
     2836        for (int i = 0; i <lp_data->m; i++){
     2837          if (si->getRowUpper()[i] < 1000000){
     2838            lb += si->getRowUpper()[i]*lp_data->dualsol[i];
     2839          }else{
     2840            lb += si->getRowLower()[i]*lp_data->dualsol[i];
     2841          }
     2842        }
     2843       
     2844        if (fabs(intercept + lb - lp_data->objval) > 0.1){
     2845          write_mps(lp_data, "lp.assert");
     2846        }
     2847       
     2848        assert(fabs(intercept + lb - lp_data->objval) <= 0.1);
     2849      }
     2850#endif
     2851       
    27992852      lp_data->lp_is_modified = LP_HAS_NOT_BEEN_MODIFIED;
    28002853   }   
     
    30273080void get_dj_pi(LPdata *lp_data)
    30283081{
     3082   const double * pi;
     3083   const CoinPackedMatrix * matrix = lp_data->si->getMatrixByCol();
     3084   const int * row = matrix->getIndices();
     3085   const int * columnLength = matrix->getVectorLengths();
     3086   const CoinBigIndex * columnStart = matrix->getVectorStarts();
     3087   const double * elementByColumn = matrix->getElements();
     3088   const double * objective = lp_data->si->getObjCoefficients();
     3089   const double * lower = lp_data->si->getColLower();
     3090   const double * upper = lp_data->si->getColUpper();
     3091   double * dj = lp_data->dj;
     3092   int numberColumns = lp_data->n;
     3093   int t;
    30293094   memcpy(lp_data->dualsol, lp_data->si->getRowPrice(), lp_data->m * DSIZE);
    3030    memcpy(lp_data->dj, lp_data->si->getReducedCost(), lp_data->n * DSIZE);
     3095   pi=lp_data->dualsol;
     3096   memcpy(dj, lp_data->si->getReducedCost(), lp_data->n * DSIZE);
     3097   /* djs may not be correct on fixed variables */
     3098   /* fix assumes minimization */
     3099   for (t=0; t < numberColumns; t++) {
     3100     if (lower[t] == upper[t]) {
     3101       int k;
     3102       double value=objective[t];
     3103       for (k=columnStart[t];k<columnStart[t]+columnLength[t];k++) {
     3104         int iRow=row[k];
     3105         value -= elementByColumn[k]*pi[iRow];
     3106       }
     3107       dj[t] = value;
     3108     }
     3109   }
    30313110}
    30323111
  • releases/5.6.15/SYMPHONY/src/Master/master.c

    r2707 r2707  
    219219   env->ub = 0;
    220220   env->has_ub = FALSE;
    221    env->lb = -MAXDOUBLE;
     221   env->lb = -SYM_INFINITY;
    222222   env->termcode = TM_NO_PROBLEM;
    223223   env->par.verbosity = 0;
  • releases/5.6.15/SYMPHONY/src/Master/master_io.c

    r2707 r2707  
    852852      printf("  Primal Heuristics         %.3f\n", tim->primal_heur);
    853853      printf("  Communication             %.3f\n", tim->communication);
    854 #ifndef COMPILE_IN_LP
    855854      printf("=================== Parallel Overhead ======================\n");
    856855      printf("  Communication         %.3f\n", tim->communication);
    857856      printf("  Ramp Up Time (TM)     %.3f\n", tim->ramp_up_tm);
     857#ifndef COMPILE_IN_LP
    858858      printf("  Ramp Up Time (LP)     %.3f\n", tim->ramp_up_lp);
     859#endif
    859860      printf("  Ramp Down Time        %.3f\n", tim->ramp_down_time);
     861#ifndef COMPILE_IN_LP
    860862      printf("  Idle Time (Node Pack) %.3f\n", tim->start_node);
    861863      printf("  Idle Time (Nodes)     %.3f\n", tim->idle_node);
  • releases/5.6.15/SYMPHONY/src/TreeManager/tm_func.c

    r2707 r2707  
    394394 
    395395            if (ramp_up){
    396                ramp_up_tm += (wall_clock(NULL) -
    397                                 no_work_start) * (tm->lp.free_num + 1);
     396               ramp_up_tm = wall_clock(NULL) - start_time;
    398397            }
    399398            if (ramp_down){
    400                ramp_down_time += (wall_clock(NULL) -
    401                                   no_work_start) * (tm->lp.free_num + 1);
     399               ramp_down_time += wall_clock(NULL) - no_work_start;
    402400            }
    403401               
    404             if (!tm->lp.free_num){
     402#ifdef COMPILE_IN_LP
     403            if (tm->active_node_num >= tm->par.max_active_nodes-1){
     404#else
     405            if (!tm->lp.free_num){
     406#endif
    405407               ramp_down = FALSE;
    406408               ramp_up = FALSE;
     409               //printf("Ramp-up %f %d %d\n", ramp_up_tm, tm->par.max_active_nodes, tm->active_node_num);
    407410            }else if (ramp_up){
    408411               no_work_start = wall_clock(NULL);
     
    743746#endif
    744747
    745 #ifdef _OPENMP
    746    int thread_num = omp_get_thread_num();
    747 #else
    748    int thread_num = 0;
    749 #endif
    750 
    751748   if (tm->par.output_mode > 0) {
    752749     if (tm->stat.print_stats_cnt < 1 || tm->par.verbosity > 1) {
     
    787784     if (tm->lb > -SYM_INFINITY) {
    788785       if (tm->obj_sense == SYM_MAXIMIZE) {
    789          obj_ub = -tm->lb + tm->obj_offset;
     786         obj_ub = -tm->printed_lb + tm->obj_offset;
    790787         printf("%19.2f ", obj_ub);
    791788       } else {
    792          obj_lb = tm->lb + tm->obj_offset;
     789         obj_lb = tm->printed_lb + tm->obj_offset;
    793790         printf("%19.2f ", obj_lb);
    794791       }
     
    880877      }else{
    881878         PRINT_TIME(tm, f);
    882          fprintf(f, "L %.2f \n", tm->lb);
     879         fprintf(f, "L %.2f \n", tm->printed_lb);
    883880         fclose(f);
    884881      }
    885882   }else if (tm->par.vbc_emulation == VBC_EMULATION_LIVE){
    886       printf("$L %.2f\n", tm->lb);
     883      printf("$L %.2f\n", tm->printed_lb);
    887884   }
    888885
     
    10711068      return(NULL);
    10721069
     1070#ifdef DO_TESTS
     1071   for (int i = tm->samephase_candnum; i >= 1; i--){
     1072      //printf("Node %i, LB: %f\n", tm->samephase_cand[i]->bc_index,
     1073      //     tm->samephase_cand[i]->lower_bound);
     1074      if ((2*i <= tm->samephase_candnum &&
     1075           tm->samephase_cand[i]->lower_bound >
     1076           tm->samephase_cand[2*i]->lower_bound) ||
     1077          (2*i+1 <= tm->samephase_candnum &&
     1078           tm->samephase_cand[i]->lower_bound >
     1079           tm->samephase_cand[2*i+1]->lower_bound)){
     1080         printf("#####Warning: heap corruption detected\n");
     1081      }
     1082   }
     1083#endif
     1084
    10731085   best_node = list[1];
    10741086   
     
    11001112   }
    11011113   list[pos] = temp;
     1114
     1115#ifdef DO_TESTS
     1116   for (int i = tm->samephase_candnum; i >= 1; i--){
     1117      //printf("Node %i, LB: %f\n", tm->samephase_cand[i]->bc_index,
     1118      //     tm->samephase_cand[i]->lower_bound);
     1119      if ((2*i <= tm->samephase_candnum &&
     1120           tm->samephase_cand[i]->lower_bound >
     1121           tm->samephase_cand[2*i]->lower_bound) ||
     1122          (2*i+1 <= tm->samephase_candnum &&
     1123           tm->samephase_cand[i]->lower_bound >
     1124           tm->samephase_cand[2*i+1]->lower_bound)){
     1125         printf("#####Warning: heap corruption detected\n");
     1126      }
     1127   }
     1128#endif
     1129
    11021130   return(best_node);
    11031131}
     
    11341162{
    11351163   int pos, ch, size = tm->samephase_candnum;
    1136    bc_node **list;
     1164   bc_node **list = tm->samephase_cand;
    11371165   int rule = tm->par.node_selection_rule;
    1138 
     1166   
     1167#ifdef DO_TESTS
     1168   if (size > 0){
     1169      for (int i = size; i >= 1; i--){
     1170         //printf("Node %i, LB: %f\n", list[i]->bc_index, list[i]->lower_bound);
     1171         if ((2*i <= size && list[i]->lower_bound > list[2*i]->lower_bound) ||
     1172             (2*i+1 <= size && list[i]->lower_bound > list[2*i+1]->lower_bound)){
     1173            printf("#####Warning: heap corruption detected\n");
     1174         }
     1175      }
     1176   }
     1177#endif
     1178   
    11391179   tm->samephase_candnum = pos = ++size;
    11401180
     
    11461186   REALLOC(tm->samephase_cand, bc_node *,
    11471187           tm->samephase_cand_size, size + 1, BB_BUNCH);
     1188
    11481189   list = tm->samephase_cand;
    1149 
     1190   
    11501191   while ((ch=pos>>1) != 0){
    11511192      if (node_compar(tm, rule, list[ch], node)){
     
    11571198   }
    11581199   list[pos] = node;
     1200
     1201#ifdef DO_TESTS
     1202   for (int i = size; i >= 1; i--){
     1203      if ((2*i <= size && list[i]->lower_bound > list[2*i]->lower_bound) ||
     1204          (2*i+1 <= size && list[i]->lower_bound > list[2*i+1]->lower_bound)){
     1205         printf("#####Warning: heap corruption detected\n");
     1206      }
     1207   }
     1208#endif
     1209   
    11591210} /* End critical Region */
    11601211
     
    11731224   int ret_ind = 0;
    11741225
     1226#if 0
    11751227   double n0_rhs, n1_rhs;
    11761228   int n0_ind, n1_ind;
     
    11921244   n0_frac = fabs(node0->parent->bobj.value - n0_rhs);
    11931245   n1_frac = fabs(node1->parent->bobj.value - n1_rhs);
     1246#endif
    11941247   
    11951248   /* solves acc3 without swap
     
    12041257   switch(rule){
    12051258    case LOWEST_LP_FIRST:     
    1206       if(node1->lower_bound < node0->lower_bound - 1e-4) ret_ind = 1;
    1207       else if (node1->lower_bound < node0->lower_bound + 1e-4) {
    1208          if(node1->bc_level > node0->bc_level) ret_ind = 1;
    1209          else if(node1->bc_level == node0->bc_level)
    1210             if(node1->frac_cnt < node0->frac_cnt) ret_ind = 1;
    1211          //if(tm->has_ub){
    1212          // if(node1->bc_level > node0->bc_level) ret_ind = 1;
    1213          // else if(node1->bc_level == node0->bc_level)
    1214          //    if(node1->frac_cnt < node0->frac_cnt) ret_ind = 1;
    1215          //}else
    1216          //  if(node1->frac_cnt < node0->frac_cnt) ret_ind = 1;
    1217          //  else if(node1->frac_cnt == node0->frac_cnt)
    1218          //     if (node1->bc_level > node0->bc_level) ret_ind = 1;
    1219       }
     1259      if(node1->lower_bound < node0->lower_bound) ret_ind = 1;
     1260      //if(node1->lower_bound < node0->lower_bound - 1e-4) ret_ind = 1;
     1261      //else if (node1->lower_bound < node0->lower_bound + 1e-4) {
     1262      // if(node1->bc_level > node0->bc_level) ret_ind = 1;
     1263      // else if(node1->bc_level == node0->bc_level)
     1264      //    if(node1->frac_cnt < node0->frac_cnt) ret_ind = 1;
     1265         ////if(tm->has_ub){
     1266         //// if(node1->bc_level > node0->bc_level) ret_ind = 1;
     1267         //// else if(node1->bc_level == node0->bc_level)
     1268         ////    if(node1->frac_cnt < node0->frac_cnt) ret_ind = 1;
     1269         ////}else
     1270         ////  if(node1->frac_cnt < node0->frac_cnt) ret_ind = 1;
     1271         ////  else if(node1->frac_cnt == node0->frac_cnt)
     1272         ////     if (node1->bc_level > node0->bc_level) ret_ind = 1;
     1273      //}
    12201274      //return(node1->lower_bound < node0->lower_bound ? 1:0);
    12211275      return ret_ind;
     
    13601414      child->bc_level = node->bc_level + 1;
    13611415      child->lower_bound = objval[i];
     1416#ifdef DO_TESTS
     1417      if (child->lower_bound < tm->lb - .001 ||
     1418          child->lower_bound < node->lower_bound - .001){
     1419         printf("#####Warning: lower bound decrease detected after branching\n");
     1420         printf("     From parent: %f\n", node->lower_bound - child->lower_bound);
     1421         printf("     From global: %f\n", tm->lb - child->lower_bound);
     1422      }
     1423#endif
    13621424      child->frac_cnt = node->frac_cnt;
    13631425      child->frac_avg = node->frac_avg;
     
    14591521#endif
    14601522         if (tm->par.keep_description_of_pruned == DISCARD ||
    1461              tm->par.keep_description_of_pruned == KEEP_ON_DISK_VBC_TOOL){
     1523             tm->par.keep_description_of_pruned == KEEP_ON_DISK_VBC_TOOL ||
     1524             tm->par.keep_description_of_pruned == KEEP_ON_DISK_FULL){
    14621525            child->parent = node;
    1463             if (tm->par.keep_description_of_pruned == KEEP_ON_DISK_VBC_TOOL)
     1526            if (tm->par.keep_description_of_pruned != DISCARD)
    14641527#pragma omp critical (write_pruned_node_file)
    14651528               write_pruned_nodes(tm, child);
     
    14771540                  vbc_node_pr_reason = VBC_PRUNED;
    14781541               }
    1479                /* following is no longer needed because this care is taken
    1480                 * care of in install_new_ub
    1481                 */
    1482                /*
    1483                if (feasible[i]) {
    1484                   vbc_node_pr_reason = VBC_FEAS_SOL_FOUND;
    1485                }
    1486                */
    14871542               purge_pruned_nodes(tm, child, vbc_node_pr_reason);
    14881543            } else {
     
    14901545                                  VBC_PRUNED);
    14911546            }
    1492 
    1493             if (--child_num == 0){
    1494                *keep = -1;
    1495                return(DO_NOT_DIVE);
    1496             }
    1497             if (*keep == child_num) *keep = i;
    1498 #ifdef TRACE_PATH
    1499             if (optimal_path == child_num) optimal_path = i;
    1500 #endif
    1501             action[i] = action[child_num];
    1502             objval[i] = objval[child_num];
    1503             feasible[i--] = feasible[child_num];
    1504             continue;
    1505          }
    1506       }else{
    1507          child->node_status = NODE_STATUS__CANDIDATE;
    1508          /* child->lp = child->cg = 0;   zeroed out by calloc */
    1509          child->cp = node->cp;
    1510       }
    1511 
    1512       /* child->children = NULL;   zeroed out by calloc */
    1513       /* child->child_num = 0;   zeroed out by calloc */
    1514       /* child->died = 0;   zeroed out by calloc */
    1515       desc = &child->desc;
    1516       /* all this is set by calloc
    1517        * desc->uind.type = 0;            WRT_PARENT and no change
    1518        * desc->uind.size = 0;
    1519        * desc->uind.added = 0;
    1520        * desc->uind.list = NULL;
    1521        
    1522        * desc->not_fixed.type = 0;       WRT_PARENT and no change
    1523        * desc->not_fixed.size = 0;
    1524        * desc->not_fixed.added = 0;
    1525        * desc->not_fixed.list = NULL;
    1526 
    1527        * desc->cutind.type = 0;          WRT_PARENT and no change
    1528        * desc->cutind.size = 0;
    1529        * desc->cutind.added = 0;
    1530        * desc->cutind.list = NULL;
    1531 
    1532        * desc->basis.basis_exists = FALSE;    This has to be validated!!!
    1533        * desc->basis.{[base,extra][rows,vars]}
    1534                     .type = 0;           WRT_PARENT and no change
    1535                     .size = 0;
    1536                     .list = NULL;
    1537                     .stat = NULL;
    1538        */
    1539 
    1540       if (node->desc.basis.basis_exists){
    1541          desc->basis.basis_exists = TRUE;
    1542       }
    1543 
    1544       /* If we have a non-base, new branching cut then few more things
    1545          might have to be fixed */
    1546       if (new_branching_cut && bobj->name >= 0){
    1547          /* Fix cutind and the basis description */
    1548          desc->cutind.size = 1;
    1549          desc->cutind.added = 1;
    1550          desc->cutind.list = (int *) malloc(ISIZE);
    1551          desc->cutind.list[0] = bobj->name;
    1552          if (desc->basis.basis_exists){
    1553             desc->basis.extrarows.size = 1;
    1554             desc->basis.extrarows.list = (int *) malloc(ISIZE);
    1555             desc->basis.extrarows.list[0] = bobj->name;
    1556             desc->basis.extrarows.stat = (int *) malloc(ISIZE);
    1557             desc->basis.extrarows.stat[0] = SLACK_BASIC;
    1558          }
    1559       }
    1560 
    1561       desc->desc_size = node->desc.desc_size;
    1562       desc->desc = node->desc.desc;
    1563       desc->nf_status = node->desc.nf_status;
    1564 
    1565 
    1566 #ifdef SENSITIVITY_ANALYSIS
    1567       if (tm->par.sensitivity_analysis &&
    1568           action[i] != PRUNE_THIS_CHILD_INFEASIBLE){
    1569          child->duals = bobj->duals[i];
    1570          bobj->duals[i] = 0;
    1571       }
    1572 #endif
    1573 
    1574       if (child->node_status != NODE_STATUS__PRUNED && feasible[i]){
    1575          if(tm->par.keep_description_of_pruned == KEEP_IN_MEMORY){
    1576             child->sol_size = bobj->sol_sizes[i];
    1577             child->sol_ind = bobj->sol_inds[i];
    1578             bobj->sol_inds[i]=0;
    1579             child->sol = bobj->solutions[i];
    1580             bobj->solutions[i] = 0;
    1581             child->feasibility_status = NOT_PRUNED_HAS_CAN_SOLUTION;
    1582          }
    1583       }
    1584      
    1585       if (child->node_status == NODE_STATUS__PRUNED){
    1586 
    1587          if(tm->par.keep_description_of_pruned == KEEP_IN_MEMORY){
    1588          
     1547         }else{ /* tm->par.keep_description_of_pruned == KEEP_IN_MEMORY */
    15891548            child->feasibility_status = OVER_UB_PRUNED;   
    1590            
    15911549            if (feasible[i]){
    15921550               child->sol_size = bobj->sol_sizes[i];
     
    15971555               child->feasibility_status = FEASIBLE_PRUNED;                 
    15981556            }
    1599 
    16001557            if (action[i] == PRUNE_THIS_CHILD_INFEASIBLE){
    16011558               child->feasibility_status = INFEASIBLE_PRUNED;
    16021559            }
    16031560         }
    1604 
     1561      }else{
     1562         child->node_status = NODE_STATUS__CANDIDATE;
     1563         /* child->lp = child->cg = 0;   zeroed out by calloc */
     1564         child->cp = node->cp;
     1565         if (feasible[i]){
     1566            if(tm->par.keep_description_of_pruned == KEEP_IN_MEMORY){
     1567               child->sol_size = bobj->sol_sizes[i];
     1568               child->sol_ind = bobj->sol_inds[i];
     1569               bobj->sol_inds[i]=0;
     1570               child->sol = bobj->solutions[i];
     1571               bobj->solutions[i] = 0;
     1572               child->feasibility_status = NOT_PRUNED_HAS_CAN_SOLUTION;
     1573            }
     1574         }
     1575      }
     1576
     1577      if (child->node_status == NODE_STATUS__CANDIDATE ||
     1578          tm->par.keep_description_of_pruned != DISCARD){
     1579         desc = &child->desc;
     1580         
     1581         if (node->desc.basis.basis_exists){
     1582            desc->basis.basis_exists = TRUE;
     1583         }
     1584         
     1585         /* If we have a non-base, new branching cut then few more things
     1586            might have to be fixed */
     1587         if (new_branching_cut && bobj->name >= 0){
     1588            /* Fix cutind and the basis description */
     1589            desc->cutind.size = 1;
     1590            desc->cutind.added = 1;
     1591            desc->cutind.list = (int *) malloc(ISIZE);
     1592            desc->cutind.list[0] = bobj->name;
     1593            if (desc->basis.basis_exists){
     1594               desc->basis.extrarows.size = 1;
     1595               desc->basis.extrarows.list = (int *) malloc(ISIZE);
     1596               desc->basis.extrarows.list[0] = bobj->name;
     1597               desc->basis.extrarows.stat = (int *) malloc(ISIZE);
     1598               desc->basis.extrarows.stat[0] = SLACK_BASIC;
     1599            }
     1600         }
     1601         
     1602         desc->desc_size = node->desc.desc_size;
     1603         desc->desc = node->desc.desc;
     1604         desc->nf_status = node->desc.nf_status;
     1605         
     1606#ifdef SENSITIVITY_ANALYSIS
     1607         if (tm->par.sensitivity_analysis &&
     1608             action[i] != PRUNE_THIS_CHILD_INFEASIBLE){
     1609            child->duals = bobj->duals[i];
     1610            bobj->duals[i] = 0;
     1611         }
     1612#endif
     1613      }
     1614
     1615      if (child->node_status == NODE_STATUS__PRUNED){
     1616         if (--child_num == 0){
     1617            *keep = -1;
     1618            return(DO_NOT_DIVE);
     1619         }
     1620         if (*keep == child_num){
     1621            *keep = i;
     1622         }else if (*keep == i){
     1623            /*We pruned the child we were supposed to keep*/
     1624            dive = DO_NOT_DIVE;
     1625         }
    16051626#ifdef TRACE_PATH
    1606          if (child->optimal_path){
    1607             printf("\n\nAttempting to prune the optimal path!!!!!!!!!\n\n");
    1608             sleep(600);
    1609             if (tm->par.logging){
    1610                write_tm_info(tm, tm->par.tree_log_file_name, NULL, FALSE);
    1611                write_subtree(tm->rootnode, tm->par.tree_log_file_name, NULL,
    1612                              TRUE, tm->par.logging);
    1613                write_tm_cut_list(tm, tm->par.cut_log_file_name, FALSE);
    1614             }
    1615             exit(1);
    1616          }
    1617 #endif
    1618          if (tm->par.keep_description_of_pruned == KEEP_ON_DISK_FULL ||
    1619              tm->par.keep_description_of_pruned == KEEP_ON_DISK_VBC_TOOL){
    1620 #pragma omp critical (write_pruned_node_file)
    1621             write_pruned_nodes(tm, child);
    1622 #pragma omp critical (tree_update)
    1623             if (tm->par.vbc_emulation== VBC_EMULATION_FILE_NEW) {
    1624                int vbc_node_pr_reason;
    1625                switch (action[i]) {
    1626                 case PRUNE_THIS_CHILD_INFEASIBLE:
    1627                   vbc_node_pr_reason = VBC_PRUNED_INFEASIBLE;
    1628                   break;
    1629                 case PRUNE_THIS_CHILD_FATHOMABLE:
    1630                   vbc_node_pr_reason = VBC_PRUNED_FATHOMED;
    1631                   break;
    1632                 default:
    1633                   vbc_node_pr_reason = VBC_PRUNED;
    1634                }
    1635                /* following is no longer needed because this care is taken
    1636                 * care of in install_new_ub
    1637                 */
    1638                /*
    1639                   if (feasible[i]) {
    1640                   vbc_node_pr_reason = VBC_FEAS_SOL_FOUND;
    1641                }
    1642                */
    1643                purge_pruned_nodes(tm, child, vbc_node_pr_reason);
    1644             } else {
    1645                purge_pruned_nodes(tm, child, feasible[i] ? VBC_FEAS_SOL_FOUND :
    1646                                   VBC_PRUNED);
    1647             }
    1648 
    1649             if (--child_num == 0){
    1650                *keep = -1;
    1651                return(DO_NOT_DIVE);
    1652             }
    1653             if (*keep == child_num) *keep = i;
    1654 #ifdef TRACE_PATH
    1655             if (optimal_path == child_num) optimal_path = i;
    1656 #endif
    1657             action[i] = action[child_num];
    1658             objval[i] = objval[child_num];
    1659             feasible[i--] = feasible[child_num];
    1660          }
     1627         if (optimal_path == child_num){
     1628            optimal_path = i;
     1629         }
     1630#endif
     1631         action[i] = action[child_num];
     1632         objval[i] = objval[child_num];
     1633         feasible[i--] = feasible[child_num];
    16611634         continue;
    16621635      }
     
    39243897int find_tree_lb(tm_prob *tm)
    39253898{
    3926    double lb = MAXDOUBLE;
     3899   double lb = -SYM_INFINITY;
    39273900   bc_node **samephase_cand;
    39283901
     
    39333906         if (tm->par.node_selection_rule == LOWEST_LP_FIRST) {
    39343907            lb = tm->samephase_cand[1]->lower_bound; /* [0] is a dummy */
     3908#ifdef DO_TESTS
     3909            for (int i = tm->samephase_candnum; i >= 1; i--){
     3910               //printf("Node %i, LB: %f\n", tm->samephase_cand[i]->bc_index,
     3911               //     tm->samephase_cand[i]->lower_bound);
     3912               if ((2*i <= tm->samephase_candnum &&
     3913                    tm->samephase_cand[i]->lower_bound >
     3914                    tm->samephase_cand[2*i]->lower_bound) ||
     3915                   (2*i+1 <= tm->samephase_candnum &&
     3916                    tm->samephase_cand[i]->lower_bound >
     3917                    tm->samephase_cand[2*i+1]->lower_bound)){
     3918                  printf("#####Warning: heap corruption detected\n");
     3919               }
     3920            }
     3921#endif
    39353922         } else {
    39363923            samephase_cand = tm->samephase_cand;
     
    39563943   }
    39573944   */
     3945#ifdef DO_TESTS
     3946   if (lb < tm->lb - .001 && tm->stat.analyzed > 1){
     3947      printf("#####Warning: global lower bound decrease detected: %f\n",
     3948             tm->lb - lb);
     3949   }
     3950#endif
    39583951   tm->lb = lb;
    3959  }
     3952   // In parallel execution, the lower bound can be slightly non-monotonic in rare
     3953   // circumstances. This is algorithmically expected, but we keep the bound in the output
     3954   // non-monotonic because this is what the user expects.
     3955   if (tm->stat.analyzed <= 1 || tm->printed_lb >= SYM_INFINITY){
     3956      tm->printed_lb = lb;
     3957   }else{
     3958      tm->printed_lb = MAX(lb, tm->printed_lb);
     3959   }
     3960}
    39603961   return 0;
    39613962}
  • releases/5.6.15/SYMPHONY/src/TreeManager/tm_proccomm.c

    r2707 r2707  
    701701#ifdef DO_TESTS
    702702   if (n->lower_bound < old_lower_bound - 10){
    703       printf("#####Error: lower bound descrease in node from %.3f to %.3f\n",
     703      printf("#####Error: lower bound decrease in node from %.3f to %.3f\n",
    704704             old_lower_bound, n->lower_bound);
    705705   }
     
    973973      ch = (char) dive;
    974974      send_char_array(&ch, 1);
     975      send_int_array(&keep, 1);
    975976      if (dive == DO_DIVE || dive == CHECK_BEFORE_DIVE){
    976977         /* Give the index of the node kept and also the index of the
  • releases/5.6.15/appveyor.yml

    r2707 r2707  
    44environment:
    55  global:
    6     MSYS2_BASEVER: 20150512
    7     MSYS2_ARCH: x86_64
     6    BINTRAY_API:
     7      secure: a9n4jf90wlFCdaYa6fOmYxsF97ur2dnK8Ys3gn5R90JBzTDq6cD2GlEwmmts75mq
     8    BINTRAY_USERNAME: tkralphs
     9    BINTRAY_API:
     10      secure: a9n4jf90wlFCdaYa6fOmYxsF97ur2dnK8Ys3gn5R90JBzTDq6cD2GlEwmmts75mq
     11    BINTRAY_USERNAME: tkralphs
    812  matrix:
    9     - HOST_ARCH_ARG: --host=x86_64-w64-mingw32
     13    - ARCH: win32-msvc9
     14      HOST_ARCH_ARG: --enable-msvc=MD
    1015      ADD_PATH: /mingw64/bin
    11     - HOST_ARCH_ARG: --host=i686-w64-mingw32
     16    - ARCH: win32-msvc12
     17      HOST_ARCH_ARG: --enable-msvc
     18      ADD_PATH: /mingw64/bin
     19    - ARCH: win32-msvc14
     20      HOST_ARCH_ARG: --enable-msvc
     21      ADD_PATH: /mingw64/bin
     22    - ARCH: x86_64-w64-mingw32
     23      HOST_ARCH_ARG: --host=x86_64-w64-mingw32
     24      ADD_PATH: /mingw64/bin
     25    - ARCH: i686-w64-mingw32
     26      HOST_ARCH_ARG: --host=i686-w64-mingw32
    1227      ADD_PATH: /mingw32/bin
    13     - HOST_ARCH_ARG: --enable-msvc
    14       ADD_PATH: /mingw64/bin
    15      
    1628
    1729install:
    18   - C:\"Program Files (x86)\Microsoft Visual Studio 12.0\VC\vcvarsall.bat"
     30  - for /f "delims=" %%i in ('C:\msys64\usr\bin\bash -lc "if [ $APPVEYOR_REPO_BRANCH = 'master' ]; then echo 'trunk'; else echo $APPVEYOR_REPO_BRANCH | cut -d "/" -f 2; fi"') do set VERSION=%%i
     31  - echo %VERSION%
     32  - IF %ARCH%==win32-msvc9 (CALL C:\"Program Files (x86)\Microsoft Visual Studio 9.0\VC\vcvarsall.bat")
     33  - IF %ARCH%==win32-msvc12 (CALL C:\"Program Files (x86)\Microsoft Visual Studio 12.0\VC\vcvarsall.bat")
     34  - IF %ARCH%==win32-msvc14 (CALL C:\"Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat")
    1935  - C:\msys64\usr\bin\bash -lc ""
    20   - C:\msys64\usr\bin\bash -lc "pacman --noconfirm -S make wget tar patch dos2unix diffutils ca-certificates mingw-w64-i686-ca-certificates mingw-w64-x86_64-ca-certificates mingw-w64-i686-gcc mingw-w64-i686-gcc-fortran mingw-w64-x86_64-gcc mingw-w64-x86_64-gcc-fortran"
    2136
    2237build_script:
    23   - C:\msys64\usr\bin\bash -lc "cd $APPVEYOR_BUILD_FOLDER; git clone --branch=stable/0.8 https://github.com/coin-or-tools/BuildTools"
     38  - C:\msys64\usr\bin\bash -lc "cd $APPVEYOR_BUILD_FOLDER; git clone https://github.com/coin-or-tools/BuildTools"
    2439  - C:\msys64\usr\bin\bash -lc "cd $APPVEYOR_BUILD_FOLDER; BuildTools/get.dependencies.sh fetch --no-third-party"
    2540  - C:\msys64\usr\bin\bash -lc "cd $APPVEYOR_BUILD_FOLDER; patch -p0 < SYMPHONY/Osi.patch"
    26   - C:\msys64\usr\bin\bash -lc "cd $APPVEYOR_BUILD_FOLDER; export PATH=$PATH:$ADD_PATH; BuildTools/get.dependencies.sh build --monolithic --disable-openmp --build=x86_64-w64-mingw32 $HOST_ARCH_ARG --test"
     41  - C:\msys64\usr\bin\bash -lc "cd $APPVEYOR_BUILD_FOLDER; export PATH=$ADD_PATH:$PATH; BuildTools/get.dependencies.sh build --build=x86_64-w64-mingw32 $HOST_ARCH_ARG --verbosity=2 --test"
    2742
     43after_build:
     44  - 7z a -r %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip %APPVEYOR_BUILD_FOLDER%\bin
     45  - 7z a -r %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip %APPVEYOR_BUILD_FOLDER%\include
     46  - 7z a -r %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip %APPVEYOR_BUILD_FOLDER%\lib
     47  - 7z a -r %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip %APPVEYOR_BUILD_FOLDER%\share
     48  - curl -T %APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip -utkralphs:%BINTRAY_API% -H "X-Bintray-Publish:1" -H "X-Bintray-Override:1" https://api.bintray.com/content/coin-or/download/%APPVEYOR_PROJECT_NAME%/%VERSION%/%APPVEYOR_PROJECT_NAME%-%VERSION%-%ARCH%.zip
     49
  • releases/5.6.15/configure

    r2707 r2707  
    22# From configure.ac 0.9.
    33# Guess values for system-dependent variables and create Makefiles.
    4 # Generated by GNU Autoconf 2.59 for SYMPHONY 5.6.14.
     4# Generated by GNU Autoconf 2.59 for SYMPHONY 5.6.15.
    55#
    66# Report bugs to <https://projects.coin-or.org/svn/SYMPHONY/newticket>.
     
    441441PACKAGE_NAME='SYMPHONY'
    442442PACKAGE_TARNAME='symphony'
    443 PACKAGE_VERSION='5.6.14'
    444 PACKAGE_STRING='SYMPHONY 5.6.14'
     443PACKAGE_VERSION='5.6.15'
     444PACKAGE_STRING='SYMPHONY 5.6.15'
    445445PACKAGE_BUGREPORT='https://projects.coin-or.org/svn/SYMPHONY/newticket'
    446446
     
    10451045  # This message is too long to be a string in the A/UX 3.1 sh.
    10461046  cat <<_ACEOF
    1047 \`configure' configures SYMPHONY 5.6.14 to adapt to many kinds of systems.
     1047\`configure' configures SYMPHONY 5.6.15 to adapt to many kinds of systems.
    10481048
    10491049Usage: $0 [OPTION]... [VAR=VALUE]...
     
    11111111if test -n "$ac_init_help"; then
    11121112  case $ac_init_help in
    1113      short | recursive ) echo "Configuration of SYMPHONY 5.6.14:";;
     1113     short | recursive ) echo "Configuration of SYMPHONY 5.6.15:";;
    11141114   esac
    11151115  cat <<\_ACEOF
     
    13261326if $ac_init_version; then
    13271327  cat <<\_ACEOF
    1328 SYMPHONY configure 5.6.14
     1328SYMPHONY configure 5.6.15
    13291329generated by GNU Autoconf 2.59
    13301330
     
    13561356running configure, to aid debugging if configure makes a mistake.
    13571357
    1358 It was created by SYMPHONY $as_me 5.6.14, which was
     1358It was created by SYMPHONY $as_me 5.6.15, which was
    13591359generated by GNU Autoconf 2.59.  Invocation command line was
    13601360
     
    51275127# Define the identity of the package.
    51285128 PACKAGE='symphony'
    5129  VERSION='5.6.14'
     5129 VERSION='5.6.15'
    51305130
    51315131
     
    2287422874cat >&5 <<_CSEOF
    2287522875
    22876 This file was extended by SYMPHONY $as_me 5.6.14, which was
     22876This file was extended by SYMPHONY $as_me 5.6.15, which was
    2287722877generated by GNU Autoconf 2.59.  Invocation command line was
    2287822878
     
    2293222932cat >>$CONFIG_STATUS <<_ACEOF
    2293322933ac_cs_version="\\
    22934 SYMPHONY config.status 5.6.14
     22934SYMPHONY config.status 5.6.15
    2293522935configured by $0, generated by GNU Autoconf 2.59,
    2293622936  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
  • releases/5.6.15/configure.ac

    r2707 r2707  
    2323AC_PREREQ(2.59)
    2424
    25 AC_INIT([SYMPHONY],[5.6.14],[https://projects.coin-or.org/svn/SYMPHONY/newticket])
     25AC_INIT([SYMPHONY],[5.6.15],[https://projects.coin-or.org/svn/SYMPHONY/newticket])
    2626
    2727AC_COPYRIGHT([
Note: See TracChangeset for help on using the changeset viewer.