SCIP Solving Constraint Integer Programs

SCIP

Solving Constraint Integer Programs

About

SCIP is currently one of the fastest non-commercial solvers for mixed integer programming (MIP) and mixed integer nonlinear programming (MINLP). It is also a framework for constraint integer programming and branch-cut-and-price. It allows for total control of the solution process and the access of detailed information down to the guts of the solver.

MIP solver benchmark (1 thread): Shifted geometric mean of results taken from the homepage of Hans Mittelmann (13/Jun/2016). Unsolved or failed instances are accounted for with the time limit of 2 hours.

What is SCIP?

A similar technique is used for solving both Integer Programs and Constraint Programs: the problem is successively divided into smaller subproblems (branching) that are solved recursively.

On the other hand, Integer Programming and Constraint Programming have different strengths: Integer Programming uses LP relaxations and cutting planes to provide strong dual bounds, while Constraint Programming can handle arbitrary (non-linear) constraints and uses propagation to tighten domains of variables.

SCIP is a framework for Constraint Integer Programming oriented towards the needs of Mathematical Programming experts who want to have total control of the solution process and access detailed information down to the guts of the solver. SCIP can also be used as a pure MIP solver or as a framework for branch-cut-and-price.

SCIP is implemented as C callable library and provides C++ wrapper classes for user plugins. It can also be used as a standalone program to solve mixed integer programs given in MPS, LP, flatzinc, CNF, OPB, WBO, PIP, or CIP format. Besides that SCIP can directly read ZIMPL models.

An outline of SCIP and its algorithmic approach can be found in

• Constraint Integer Programming: a New Approach to Integrate CP and MIP
  Tobias Achterberg, Timo Berthold, Thorsten Koch, Kati Wolter
  Integration of AI and OR Techniques in Constraint Programming for Combinatorial Optimization Problems, CPAIOR 2008, LNCS 5015, Pages 6–20, 2008

and in

• SCIP: solving constraint integer programs
  Tobias Achterberg
  Mathematical Programming Computation, Volume 1, Number 1, Pages 1–41, 2009
  

A detailed description of SCIP can be found in

• Constraint Integer Programming
  Tobias Achterberg
  Ph.D. thesis, TU Berlin, July 2007

The nonlinear solving features are described in

• SCIP: Global Optimization of Mixed-Integer Nonlinear Programs in a Branch-and-Cut Framework
  Stefan Vigerske, Ambros Gleixner
  ZIB Report, May 2016

What is the SCIP Optimization Suite?

The SCIP Optimization Suite is a toolbox for generating and solving mixed integer programs. It consists of the following parts:

SCIP	mixed integer (linear and nonlinear) programming solver and constraint programming framework
SoPlex	linear programming solver
ZIMPL	mathematical programming language
UG	parallel framework for mixed integer (linear and nonlinear) programs
GCG	generic branch-cut-and-price solver

The user can easily generate linear programs and mixed integer programs with the modeling language ZIMPL. The resulting model can directly be loaded into SCIP and solved. In the solution process SCIP may use SoPlex as underlying LP solver.

Since all five components are available in source code and free for academic use, they are an ideal tool for academic research purposes and for teaching mixed integer programming.

Download the SCIP Optimization Suite (Linux). Previous releases and versions for different platforms are available here.

Locations of registered SCIP downloads

News

01/Sep/2016	The Java interface is also now availabe on GitHub: JSCIPOpt.
08/Jul/2016	The Python interface has been externalized to GitHub for easier collaboration: PySCIPOpt. We also released a patched Makefile for the SCIP Optimization Suite 3.2.1 necessary to build the updated interface.
25/May/2016	Release of Version 2.1.0 of SCIP-SDP, the mixed-integer semidefinite programming plugin for SCIP, developed at TU Darmstadt.
29/Feb/2016	SCIP version 3.2.1 released The SCIP Optimization Suite 3.2.1 consists of SCIP 3.2.1, SoPlex 2.2.1, ZIMPL 3.3.3, GCG 2.1.1, and UG 0.8.2. For more details, please see the current CHANGELOG. There is also a technical report about new features and improvements in the SCIP Optimization Suite 3.2.
27/Oct/2015	Normaliz in its new release 3.0 uses SCIP for subtasks requiring the solution of Integer Programming problems. Normaliz is a tool for computations in affine monoids, vector configurations, lattice polytopes, and rational cones developed at the University of Osnabrück.
28/Sep/2015	Workshop/Lecture/Winter School "Combinatorial Optimization @ Work" is held at ZIB! Check out the program here (including slides of all presentations).
03/Aug/2015	DSP – new open-source parallel solver for stochastic mixed-integer programming using SCIP
31/Jul/2015	Patched version UG 0.8.1 is released, replacing UG 0.8.0 of the SCIP Optimization Suite 3.2.0.
01/Jul/2015	SCIP version 3.2.0 released (see Release Notes and CHANGELOG). The SCIP Optimization Suite 3.2.0 consists of SCIP 3.2.0, SoPlex 2.2.0, ZIMPL 3.3.3, GCG 2.1.0, and UG 0.8.0.
30/Jun/2015	New Release of SCIP-SDP, the mixed integer semidefinite programming plugin for SCIP, developed at TU Darmstadt.
23/Mar/2015	Windows binaries and libraries available for download.
09/Mar/2015	Upcoming event: Combinatorial Optimization @ Work in Berlin (ZIB) - application deadline: 01/Aug/2015

older news...

18/Dec/2014	SCIP version 3.1.1 released The SCIP Optimization Suite 3.1.1 consists of SCIP 3.1.1, SoPlex 2.0.1, ZIMPL 3.3.2, GCG 2.0.1, and UG 0.7.5. See the CHANGELOG for details.
21/Jul/2014	OPTI toolbox is now available in version 2.10. OPTimization Interface (OPTI) Toolbox is a free MATLAB toolbox for constructing and solving linear, nonlinear, continuous and discrete optimization problems for Windows users. OPTI Toolbox in its current version comes with SCIP 3.0.2.
16/Jul/2014	We are happy to announce our upcoming SCIP workshop from September 30 to October 2, 2014. The workshop provides a forum for current and prospective SCIP users to discuss their applications and share their experience with SCIP.
16/Mar/2014	Windows binaries and libraries of SCIP 3.1.0 available for download.
27/Feb/2014	SCIP version 3.1.0 released (see Release Notes and CHANGELOG). The SCIP Optimization Suite 3.1.0 consists of SCIP 3.1.0, SoPlex 2.0.0, ZIMPL 3.3.2, GCG 2.0.0, and UG 0.7.3.
25/Feb/2014	Website relaunched.
16/Oct/2013	SCIP version 3.0.2 released (bug fix release, see Release Notes and CHANGELOG). The SCIP Optimization Suite 3.0.2 consists of SCIP 3.0.2, SoPlex 1.7.2, and ZIMPL 3.3.1, GCG 1.1.1, and UG 0.7.2.
17/Apr/2013	Released beta-version of SCIP which can solve MIP instances exactly over the rational numbers (based on SCIP 3.0.0). Download the source code and get information here.
18/Jan/2013	Recently, Sonja Mars from TU Darmstadt and Lars Schewe from the University of Erlangen-Nürnberg released an SDP-Package for SCIP.
04/Jan/2013	SCIP version 3.0.1 released (bug fix release, see Release Notes and CHANGELOG). The SCIP Optimization Suite 3.0.1 consists of SCIP 3.0.1, SoPlex 1.7.1, and ZIMPL 3.3.1, GCG 1.1.0, and UG 0.7.1. Happy New Year!
31/Oct/2012	There are some new interfaces to SCIP available: The OPTI project provides a MATLAB interface; on top of this, YALMIP provides a free modeling language; PICOS is a python interface for conic optimization. Thanks to all developers, in particular Jonathan Currie, Johan Löfberg, and Guillaume Sagnol.
18/Aug/2012	The SCIP workshop 2012 will take place at TU Darmstadt on October 8 and 9: further information See you there!
01/Aug/2012	SCIP version 3.0.0 released (see Release Notes and CHANGELOG). The SCIP Optimization Suite 3.0.0 consists of SCIP 3.0.0, SoPlex 1.7.0, ZIMPL 3.3.0, GCG 1.0.0, and UG 0.7.0.
28/Dec/2011	SCIP version 2.1.1 released (bug fix release, see Release Notes and CHANGELOG). The ZIB Optimization Suite 2.1.1 consists of SCIP 2.1.1, SoPlex 1.6.0, and ZIMPL 3.2.0.
31/Oct/2011	SCIP version 2.1.0 released (see Release Notes and CHANGELOG). The ZIB Optimization Suite 2.1.0 consists of SCIP 2.1.0, SoPlex 1.6.0, and ZIMPL 3.2.0.
26/Aug/2011	SCIP version 2.0.2 released (see Release Notes and CHANGELOG).
04/Jan/2011	SCIP version 2.0.1 released (see Release Notes). The ZIB Optimization Suite 2.0.1 consists of SCIP 2.0.1, SoPlex 1.5.0, and ZIMPL 3.1.0
12/Nov/2010	There was a performance issue with the precompiled SCIP 2.0.0 binaries for Windows/PC which were compiled with the compilers cl 15 and Intel 11.1. If you downloaded these binaries before 12/Nov/2010, we recommend to download these binaries again.
30/Sep/2010	SCIP version 2.0.0 released (see Release Notes). The ZIB Optimization Suite 2.0.0 consists of SCIP 2.0.0, SoPlex 1.5.0, and ZIMPL 3.1.0
12/Jan/2010	A bug in the Makefiles of the SCIP examples may cause data loss. The SCIP 1.2.0 tarball in the download section has been patched. We strongly recommend to replace your current SCIP installation. If you have a custom Makefile, please ensure, that the target "clean" is changed as described here.
15/Sep/2009	SCIP version 1.2.0 released (see Release Notes). The ZIB Optimization Suite 1.2.0 consists of SCIP 1.2.0, SoPlex 1.4.2, and ZIMPL 3.0.0
13/Sep/2009	Ryan J. O'Neil provides a SCIP-python interface at http://code.google.com.
04/Jul/2009	The results of the Pseudo-Boolean Competition 2009 are online. SCIP-Soplex participated in twelve categories and scored first eight times, second three times. SCIP-Clp participated in nine categories and scored first five times, second two times. Detailed results.
20/Feb/2009	SoPlex version 1.4.1 and Clp version 1.9.0 have been released. We recommend to upw-150. Some precompiled binaries can be found at the download page.
30/Sep/2008	Version 1.1.0 released.
27/Feb/2008	New SCIP Introduction by Cornelius Schwarz, see further documention.
05/Dec/2007	Upw-150d LP-interface for Mosek, see the download page.
11+12/Oct/2007	SCIP Workshop 2007 (in German).
27/Aug/2007	Version 1.0 released.
21/Aug/2007	Web site relaunched.
19/Jul/2007	Tobias Achterberg finished his PhD thesis, which includes a detailed description of SCIP. You can get it here.
14/May/2007	Tobias Achterberg submitted his PhD thesis. The log files for SCIP 0.90f and SCIP 0.90i of the benchmarks conducted in the thesis are available here and here.
01/Sep/2006	SCIP Version 0.90 released.
11/Aug/2006	Linux binaries linked to CLP 1.03.03 available (contributed by Hans Mittelmann).
11/Jul/2006	MS Visual C++ project files for SCIP 0.82 contributed by Martin C. Mueller.
15/May/2006	SCIP Version 0.82 released.
03/Jan/2006	SCIP Version 0.81 released.
20/Sep/2005	SCIP Version 0.80 released.

Workshop

Every now and then there are SCIP Workshops where developers and users come together to discuss different approaches and implementations. The most recent workshop was held in Berlin from September 30 to October 2, 2014, including an introduction day dedicated for newcomers.

Click here for further information. Sign up for the SCIP mailing list to get notified about future events.

License

SCIP is distributed under the ZIB Academic License. You are allowed to retrieve SCIP for research purposes as a member of a non-commercial and academic institution.
If you want to use SCIP commercially or if you are interested in maintenance and support, please contact us by sending an email to Thorsten Koch.

How To Cite

Any publication for which SCIP is used must include an acknowledgment and a reference to this article:

The SCIP Optimization Suite 3.2
Gamrath et al.
ZIB-Report (15-60)
Bibtex

Download

The files you can download here come without warranty. Use at your own risk!

You can either download SCIP alone or the SCIP Optimization Suite (recommended), a complete source code bundle of SCIP, SoPlex, ZIMPL, GCG, and UG with an easy-to-use Makefile.

You can also download precompiled binaries of SCIP with which you can solve MIP, MIQCP, CIP, SAT, or PBO instances in MPS, LP, RLP, ZIMPL, flatzinc, CNF, OPB, WBO, PIP, or CIP format.
Note that these binaries do not include the readline features (i.e., command line editing and history) due to license issues. However, you can download the free readline wrapper rlwrap to provide this missing feature to the binaries.

Here are the MIPLIB 2010 MPS files assembled as an archive: miplib2010-benchmark.tgz.

• SCIP version 3.2.1
• Source code:
  • SCIP
  • SCIP Optimization Suite
  
  
  Additional files:
  • Makefile.doit: Corrected Makefile.doit for the SCIP Optimization Suite 3.2.1 that makes the generated Linux library libscipopt.so aware of dependencies on third-party libraries.
    Please replace the original file.
  
  
  Libraries:
  • Windows/PC, 32bit, msvc 12.0: with SoPlex 2.2.1, Zimpl 3.3.3, Ipopt 3.12.3, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 32bit, msvc 14.0: with SoPlex 2.2.1, Zimpl 3.3.3, Ipopt 3.12.4, CppAD 20140000.1, MPIR 2.7.2, zlib 1.2.8 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 64bit, msvc 12.0: with SoPlex 2.2.1, Zimpl 3.3.3, Ipopt 3.12.3, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 64bit, msvc 14.0: with SoPlex 2.2.1, Zimpl 3.3.3, Ipopt 3.12.4, CppAD 20140000.1, MPIR 2.7.2, zlib 1.2.8 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 64bit, msvc 12.0: Java Native Interface with SoPlex 2.2.1
  
  
  Binaries:
  • Darwin(Mac)/PC, 64bit, gcc 4.9.2: linked to SoPlex 2.2.1, Zimpl 3.3.3, Ipopt 3.12.4, CppAD cppad-20140000.3, GMP 6.0.0, zlib 1.2.5
  • Linux/PC, 32bit, gcc 4.8.4: statically linked to SoPlex 2.2.1, Zimpl 3.3.3, Ipopt 3.12.0, CppAD 20140000.3, GMP 5.1.3, zlib 1.2.8
  • Linux/PC, 64bit, gcc 4.8.4: statically linked to SoPlex 2.2.1, Zimpl 3.3.3, Ipopt 3.12.0, CppAD 20140000.3, GMP 5.1.3, zlib 1.2.8
  • Windows/PC, 32bit, msvc 12.0: dynamically linked to SoPlex 2.2.1, Zimpl 3.3.3, Ipopt 3.12.3, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 32bit, msvc 12.0: statically linked to SoPlex 2.2.1, Zimpl 3.3.3, Ipopt 3.12.3, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 32bit, msvc 14.0: statically linked to SoPlex 2.2.1, Zimpl 3.3.3, Ipopt 3.12.4, CppAD 20140000.1, MPIR 2.7.2, zlib 1.2.8 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 64bit, msvc 12.0: dynamically linked to SoPlex 2.2.1, Zimpl 3.3.3, Ipopt 3.12.3, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 64bit, msvc 12.0: statically linked to SoPlex 2.2.1, Zimpl 3.3.3, Ipopt 3.12.3, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 64bit, msvc 14.0: statically linked to SoPlex 2.2.1, Zimpl 3.3.3, Ipopt 3.12.4, CppAD 20140000.1, MPIR 2.7.2, zlib 1.2.8 [requires the Visual C++ Redistributable Packages]
  
  
• SCIP version 3.2.0
• Source code:
  • SCIP
  • SCIP Optimization Suite
  
  
  Libraries:
  • Windows/PC, 32bit, msvc 12.0: with SoPlex 2.2.0, Zimpl 3.3.3, Ipopt 3.12.3, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 64bit, msvc 12.0: with SoPlex 2.2.0, Zimpl 3.3.3, Ipopt 3.12.3, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  
  
  Binaries:
  • Linux/PC, 32bit, gcc 4.8.2: statically linked to SoPlex 2.2.0, Zimpl 3.3.3, Ipopt 3.12.0, CppAD 20140000.3, GMP 5.1.3, zlib 1.2.8
  • Linux/PC, 64bit, gcc 4.8.2: statically linked to SoPlex 2.2.0, Zimpl 3.3.3, Ipopt 3.12.0, CppAD 20140000.3, GMP 5.1.3, zlib 1.2.8
  • Windows/PC, 32bit, msvc 12.0: dynamically linked to SoPlex 2.2.0, Zimpl 3.3.3, Ipopt 3.12.3, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 32bit, msvc 12.0: statically linked to SoPlex 2.2.0, Zimpl 3.3.3, Ipopt 3.12.3, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 64bit, msvc 12.0: dynamically linked to SoPlex 2.2.0, Zimpl 3.3.3, Ipopt 3.12.3, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 64bit, msvc 12.0: statically linked to SoPlex 2.2.0, Zimpl 3.3.3, Ipopt 3.12.3, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 64bit, Intel 14.0.5.239: statically linked to SoPlex 2.2.0, Ipopt 3.12.3, CppAD 20140000.1 [SCIP/AMPL binary to use within AMPL]
  
  
• SCIP version 3.1.1
• Source code:
  • SCIP
  • SCIP Optimization Suite
  
  
  Libraries:
  • Windows/PC, 32bit, msvc 10.0: with SoPlex 2.0.1, Zimpl 3.3.2, Ipopt 3.11.7, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 64bit, msvc 12.0: with SoPlex 2.0.1, Zimpl 3.3.2, Ipopt 3.11.7, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  
  
  Binaries:
  • Linux/PC, 32bit, gcc 4.8.2: statically linked to SoPlex 2.0.1, Zimpl 3.3.2, Ipopt 3.12.0, CppAD 20140000.1, GMP 5.1.3, zlib 1.2.8
  • Linux/PC, 64bit, gcc 4.8.2: statically linked to SoPlex 2.0.1, Zimpl 3.3.2, Ipopt 3.12.0, CppAD 20140000.1, GMP 5.1.3, zlib 1.2.8
  • Windows/PC, 32bit, msvc 10.0: dynamically linked to SoPlex 2.0.1, Zimpl 3.3.2, Ipopt 3.11.7, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 32bit, msvc 10.0: statically linked to SoPlex 2.0.1, Zimpl 3.3.2, Ipopt 3.11.7, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 64bit, msvc 12.0: dynamically linked to SoPlex 2.0.1, Zimpl 3.3.2, Ipopt 3.11.7, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 64bit, msvc 10.0: statically linked to SoPlex 2.0.1, Zimpl 3.3.2, Ipopt 3.11.7, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  
  
• SCIP version 3.1.0
• Source code:
  • SCIP
  • SCIP Optimization Suite
  
  
  Libraries:
  • Linux/PC, 32bit, gcc 4.7.2: with SoPlex 2.0.0, Zimpl 3.3.2, Ipopt 3.11.8, CppAD 20140000.1, GMP 5.0.5, zlib 1.2.8
  • Linux/PC, 64bit, gcc 4.7.2: with SoPlex 2.0.0, Zimpl 3.3.2, Ipopt 3.11.8, CppAD 20140000.1, GMP 5.0.5, zlib 1.2.8
  • Windows/PC, 32bit, msvc 12.0: with SoPlex 2.0.0, Zimpl 3.3.2, Ipopt 3.11.7, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 64bit, msvc 12.0: with SoPlex 2.0.0, Zimpl 3.3.2, Ipopt 3.11.7, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  
  
  Binaries:
  • Darwin(Mac)/PC, 64bit, gcc 4.5.3: linked to SoPlex 2.0.0, Zimpl 3.3.2, Ipopt 3.11.7, CppAD 20140101.1
  • Linux/PC, 32bit, gcc 4.8.2: statically linked to SoPlex 2.0.0, Zimpl 3.3.2, Ipopt 3.11.7, CppAD 20140000.1, GMP 5.1.3, zlib 1.2.8
  • Linux/PC, 64bit, gcc 4.8.2: statically linked to SoPlex 2.0.0, Zimpl 3.3.2, Ipopt 3.11.7, CppAD 20140000.1, GMP 5.1.3, zlib 1.2.8
  • Windows/PC, 32bit, msvc 12.0: dynamically linked to SoPlex 2.0.0, Zimpl 3.3.2, Ipopt 3.11.7, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 32bit, msvc 12.0: statically linked to SoPlex 2.0.0, Zimpl 3.3.2, Ipopt 3.11.7, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 64bit, msvc 12.0: dynamically linked to SoPlex 2.0.0, Zimpl 3.3.2, Ipopt 3.11.7, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  • Windows/PC, 64bit, msvc 12.0: statically linked to SoPlex 2.0.0, Zimpl 3.3.2, Ipopt 3.11.7, CppAD 20140000.1, MPIR 2.6.0, zlib 1.2.5 [requires the Visual C++ Redistributable Packages]
  
  
• SCIP version 3.0.2
• Source code:
  • SCIP
  • SCIP Optimization Suite
  
  
  Libraries:
  • Windows/PC, 32bit, vc10: with SoPlex 1.7.2, Zimpl 3.3.1, CppAD 20120101.3
  • Windows/PC, 64bit, vc10: with SoPlex 1.7.2, Zimpl 3.3.1, CppAD 20120101.3
  
  
  Binaries:
  • Darwin(Mac)/PC, 64bit, gcc 4.5.3: linked to SoPlex 1.7.2, Zimpl 3.3.1, Ipopt 3.11.5, CppAD 20120101.3
  • Linux/PC, 32bit, gcc 4.7.2: statically linked to SoPlex 1.7.2, Zimpl 3.3.1, Ipopt 3.11.5, CppAD 20120101.3
  • Linux/PC, 64bit, gcc 4.8.1: statically linked to SoPlex 1.7.2, Zimpl 3.3.1, Ipopt 3.11.0, CppAD 20120101.3
  • Windows/PC, 32bit, cl 16, intel 13.1: statically linked to SoPlex 1.7.2, Ipopt 3.11.5, CppAD 20120101.3
  • Windows/PC, 64bit, intel 13.1: statically linked to SoPlex 1.7.2, Ipopt 3.11.5, CppAD 20120101.3
  • Windows/PC, 32bit, vc10: linked to SoPlex 1.7.2, Zimpl 3.3.1, CppAD 20120101.3
  • Windows/PC, 64bit, vc10: linked to SoPlex 1.7.2, Zimpl 3.3.1, CppAD 20120101.3
  
  
• SCIP version 3.0.1
• Source code:
  • SCIP
  • SCIP Optimization Suite
  
  
  Additional files:
  • lpi_msk.c.gz: updated Mosek interface that compiles with Mosek 7, too
  
  
  Binaries:
  • Darwin(Mac)/PC, 64bit, gcc 4.5.3: linked to SoPlex 1.7.1, Zimpl 3.3.1, Ipopt 3.11.1, CppAD 20120101.3
  • Linux/PC, 32bit, gcc 4.7.2: statically linked to SoPlex 1.7.1, Zimpl 3.3.1, Ipopt 3.10.3, CppAD 20120101.3
  • Linux/PC, 64bit, gcc 4.7.2: statically linked to Clp 1.14.8, Zimpl 3.3.1, Ipopt 3.10.3, CppAD 20120101.3
  • Linux/PC, 64bit, gcc 4.7.2: statically linked to SoPlex 1.7.1, Zimpl 3.3.1, Ipopt 3.10.3, CppAD 20120101.3
  • Windows/PC, 32bit, cl 16, intel 13.1: statically linked to SoPlex 1.7.1, Ipopt 3.11.1, CppAD 20120101.3
  • Windows/PC, 64bit, intel 13.1: statically linked to SoPlex 1.7.1, Ipopt 3.11.1, CppAD 20120101.3
  
  
• SCIP version 3.0.0
• Source code:
  • SCIP
  • SCIP Optimization Suite
  
  
  Libraries:
  • Windows/PC, 32bit, vc10: with SoPlex 1.7.0, Zimpl 3.3.0
  • Windows/PC, 64bit, vc10: with SoPlex 1.7.0, Zimpl 3.3.0
  
  
  Binaries:
  • Darwin(Mac)/PC, 32bit, gcc 4.5.3: linked to SoPlex 1.7.0, CppAD 20120101.3
  • Darwin(Mac)/PC, 32bit, gcc 4.5.3: linked to SoPlex 1.7.0, Zimpl 3.3.0, Ipopt 3.10, CppAD 20120101.3 [updated on 6.8.12]
  • Darwin(Mac)/PC, 64bit, gcc 4.5.3: linked to SoPlex 1.7.0, Zimpl 3.3.0, CppAD 20120101.3 [updated on 3.8.12]
  • Darwin(Mac)/PC, 64bit, gcc 4.5.3: linked to SoPlex 1.7.0, CppAD 20120101.3
  • Darwin(Mac)/PC, 64bit, gcc 4.5.3: linked to SoPlex 1.7.0, Zimpl 3.3.0, Ipopt 3.10, CppAD 20120101.3 [updated on 21.9.12]
  • Darwin(Mac)/PC, 64bit, gnu: linked to SoPlex
  • Linux/PC, 32bit, gcc 4.6.2: statically linked to SoPlex 1.7.0, Zimpl 3.3.0, Ipopt 3.10.2, CppAD 20120101.3
  • Linux/PC, 32bit, gnu: linked to SoPlex
  • Linux/PC, 64bit, gcc 4.7.1: statically linked to Clp 1.14.7, Zimpl 3.3.0, Ipopt 3.10.2, CppAD 20120101.3
  • Linux/PC, 64bit, gcc 4.6.2: statically linked to SoPlex 1.7.0, Zimpl 3.3.0, Ipopt 3.10.2, CppAD 20120101.3
  • Linux/PC, 64bit, gnu: linked to SoPlex
  • Windows/PC, 32bit, cl 16, intel 12.1: statically linked to SoPlex 1.7.0, Ipopt 3.10.2, CppAD 20120101.3
  • Windows/PC, 64bit, intel 12.1: statically linked to SoPlex 1.7.0, Ipopt 3.10.2, CppAD 20120101.3
  • Windows/PC, 32bit, vc10: linked to SoPlex 1.7.0, Zimpl 3.3.0
  • Windows/PC, 64bit, vc10: linked to SoPlex 1.7.0, Zimpl 3.3.0
  
  

older versions...

• SCIP version 2.1.1
• Source code:
  • SCIP
  • ZIB Optimization Suite
  
  
  Libraries:
  • Windows/PC, 32bit, vc10: with SoPlex 1.6.0, Zimpl 3.2.0
  • Windows/PC, 64bit, vc10: with SoPlex 1.6.0, Zimpl 3.2.0
  
  
  Binaries:
  • Darwin(Mac)/PC, 32bit, gcc 4.2.1: statically linked to SoPlex 1.6.0
  • Darwin(Mac)/PC, 64bit, gcc 4.2.1: statically linked to SoPlex 1.6.0
  • Linux/PC, 32bit, gcc 4.5.0: statically linked to SoPlex 1.6.0, Zimpl 3.2.0, Ipopt 3.10.1, CppAD 20110101.5
  • Linux/PC, 64bit, gcc 4.5.1: statically linked to SoPlex 1.6.0, Zimpl 3.2.0, Ipopt 3.10, CppAD 20110101.5
  • Windows/PC, 32bit, cl 15 DEBUG mode: linked to SoPlex 1.6.0, Ipopt 3.10.1, CppAD 20110101.5
  • Windows/PC, 32bit, cl 15: linked to SoPlex 1.6.0, Ipopt 3.10.1, CppAD 20110101.5
  • Windows/PC, 64bit, intel 11.1 DEBUG mode: linked to SoPlex 1.6.0, Ipopt 3.10.1, CppAD 20110101.5
  • Windows/PC, 64bit, intel 11.1: linked to SoPlex 1.6.0, Ipopt 3.10.1, CppAD 20110101.5
  • Windows/PC, 32bit, vc10: linked to SoPlex 1.6.0, Zimpl 3.2.0
  • Windows/PC, 32bit, vc10: linked to SoPlex
  • Windows/PC, 32bit, vc10: linked to SoPlex
  • Windows/PC, 64bit, vc10: linked to SoPlex 1.6.0, Zimpl 3.2.0
  • Windows/PC, 64bit, vc10: linked to SoPlex
  • Windows/PC, 64bit, vc10: linked to SoPlex
  
  
• SCIP version 2.1.0
• Source code:
  • SCIP
  • ZIB Optimization Suite
  
  
  Binaries:
  • Darwin(Mac)/PC, 64bit, gcc 4.5.3: dynamically linked to SoPlex 1.6.0, Zimpl 3.2.0
  • Darwin(Mac)/PC, 64bit, gcc 4.5.3: dynamically linked to SoPlex 1.6.0, Zimpl 3.2.0, Ipopt 3.10.1, CppAD 20110101.5
  • Linux/PC, 32bit, gcc 4.5.0: statically linked to SoPlex 1.6.0, Zimpl 3.2.0, Ipopt 3.10.1, CppAD 20110101.5
  • Linux/PC, 64bit, gcc 4.6.2: statically linked to SoPlex 1.6.0, Zimpl 3.2.0, Ipopt 3.10.1, CppAD 20110101.5
  • Linux/PC, 64bit, intel 12.0.4 20110427: statically linked to SoPlex 1.6.0, Zimpl 3.2.0, Ipopt 3.10.1, CppAD 20110101.5
  • Windows/PC, 32bit, cl 15 DEBUG mode: linked to SoPlex 1.6.0, Ipopt 3.10.1, CppAD 20110101.5
  • Windows/PC, 32bit, cl 15: linked to SoPlex 1.6.0, Ipopt 3.10.1, CppAD 20110101.5
  • Windows/PC, 64bit, intel 11.1 DEBUG mode: linked to SoPlex 1.6.0, Ipopt 3.10.1, CppAD 20110101.5
  • Windows/PC, 64bit, intel 11.1: linked to SoPlex 1.6.0, Ipopt 3.10.1, CppAD 20110101.5
  
  
• SCIP version 2.0.2
• Source code:
  • SCIP
  
  
  Additional files:
  • lp.c.gz: bugfix in lp solve method to avoid lperror -6 in cases where column generation is used in connection with cplex as LP solver
  
  
  Binaries:
  • Darwin(Mac)/PC, 64bit, gcc 4.2.1: dynamically linked to SoPlex 1.5.0, Zimpl 3.1.0
  • Darwin(Mac)/PC, 64bit, gcc 4.2.1: dynamically linked to SoPlex 1.5.0, Zimpl 3.1.0, Ipopt 3.10.0, CppAD 20110101.3
  • Linux/PC, 32bit, gcc 4.5.1: statically linked to SoPlex 1.5.0, Zimpl 3.1.0, Ipopt 3.10.0, CppAD 20110101.3
  • Linux/PC, 64bit, gcc 4.5.1: statically linked to SoPlex 1.5.0, Zimpl 3.1.0, Ipopt 3.10.0, CppAD 20110101.3
  • Windows/PC, 32bit, cl 15: linked to SoPlex 1.5.0, Ipopt 3.10, CppAD 20110101.3
  • Windows/PC, 32bit, intel 11.1: linked to SoPlex 1.5.0, Ipopt 3.10, CppAD 20110101.3
  
  
• SCIP version 2.0.1
• Source code:
  • SCIP
  • ZIB Optimization Suite
  
  
  Binaries:
  • Darwin(Mac)/PowerPC, gcc 4.2.0: dynamically linked to SoPlex 1.5.0, Zimpl 3.1.0, Ipopt 3.9stable, CppAD 20110101.0
  • Linux/PC, 32bit, gcc 4.5.0: statically linked to SoPlex 1.5.0, Zimpl 3.1.0, Ipopt 3.9.2, CppAD 20110101.0
  • Linux/PC, 64bit, gcc 4.5.2: statically linked to Clp 1.14, Zimpl 3.1.0, Ipopt 3.9.2, CppAD 20110106
  • Linux/PC, 64bit, gcc 4.5.2: statically linked to SoPlex 1.5.0, Zimpl 3.1.0, Ipopt 3.9.2, CppAD 20110106
  • Windows/PC, 32bit, cl 15: statically linked to SoPlex 1.5.0, Ipopt 3.9.2, CppAD 20100101.0
  • Windows/PC, 64bit, intel 11.1: statically linked to SoPlex 1.5.0, Ipopt 3.9.2, CppAD 20110101.0
  
  
• SCIP version 2.0.0
• Source code:
  • SCIP
  • ZIB Optimization Suite
  
  
  Binaries:
  • Darwin(Mac)/PC, 32bit, gnu: linked to SoPlex 1.5.0, Zimpl 3.1.0
  • Darwin(Mac)/PC, 32bit, gnu: linked to SoPlex 1.5.0, Zimpl 3.1.0, Ipopt 3.8.3, CppAD 20100101.4
  • Darwin(Mac)/PC, 64bit, gnu: linked to SoPlex 1.5.0, Zimpl 3.1.0
  • Darwin(Mac)/PC, 64bit, gnu: linked to SoPlex 1.5.0, Zimpl 3.1.0, Ipopt 3.8.3, CppAD 20100101.4
  • Linux/PC, 32bit, gnu: statically linked to SoPlex 1.5.0, Zimpl 3.1.0, Ipopt 3.8.3, CppAD 20100101.4
  • Linux/PC, 64bit, gnu: statically linked to SoPlex 1.5.0, Zimpl 3.1.0, Ipopt 3.8.3, CppAD 20100101.4
  • Windows/PC, 32bit, cl: statically linked to SoPlex 1.5.0, Ipopt 3.8.3, CppAD 20100101.4
  • Windows/PC, 64bit, intel: statically linked to SoPlex 1.5.0, Ipopt 3.8.3, CppAD 20100101.4
  • SunOS/PC, 32bit, gnu: dynamically linked to SoPlex 1.5.0, Zimpl 3.1.0, Ipopt 3.8.3, CppAD 20100101.4
  • SunOS/PC, 64bit, gnu: dynamically linked to SoPlex 1.5.0, Zimpl 3.1.0, Ipopt 3.8.3, CppAD 20100101.4
  • Windows/PC, 32bit, vs10: statically linked to SoPlex 1.5.0, Zimpl 3.1.0
  • Windows/PC, 64bit, vs10: statically linked to SoPlex 1.5.0, Zimpl 3.1.0
  
  
• SCIP version 1.2.0
• Source code:
  • SCIP
  • ZIB Optimization Suite
  
  
  Binaries:
  • Darwin(Mac)/PowerPC, gnu: linked to SoPlex 1.4.2, Zimpl 3.0.0
  • Linux/PC, 32bit, gnu: linked to Clp trunk (09/14/09), Zimpl 3.0.0
  • Linux/PC, 32bit, gnu: linked to SoPlex 1.4.2, Zimpl 3.0.0
  • Windows/PC, 32bit, gnu: linked to SoPlex 1.4.2, Zimpl 3.0.0
  • SunOS/PC, 32bit, gnu: linked to SoPlex 1.4.2, Zimpl 3.0.0
  • Windows/PC, 64bit, intel: linked to SoPlex 1.4.2
  
  
• SCIP version 1.1.0
• Source code:
  • SCIP
  • ZIB Optimization Suite
  
  
  Additional files:
  • lpi_clp.cpp: Bugfix in the Clp interface (several changes in the status methods).
  • reader_lp.c: Bugfix in the reading routine for LP format (bounds that had been read earlier were discarded).
  
  
  Binaries:
  • Darwin(Mac)/PowerPC, gnu: linked to SoPlex 1.4.0, Zimpl 2.08
  • Darwin(Mac)/PC, 32bit, gnu: linked to SoPlex 1.4.0, Zimpl 2.08 (contributed by Ulrich Türke)
  • Darwin(Mac)/PC, 64bit, gnu: linked to SoPlex 1.4.0, Zimpl 2.08 (contributed by Daniel Heldt)
  • Linux/PC, 32bit, gnu: linked to Clp 1.9.0, Zimpl 2.08 (contributed by Hans Mittelmann)
  • Linux/PC, 32bit, gnu: linked to Clp 1.8.2, Zimpl 2.08 (contributed by Hans Mittelmann)
  • Linux/PC, 32bit, gnu: linked to SoPlex 1.4.1, Zimpl 2.08
  • Linux/PC, 32bit, gnu: linked to SoPlex 1.4.0, Zimpl 2.08
  • Linux/PC, 64bit, gnu: linked to Clp 1.9.0, Zimpl 2.08 (contributed by Hans Mittelmann)
  • Linux/PC, 64bit, gnu: linked to Clp 1.8.2, Zimpl 2.08 (contributed by Hans Mittelmann)
  • Linux/PC, 64bit, gnu: linked to SoPlex 1.4.1, Zimpl 2.08
  • Linux/PC, 64bit, gnu: linked to SoPlex 1.4.0, Zimpl 2.08
  • Windows/PC, 32bit, gnu: linked to SoPlex 1.4.0, Zimpl 2.08
  • SunOS/sparc, gnu: linked to SoPlex 1.4.0, Zimpl 2.08
  
  
• SCIP version 1.00
• Source code:
  • SCIP
  • ZIB Optimization Suite
  
  
  Additional files:
  • interrupt.c: Bugfix for an error that occured under Windows with MinGW (after Crtl-C the current run could not be continued). (Copy file to src/scip/interrupt.c in the SCIP directory and recompile.)
  • lpi_msk.c: Updated interface for the Mosek LP-solver, contributed by Anders Schack-Nielsen and updated by Bo Jensen, Mosek. (Copy file to src/scip/lpi_msk.c in the SCIP directory and recompile.)
  • make.darwin.x86.gnu.dbg: Makefile needed for Mac Darwin with Intel processors (contributed by Volker Kaibel). (Copy file to make in the SCIP directory.)
  • make.darwin.x86.gnu.opt: Makefile needed for Mac Darwin with Intel processors (contributed by Volker Kaibel). (Copy file to make in the SCIP directory.)
  
  
  Binaries:
  • Darwin(Mac)/PowerPC, gnu: linked to SoPlex 1.3.2, Zimpl 2.07
  • Darwin(Mac)/PC, 32bit, gnu: linked to SoPlex 1.3.2, Zimpl 2.07 (contributed by Volker Kaibel)
  • Linux/PC, 32bit, gnu: linked to Clp 1.6, Zimpl 2.07 (contributed by Hans Mittelmann)
  • Linux/PC, 32bit, gnu: linked to SoPlex 1.3.2, Zimpl 2.07
  • Linux/PC, 64bit, gnu: linked to Clp 1.6, Zimpl 2.07 (contributed by Hans Mittelmann)
  • Linux/PC, 64bit, gnu: linked to SoPlex 1.3.2, Zimpl 2.07
  • Windows/PC, 32bit, gnu: linked to SoPlex 1.3.2, Zimpl 2.07
  
  
• SCIP version 0.90
• Source code:
  • SCIP
  
  
  Additional files:
  • Makefile: Makefile without "line" command.
    The "line" command used to enter the soft-link locations seems to be non-standard, which causes an error on some machines. The new Makefile uses "read" instead which is a standard bash command.
  
  
  Binaries:
  • Darwin(Mac)/PowerPC, gnu: statically linked to Clp 1.3.3, Zimpl 2.05 (contributed by Armin Fügenschuh)
  • Darwin(Mac)/PowerPC, gnu: statically linked to SoPlex 1.3.1, Zimpl 2.05 (contributed by Armin Fügenschuh)
  • Darwin(Mac)/PC, 32bit, gnu: statically linked to Clp 1.3.3, Zimpl 2.05 (contributed by Armin Fügenschuh)
  • Darwin(Mac)/PC, 32bit, gnu: statically linked to SoPlex 1.3.1, Zimpl 2.05 (contributed by Armin Fügenschuh)
  • Linux/PC, 32bit, gnu: statically linked to Clp, Zimpl 2.05 (contributed by Hans Mittelmann)
  • Linux/PC, 32bit, gnu: statically linked to SoPlex 1.3.0, Zimpl 2.05d
  • Linux/PC, 64bit, gnu: statically linked to Clp, Zimpl 2.05 (contributed by Hans Mittelmann)
  • Linux/PC, 64bit, gnu: statically linked to SoPlex 1.3.1, Zimpl 2.05 (contributed by Hans Mittelmann)
  • Windows/PC, 32bit, gnu: statically linked to SoPlex 1.3.1, Zimpl 2.05
  • SunOS/sparc, gnu: statically linked to SoPlex 1.3.1, Zimpl 2.05 (contributed by Hans Mittelmann)
  
  
• SCIP version 0.82
• Source code:
  • SCIP
  
  
  Additional files:
  • clock.c: Bugfix for missing include of unistd.h.
    Since Suse Linux 10.1 one needs to include "unistd.h" in clock.c in order to find the method "sysconf". Copy this source file into the scip/src/scip directory to fix this bug.
  • objscippatch.zip: Bugfix for string pointer copy instead of string content duplication in C++ wrapper classes.
    This fixes a quite embarrassing bug. In the constructors of the Obj... base classes for the C++ wrapper objects, I copied only the pointers to the given strings (like name and description) instead of duplicating the content. The zip file contains the patched header files for the wrapper objects with the full subpath src/objscip/. Just unpack the file into your SCIP base directory.
  • INSTALL: updated INSTALL file for Mosek interface
  • Makefile: updated Makefile for Mosek interface
  • lpi_msk.c: LP interface for Mosek LP solver (contributed by Anders Schack-Nielsen, Mosek Aps):
    Copy the file into the scip/src/ subdirectory of SCIP. In order to link Mosek to SCIP, you also need an updated Makefile and soft-links that are described in the updated INSTALL file.
  • make.linux.x86.intel.dbg.static: Machine dependent makefile for Linux/Intel compiler 9.0 (debug mode).
    Copy the file into the make/ subdirectory of SCIP.
  • make.linux.x86.intel.opt.static: Machine dependent makefile for Linux/Intel compiler 9.0.
    Copy the file into the make/ subdirectory of SCIP.
  • scip_make_vc7.zip: Project files for MS Visual C++ Studio (contributed by Martin C. Mueller, Siemens AG).
    Unzip the file into the SCIP base directory. It will automatically extract to the subdirectory "make/vc7/". Afterwards, follow the instructions in "make/vc7/INSTALL_VC7.txt".
  
  
  Binaries:
  • Linux/PC, 32bit, gnu: statically linked to Clp 1.3.3, Zimpl 2.04 (contributed by Hans Mittelmann)
  • Linux/PC, 32bit, gnu: statically linked to SoPlex 1.3.0, Zimpl 2.04
  • Linux/PC, 64bit, gnu: statically linked to Clp 1.3.3, Zimpl 2.04 (contributed by Hans Mittelmann)
  • Linux/PC, 64bit, gnu: statically linked to SoPlex 1.3.0, Zimpl 2.04 (contributed by Hans Mittelmann)
  • Windows/PC, 32bit, mingw windows: statically linked to SoPlex 1.3.0, Zimpl 2.04
  • Windows/PC, 32bit, mingw cross compiler linux: statically linked to SoPlex 1.3.0, Zimpl 2.04
  
  
• SCIP version 0.81
• Source code:
  • SCIP
  
  
  Additional files:
  • Makefile: Makefile fixing CLP library include.
    With the current Makefile, you cannot name the CLP library softlinks in the lib/ directory as the INSTALL file says. Using this new Makefile should fix this issue.
  • reader_lp.c: LP file reader bug fix for SCIP 0.80.
    The LP file reader is a total mess, if the LP file was not produced by CPLEX. This fixed version has to be copied into the "scip/src/scip" directory, replacing the old version.
  
  
• SCIP version 0.80
• Source code:
  • SCIP
  
  

Features

• very fast standalone solver for linear programming (LP), mixed integer programming (MIP), and mixed integer nonlinear programming (MINLP)
• framework for branching, cutting, pricing, and propagation
• highly flexible through many possible user plugins:
  • constraint handlers to implement arbitrary constraints,
  • variable pricers to dynamically create problem variables,
  • domain propagators to apply constraint independent propagations on the variables' domains,
  • cut separators to apply cutting planes on the LP relaxation,
  • relaxators to provide relaxations and dual bounds in addition to the LP relaxation,
  • primal heuristics to search for feasible solutions with specific support for probing and diving,
  • node selectors to guide the search,
  • branching rules to split the problem into subproblems,
  • presolvers to simplify the solved problem,
  • file readers to parse different input file formats,
  • event handlers to be informed on specific events, e.g., after a node was solved, a specific variable changes its bounds, or a new primal solution is found,
  • display handlers to create additional columns in the solver's output.
  • dialog handlers to extend the included command shell.
• every existing unit implemented as a plugin, leading to an interface flexible enough to meet the needs of most additional user extensions
• interfaces to other applications and programming languages (contained in source code packages):
  • Python
  • Java
  • AMPL
  • GAMS
  • MATLAB
• dynamic cut pool management
• user may mix preprocessed and active problem variables in expressions: they are automatically transformed to corresponding active problem variables
• arbitrarily many children per node can be created, and the different children can be arbitrarily defined
• open LP solver support:
  • CPLEX
  • Gurobi (only beta version, since ranged rows and basis inverse are not supported yet)
  • XPress
  • Mosek
  • SoPlex
  • QSopt
  • CLP.
• LP relaxation not need to be solved at every single node (can even be turned off completely, mimicing a pure constraint programming solver)
• additional relaxations (e.g., semidefinite relaxations or Lagrangian relaxations) can be included, working in parallel or interleaved
• conflict analysis can be applied to learn from infeasible subproblems
• dynamic memory management to reduce the number of operation system calls with automatic memory leakage detection in debug mode

Platforms

SCIP is completely implemented in C. The code should compile with any ANSI compliant C compiler.

We have tested SCIP with compilers from

• GNU
• Compaq
• Intel
• SUN

on 32- and 64-bit versions of

• Linux
• Mac
• Windows
• SunOS
• Android

SCIP is also available on the NEOS Server, where you can post your model in LP or MPS format, or as an AMPL, GAMS, or ZIMPL model and let the NEOS Server solve it with SCIP linked to CPLEX.

Hints for SUN platforms

• If you are using the GNU compiler and you experience a strange behavior of your program (segmentation faults), you might try a reduce the optimization level in make.sunos.sparc.gnu.opt by changing -O3 to -O2.
• If problems occur with STL code, you might change to a different implementation by adding -library=stlport4 to CXX_COMPILER_FLAGS. (Note: There are different implementations of the STL on SUN platforms.)

FAQ

General Questions about SCIP

1. What is SCIP?

   SCIP is a constraint integer program solver. It can be used as a framework for branch-cut-and-price and contains all necessary plugins to serve as a standalone solver for MIP, MINLP, and PBO.

   • You can use the precompiled binaries to solve MIPs, MINLPs, or PBO problems. They can read
     1. CIP - file format (own constraint based file format)
     2. CNF - file format
     3. FZN - file format
     4. (R)LP - file formats
     5. MPS - file format
     6. OPB/WBO - file formats
     7. OSiL format for MINLP
     8. PIP - file format
     9. SOL - file format (solution reader, xml-solutions are also supported)
     10. ZPL - file format
     See also the page on file readers.
   • You can use SCIP as a subroutine for solving MIPs and more general constraint integer programs from your own source code.
   • You can use SCIP as a framework in which you implement your own plugins.
   • You can use SCIP in any combination of the three purposes above.

   This FAQ contains separate sections covering each of these usages of SCIP. It further considers specific questions for some features.

2. When should I use SCIP?

   If you are either looking for a fast non-commercial MIP-solver or for a branch-cut-and-price-framework in which you can directly implement your own methods — which can even be for more general purposes than MIP.

3. I heard something about licenses. Do I have to pay for using SCIP?

   As long as you use it for academic, non-commercial purposes: No. This will not change. For the other cases, check the explanation of the ZIB academic license and always feel free to ask us. If you want to use SCIP commercially, please write an e-mail to [email protected].

4. How do I get started?

   An easy way is to use the SCIP-binaries and call SCIP from a shell, see here for a tutorial. For that, you just have to download one of the precompiled binaries from the download section, or the zipped source code and compile it with your favorite settings. This is described in detail in the INSTALL file in the SCIP main directory.

   Another way is to use SCIP as a solver integrated into your own program source code. See the directories "examples/MIPsolver/" and "examples/Queens/" for simple examples and this point.

   A third way is to implement your own plugins into SCIP. This is explained in the HowTos for all plugin types, which you can find in the doxygen documentation. See also How to start a new project.

5. Do I need any extra software?

   Unless you want to use SCIP as a pure CP-Solver (see here), you need an underlying LP-Solver installed and linked to the libraries (see the INSTALL file in the SCIP root directory). LP-solvers currently supported by SCIP are:

   • CLP
   • FICO XPress
   • Gurobi (interface is in beta stage)
   • ILOG CPLEX
   • Mosek
   • QSopt
   • SoPlex

   We also provide some precompiled binaries. Besides that, you might need a modeling language like ZIMPL to generate *.mps or *.lp files. ZIMPL files can also directly be read by SCIP. You can download a package which includes SCIP, SoPlex and ZIMPL here.

   If you want to use SCIP for mixed integer nonlinear programming, you might want to use an underlying NLP solver (e.g., Ipopt) and an expression interpreter (e.g., CppAD).

6. I have installation problems. What can I do?

   Read the INSTALL file in the SCIP root directory. It contains hints of how to get around problems. You can also try the binaries available on the SCIP page.
   If you want to use SoPlex as the underlying LP-solver, you can try the following:

   First, download the SCIP Optimization Suite. Then, extract the file, change into the scipoptsuite directory, and enter 'make'. As long as you have all the necessary libraries installed in your system, it should generate a SCIP binary linked to ZIMPL and Soplex. The necessary system libraries are:

   1. ZLIB (libz.a)
   2. GMP (libgmp.a)
   3. Readline (libreadline.a)

   If you do not have all of these libraries, read the INSTALL file in the SCIP Optimization Suite directory.

   As a summary, the call of make ZIMPL=false ZLIB=false READLINE=false should work on most systems. If you have any problems while using an LP-solver different from SoPlex, please read the SCIP INSTALL file first.

   If you encounter compilation problems dealing with the explicit keyword you can either try a newer compiler or set the flags LEGACY=true for SoPlex and SPX_LEGACY=true for SCIP.

7. I changed to a new version of SCIP and now compiling breaks with some error messages which I don't understand. Do you have a general hint on that?

   Maybe the parameters of a function in SCIP changed. Relevant changes between version are listed below.

   • Interface changes between SCIP 0.9 and SCIP 1.0
   • Interface changes between SCIP 1.0 and SCIP 1.1
   • Interface changes between SCIP 1.1 and SCIP 1.2
   • Interface changes between SCIP 1.2 and SCIP 2.0
   • Interface changes between SCIP 2.0 and SCIP 2.1
   • Interface changes between SCIP 2.1 and SCIP 3.0
   • Interface changes between SCIP 3.0 and SCIP 3.1
   • Interface changes between SCIP 3.1 and SCIP 3.2
8. How can I debug in SCIP?

   Compile SCIP in debug mode: make OPT=dbg. Put the binary into a debugger, e.g., gdb and let it run again. If you get an impression which component is causing the trouble, set #define SCIP_DEBUG as the first line of the corresponding *.c file, recompile and let it run again. This will print debug messages from that piece of code. Find a short debugging tutorial here.

9. SCIP prints error messages, aborts, produces segmentation faults, or just behaves strangely. What should I do?

   See above. Often, the asserts that show up in debug mode already help to clarify misunderstandings and suggest fixes, if you were calling SCIP functions in an unexpected manner. If you, however, have the impression that there is a bug in SCIP, send us a bug report and include a log file and ideally a backtrace from a debugger.

10. I would like to check whether some functionality is implemented in SCIP. How does the naming of the methods work? Where do I find the most common methods?

    For an explanation of the naming see the coding style guidelines.
    The methods you might want to use should normally be found in scip.h or in pub_*.h, see also here. In the doxygen documentation of scip.h, the methods are ordered by topics.

11. Can I use SCIP as a pure CP-Solver?

    Yes. SCIP can be used as a pure CP-Solver by typing set emphasis cpsolver in the shell or by using the function SCIPsetEmphasis(). Furthermore, you can compile SCIP without any LP-Solver by make LPS=none. See here for more on changing the behavior of SCIP.

12. Can I use SCIP as a pure LP-Solver?

    Since LPs are only special types of MIPs and CIPs, the principal answer is yes. If you feed a pure LP to SCIP, it will first apply presolving and then hand this presolved problem to the underlying LP solver. If the LP is solved to optimality, you can query the optimal solution values as always.

    However, there are certain limitations to this: Dual multipliers and reduced costs are not accessible. If the LP turns out to be infeasible, you cannot obtain the Farkas proof. Strong LP duality theory does not apply to MIP or CIP and there is no special functionality implemented in SCIP for the case that the solved problem is an LP.

    Hence, if you need more, "LP specific", information than the primal solution, you are better off using an LP-Solver directly. If you are using the SCIP Optimization Suite, you could, e.g., use the included LP solver SoPlex. If you want to solve an LP not from the command line, but within your C/C++ program, you could also use SCIP's LP-Interface, see also here.

13. Which kind of MINLPs are supported by SCIP?

    SCIP supports nonlinear constraints of the form lhs ≤ f(x) ≤ rhs, where the function f(x) is an algebraic expression that can be represented as expression tree. Such an expression tree has constants and variables as terminal nodes and operands as non-terminal nodes. Expression operands supported by SCIP include addition, subtraction, multiplication, division, exponentiation and logarithm. Trigonometric functions are not yet supported by SCIP.

    Nonlinear objective functions are not supported by SCIP and must be modeled as constraint function. Note, that the support for non-quadratic nonlinear constraints is still in a BETA-stadium and not yet as robust as the rest of SCIP. Missing bounds on nonlinear variables and tiny or huge coefficients can easily lead to numerical problems, which can be avoided by careful modeling.

14. How can I use the SCIP makefiles?

    See Makefiles.

15. What is this business with .a and .so libraries in the directory lib/?

    When SCIP builds the binary it needs to link with the corresponding libraries of the LP-solver. There are usually two ways to distribute a library. In the first (.a) the library is linked statically to SCIP; this means that all of its information is packed into the binary. In the second way (.so) the library is a shared library. In this case, the code of the library is not inserted into the binary itself, but is loaded at runtime. This has the advantage that the binaries are smaller, but it comes at the cost that you have to make sure that the library is found at runtime (for most systems it suffices to put the path of the library into the LD_LIBRARY_PATH variable).
    
    Note: Depending on the system shared or static libraries are standard. If both links are present in the lib directory, the linker chooses which version to take (on newer Linux systems this is usually the shared version). If you do not want this to happen you have to delete the link that is not intended.

16. Can I compile SCIP as a shared library?

    You can use the SHARED=true option when making SCIP. This will generate the libraries of SCIP in shared format. The binary then also uses this form. Note that the path to the lib directory of SCIP is used to locate the libraries. If you want to move the libraries, you might to set the LD_LIBRARY_PATH environment variable to include the new path. If you are using your own building system: The "magic" changes are the -FPIC compiler/linker option and the -Wl,-rpath option.

17. The methods SCIPgetVarSol() and SCIPvarGetSol() seem to have the same functionality. Which one should I use?

    In fact, there is a slight difference: SCIPvarGetSol() is also able to return pseudo solution values. If you do not have an idea, what pseudo solutions are, SCIPgetVarSol() should be just fine. This should be the only case of 'duplicate methods'. If you find, however, another one, please contact us.

18. Is there a way to visualize the branch and bound tree?

    Yes, currently there are two tree visualizations supported, the vbctool, and the Branch-and-Bound Analysis Kit. The first comes with a viewer that has an option to uncover the nodes one-by-one (each time you hit the space key). Additional node information such as its lower bound, depth, and number are accessed through a context menu. The BAK is a command line tool written in the Python programming language. It offers several noninteractive visualizations of the tree at a user-defined frequency.

    For using one of these tools, SCIP lets you define file names set visual vbcfilename somefilename.vbc and set visual bakfilename somefilename.dat.

    For those who want to use the step-by-step functionality of vbctool, it is necessary to use a time-step counter for the visualization instead of the real time. The corresponding parameter is changed via set visual realtime FALSE.

    For users of the callable library, the corresponding parameters are called "visual/bakfilename", "visual/vbcfilename", and "visual/realtime".

Using SCIP as a standalone solver

1. The output is too wide for my terminal window. What can I do?

   In the interactive shell you can set the width of the output with the following command set display width followed by an appropriate number. See also the next question.

2. What do the cryptic abbreviations for the columns mean which are displayed during the solving process of SCIP?

   Type display display in the interactive shell to get an explanation of them.
   By the way: If a letter appears in front of a display row, it indicates, which heuristic found the new primal bound, a star representing an integral LP-relaxation.
   Typing display statistics after finishing or interrupting the solving process gives you plenty of extra information about the solving process.
   (Typing display heuristics gives you a list of the heuristics including their letters.)

3. Why does SCIP claim that it could not find the user parameters "scip.set"? Where can I get such a file?

   SCIP comes with default settings that are automatically active when you start the interactive shell. However, you have the possibility to save customized settings via the set save and set diffsave commands. Both commands will prompt you to enter a file name and save either all or customized parameters only to the specified file. A user parameter file that you save as "scip.set" has a special meaning; Whenever you invoke SCIP from a directory containing a file named "scip.set", the settings therein overwrite the default settings. For more information about customized settings, see the Tutorial on the interactive shell. Settings files can become incompatible with later releases if we decide to rename/delete a parameter. Information about this can be found in the CHANGELOG for every release, see also this related question.

4. How do I change the behavior of SCIP?

   You can switch the settings for all presolving, heuristics, and separation plugins to three different modes via the set {presolving, heuristics, separation} emphasis parameters in the interactive shell. off turns off the respective type of plugins, fast chooses settings that lead to less time spent in this type of plugins, decreasing their impact, and aggressive increases the impact of this type of plugins. You can combine these general settings for cuts, presolving, and heuristics arbitrarily.
   display parameters shows you which settings currently differ from their default, set default resets them all. Furthermore, there are complete settings that can be set by set emphasis, i.e. settings for pure feasibility problems, solution counting, and CP like search.

5. How can I learn more about/from the presolve reasoning SCIP applies to my combinatorial optimization problem?

   You can look at the statistics (type display statistics in the interactive shell or call SCIPprintStatistics() when using SCIP as a library). This way you can see, which of the presolvers, propagators or constraint handlers performed the reductions. Then, add a #define SCIP_DEBUG as first line of the corresponding *.c file in src/scip (e.g. cons_linear.c or presol_probing.c) Recompile and run again. You will get heaps of information now. Looking into the code and documentation of the corresponding plugin and ressources from the literature helps with the investigation.

6. I recognized that one special plugin works very poorly / very well for my problem and I want to disable it / weaken its influence / intensify its influence. How do I do this?
   • For using a non-default branching rule or node selection strategy as standard, you just have to give it the highest priority, using
     • SCIP> set branching priority 9999999
     • SCIP> set nodeselectors priority 9999999
     With the commands
     • SCIP> display branching
     • SCIP> display nodeselectors
     you get a list of all branching rules and node selectors, respectively. These lists give information about the different priorities.
   • If you want to completely disable a heuristic or a separator you have to set its frequency to -1 and the sepafreq to -1 for separation by constraint handlers, respectively. The commands looks like this:
     • SCIP> set heuristics freq -1
     • SCIP> set separators freq -1
     • SCIP> set constraints sepafreq -1
   • For disabling a presolver, you have to set its maxrounds parameter to 0.
     • SCIP> set presolvers maxrounds 0
   • If you want to intensify the usage of a heuristic, you can reduce its frequency to some smaller, positive value, and/or raise the quotient and offset values (maxlpiterquot for diving heuristics, nodes for LNS heuristics).
     • SCIP> set heuristics freq
     • SCIP> set heuristic maxlpiterquot
     • SCIP> set heuristic nodesquot
   • For intensifying the usage of a separator, you can raise its maxroundsroot and maxsepacutsroot values.
     • SCIP> set separators maxroundsroot
     • SCIP> set separators maxrounds
     If you also want to use this separator locally, you have to set its frequency to a positive value and possibly raise maxrounds and maxsepacuts.
     • SCIP> set separators freq
     • SCIP> set separators maxsepacuts
     Compare the parameters of the heuristic/separator in the appropriate aggressive setting
   • For weakening, you should just do the opposite operation, i.e., reducing the values you would raise for intensification and vice versa.
7. How can I use my own functions in the interactive shell/extend the set of available interactive shell commands?

   If you want to keep the interactive shell functionality, you could add a dialog handler, that introduces a new SCIP shell command that

   1. solves the problem and calls your function afterwards or
   2. checks whether the stage is SOLVED and only calls your function.

   Search SCIPdialogExecOptimize in src/scip/dialog_default.c to see how the functionality of the "optimize" command is invoked. Also, in src/scip/cons_countsols.c, you can see an example of a dialog handler being added to SCIP. If this is the way you go, please check the How to add dialogs section of the doxygen documentation.

8. How can I input a MINLP into SCIP?

   Mixed-integer nonlinear constrained programs can be input via the reader for OSiL and ZIMPL files and the AMPL interface. An interface to the modeling language GAMS is available in the COIN-OR/GAMSlinks project. Further, mixed-integer polynomially constrained programs can be input via the readers for PIP files. Finally, the readers for *.mps and *.lp files support the CPLEX extensions for quadratic constraints and objective.

Using SCIP included in another source code

1. How do I construct a problem instance in SCIP?

   First you have to create a SCIP object via SCIPcreate(), then you start to build the problem via SCIPcreateProb(). Then you create variables via SCIPcreateVar() and add them to the problem via SCIPaddVar().

   The same has to be done for the constraints. For example, if you want to fill in the rows of a general MIP, you have to call SCIPcreateConsLinear(), SCIPaddConsLinear() and additionally SCIPreleaseCons() after finishing. If all variables and constraints are present, you can initiate the solution process via SCIPsolve().

   Make sure to also call SCIPreleaseVar() if you do not need the variable pointer anymore. For an explanation of creating and releasing objects, please see the doxygen documentation..

2. I already know a solution in advance, which I want to pass to SCIP. How do I do this?

   First you have to build your problem (at least all variables have to exist), then there are two options:

   • You have the solution in file which fits the solution format of SCIP, then you can use SCIPreadSol() to pass that solution to SCIP.
   • You create a new SCIP primal solution candidate by calling SCIPcreateSol() and set all nonzero values by calling SCIPsetSolVal(). After that, you add this solution by calling SCIPaddSol() (the variable stored should be true afterwards, if your solution was added to solution candidate store) and then release it by calling SCIPsolFree(). Instead of adding and releasing sequentially, you can use SCIPaddSolFree() which tries to add the solution to the candidate store and free the solution afterwards.
3. What operational stages of SCIP are there and are they important for me?

   There are fourteen different stages during a run of SCIP. There are some methods which cannot be called in all stages, consider for example SCIPtrySol() (see previous question).

4. What is the difference between the original and the transformed problem?

   Before the solving process starts, the original problem is copied. This copy is called "transformed problem", and all modifications during the presolving and solving process are only applied to the transformed problem.
   This has two main advantages: first, the user can also modify the problem after partially solving it. All modifications done by SCIP (presolving, cuts, variable fixings) during the partial solving process will be deleted together with the transformed problem, the user can modify the original problem and restart solving. Second, the feasibility of solutions is always tested on the original problem!

5. Why do the names, e.g., in debug messages often differ from the ones I defined?

   This can have several reasons. Especially names of binary variables can get different prefixes and suffixes. Each transformed variable and constraint (see here) gets a "t_" as prefix. Apart from that, the meaning of original and transformed variables and constraints is identical.

   General integers with bounds that differ just by 1 will be aggregated to binary variables which get the same name with the suffix "_bin" . E.g. an integer variable t_x with lower bound 4 and upper bound 5 will be aggregated to a binary variable t_x_bin = t_x - 4.

   Variables can have negated counterparts, e.g. for a binary t_x its (also binary) negated would be t_x_neg = 1 - t_x.

   The knapsack constraint handler is able to disaggregate its constraints to cliques, which are set packing constraints, and create names that consist of the knapsack's name and a suffix "_clq_". E.g., a knapsack constraint knap: x_1 + x2 +2 x_3 ≤ 2 could be disaggregated to the set packing constraints knap_clq_1: x_1 + x_3 ≤ 1 and knap_clq_2: x_2 + x_3 ≤ 1.

6. What is SCIP_CALL()? Do I need this?

   Yes, you do. SCIP_CALL() is a global define, which handles the return codes of all methods which return a SCIP_RETCODE and should therefore parenthesize each such method. SCIP_OKAY is the code which is returned if everything worked well; there are 17 different error codes, see type_retcode.h. Each method that calls methods which return a SCIP_RETCODE should itself return a SCIP_RETCODE. If this is not possible, use SCIP_CALL_ABORT() to catch the return codes of the methods. If you do not want to use this either, you have to do the exception handling (i.e. the case that the return code is not SCIP_OKAY) on your own.

7. I want to stop the solving process after a certain time. How can I do this?

   Limits are given by parameters in SCIP, for example limits/time for a time limit or limits/nodes for a node limit. If you want to set a limit, you have to change these parameters. For example, for setting the time limit to one hour, you have to call SCIP_CALL( SCIPsetRealParam(scip, "limits/time", 3600) ). In the interactive shell, you just enter set limits time 3600. For more examples, please have a look into heur_rens.c.

Using SCIP as a Branch-Cut-And-Price-Framework

1. How do I start a project?

   See How to start a new project.

2. What types of plugins can I add and how do I do this?

   See the doxygen documentation for a list of plugin types. There is a HowTo for each of them.

3. When should I implement a constraint handler, when should I implement a separator?

   This depends on whether you want to add constraints or only cutting planes. The main difference is that constraints can be "model constraints", while cutting planes are only additional LP rows that strengthen the LP relaxation. A model constraint is a constraint that is important for the feasibility of the integral solutions. If you delete a model constraint, some infeasible integral vectors would suddenly become feasible in the reduced model. A cutting plane is redundant w.r.t. integral solutions. The set of feasible integral vectors does not change if a cutting plane is removed. You can, however, relax this condition slightly and add cutting planes that do cut off feasible solutions, as long as at least one of the optimal solutions remains feasible.

   You want to use a constraint handler in the following cases:

   1. Some of your feasibility conditions can not be expressed by existing constraint types (e.g., linear constraints), or you would need too many of them. For example, the "nosubtour" constraint in the TSP is equivalent to exponentially many linear constraints. Therefore, it is better to implement a "nosubtour" constraint handler that can inspect solutions for subtours and generate subtour elimination cuts and others (e.g., comb inequalities) to strengthen the LP relaxation.
   2. Although you can express your feasibility condition by a reasonable number of existing constraint types, you can represent and process the condition in a more efficient way. For example, it may be that you can, due to your structural knowledge, implement a stronger or faster domain propagation or find tighter cutting planes than what one could do with the sum of the individual "simple" constraints that model the feasibility condition.

   You want to use a cutting plane separator in the following cases:

   1. You have a general purpose cutting plane procedure that can be applied to any MIP. It does not use problem specific knowledge. It only looks at the LP, the integrality conditions, and other deduced information like the implication graph.
   2. You can describe your feasibility condition by a set C of constraints of existing type (e.g., linear constraints). The cuts you want to separate are model specific, but apart from these cuts, there is nothing you can gain by substituting the set C of constraints with a special purpose constraint. For example, the preprocessing and the domain propagation methods for the special purpose constraint would do basically the same as what the existing constraint handler does with the set C of constraints. In this case, you don't need to implement the more complex constraint handler. You add constraints of existing type to your problem instance in order to produce a valid model, and you enrich the model by your problem specific cutting plane separator to make the solving process faster. You can easily evaluate the performance impact of your cutting planes by enabling and disabling the separator.

   Note that a constraint handler is defined by the type of constraints that it manages. For constraint handlers, always think in terms of constraint programming. For example, the "nosubtour" constraint handler in the TSP example (see "ConshdlrSubtour.cpp" in the directory "scip/examples/TSP/src/") manages "nosubtour" constraints, which demand that in a given graph no feasible solution can contain a tour that does not contain all cities. In the usual TSP problem, there is only one "nosubtour" constraint, because there is only one graph for which subtours have to be ruled out. The "nosubtour" constraint handler has various ways of enforcing the "nosubtour" property of the solutions. A simple way is to just check each integral solution candidate (in the CONSCHECK, CONSENFOLP, and CONSENFOPS callback methods) for subtours. If there is a subtour, the solution is rejected. A more elaborate way includes the generation of "subtour elimination cuts" in the CONSSEPALP callback method of the constraint handler. Additionally, the constraint handler may want to separate other types of cutting planes like comb inequalities in its CONSSEPALP callback.

4. Can I remove unnecessary display columns or—even better—add my own ones? Can I change the statistics displayed at the end of solving?

   Setting the status of a display column to 0 turns it off. E.g., type set display memused status 0 in the interactive shell to disable the memory information column, or include the line SCIPsetIntParam(scip, "display/memused/status", 0) into your source code. Adding your own display column can be done by calling the SCIPincludeDisp() method, see the doxygen documentation.
   The statistic display, which is shown by display statistics and SCIPprintStatistics(), respectively, cannot be changed.

5. What do LP-rows look like in SCIP?

   Each row is of the form lhs ≤ Σ(val[j]·col[j]) + const ≤ rhs. For now, val[j]·col[j] can be interpreted as a_ij·x_j (for the difference between columns and variables see here). The constant is essentially needed for collecting the influence of presolving reductions like variable fixings and aggregations.
   The lhs and rhs may take infinite values: a less-than inequality would have lhs = -∞, and a greater-than inequality would have rhs = +∞. For equations lhs is equal to rhs. An infinite left hand side can be recognized by SCIPisInfinity(scip, -lhs), an infinite right hand side can be recognized by SCIPisInfinity(scip, rhs).

6. How do I get the data of the current LP-relaxation?

   You can get all rows in the current LP-relaxation by calling SCIPgetLPRowsData(). The methods SCIProwGetConstant(), SCIProwGetLhs(), SCIProwGetRhs(), SCIProwGetVals(), SCIProwGetNNonz(), SCIProwGetCols() then give you information about each row, see previous question.

   You get a columnwise representation by calling SCIPgetLPColsData(). The methods SCIPcolGetLb() and SCIPcolGetUb() give you the locally valid bounds of a column in the LP relaxation of the current branch-and-bound-node.

   If you are interested in global information, you have to call SCIPcolGetVar() to get the variable associated to a column (see next question), which you can ask for global bounds via SCIPvarGetLbGlobal() and SCIPvarGetUbGlobal() as well as the type of the variable (binary, general integer, implicit integer, or continuous) by calling SCIPvarGetType(). For more information, also see this question.

7. What is the difference between columns and variables, rows and constraints?

   The terms columns and rows always refer to the representation in the current LP-relaxation, variables and constraints to your global Constraint Integer Program.
   Each column has an associated variable, which it represents, but not every variable must be part of the current LP-relaxation. E.g., it could be already fixed, aggregated to another variable, or be priced out if a column generation approach was implemented.

   Each row has either been added to the LP by a constraint handler or by a cutting plane separator. A constraint handler is able to, but does not need to, add one or more rows to the LP as a linear relaxation of each of its constraints. E.g., in the usual case (i.e. without using dynamic rows) the linear constraint handler adds one row to the LP for each linear constraint.

8. Are the variables and rows sorted in any particular order?

   The variable array which you get by SCIPgetVars() is internally sorted by variable types. The ordering is binary, integer, implicit integer and continuous variables, i.e., the binary variables are stored at position [0,...,nbinvars-1], the general integers at [nbinvars,...,nbinvars+nintvars-1], and so on. It holds that nvars = nbinvars + ninitvars + nimplvars + ncontvars. There is no further sorting within these sections, as well as there is no sorting for the rows. But each column and each row has a unique index, which can be obtained by SCIPcolGetIndex() and SCIProwGetIndex(), respectively.

9. When should I use which of the numerical comparison functions?

   There are various numerical comparison functions available, each of them using a different epsilon in its comparisons. Let's take the equality comparison as an example. There are the following methods available: SCIPisEQ(), SCIPisSumEQ(), SCIPisFeasEQ(), SCIPisRelEQ(), SCIPisSumRelEQ().

   • SCIPisEQ() should be used to compare two single values that are either results of a simple calculation or are input data. The comparison is done w.r.t. the "numerics/epsilon" parameter, which is 1e-9 in the default settings.
   • SCIPisSumEQ() should be used to compare the results of two scalar products or other "long" sums of values. In these sums, numerical inaccuracy can occur due to cancellation of digits in the addition of values with opposite sign. Therefore, SCIPisSumEQ() uses a relaxed equality tolerance of "numerics/sumepsilon", which is 1e-6 in the default settings.
   • SCIPisFeasEQ() should be used to check the feasibility of some result, for example after you have calculated the activity of a constraint and compare it with the left and right hand sides. The feasibility is checked w.r.t. the "numerics/feastol" parameter, and equality is defined in a relative fashion in contrast to absolute differences. That means, two values are considered to be equal if their difference divided by the larger of their absolute values is smaller than "numerics/feastol". This parameter is 1e-6 in the default settings.
   • SCIPisRelEQ() can be used to check the relative difference between two values, just like what SCIPisFeasEQ() is doing. In contrast to SCIPisFeasEQ() it uses "numerics/epsilon" as tolerance.
   • SCIPisSumRelEQ() is the same as SCIPisRelEQ() but uses "numerics/sumepsilon" as tolerance. It should be used to compare two results of scalar products or other "long" sums.
10. How do I solve an LP inside my SCIP plugin?

    If the LP is only a slightly modified version of the LP relaxation - changed variable bounds or objective coefficients - then you can use SCIP's diving mode: methods SCIPstartDive(), SCIPchgVarLbDive(), SCIPsolveDiveLP(), etc.

    Alternatively, SCIP's probing mode allows for a tentative depth first search in the tree and can solve the LP relaxations at each node: methods SCIPstartProbing(), SCIPnewProbingNode(), SCIPfixVarProbing(), etc. However, you cannot change objective coefficients or enlarge variable bounds in probing mode.

    If you need to solve a separate LP, creating a sub-SCIP is not recommended because of the overhead involved and because dual information is not accessible (compare here). Instead you can use SCIP's LP interface. For this you should include lpi/lpi.h and call the methods provided therein. Note that the LPI can be used independently from SCIP.

Specific questions about Column Generation and Branch-And-Price with SCIP

1. What can I expect when using SCIP as a Branch-Cut-and-Price framework?

   If you want to use SCIP as a branch-and-price framework, you normally need to implement a reader to read in your problem data and build the problem, a pricer to generate new columns, and a branching rule to do the branching (see also this question to see how to store branching decisions, if needed). SCIP takes care about everything else, for example the branch-and-bound tree management and LP solving including storage of warmstart bases. Moreover, many of SCIP's primal heuristics will be used and can help improve your primal bound. However, this also comes with a few restrictions: You are not allowed to change the objective function coefficients of variables during the solving process, because that means that previously computed dual bounds might have to be updated. This prevents the use of dual variable stabilization techniques based on a (more or less strict) bounding box in the dual. We are working on making this possible and recommend to use a weighted sum stabilization approach until then. Another point that SCIP does for you is the dynamic removal of columns from the LP due to aging (see also the next two questions). However, due to the way simplex bases are stored in SCIP, columns can only be removed at the same node where they were created.

2. Why are not all variables in the LP?

   With SCIPgetLPColsData() you can obtain the columns of the current LP relaxation. It is correct that not all variables are necessarily part of the current LP relaxation. In particular, in branch-and-price the variables generated at one node in the tree are not necessarily included in the LP relaxation of a different node (e.g., if the other node is not a descendant of the first node). But even if you are still at the same node or at a descendant node, SCIP can remove columns from the LP, if they are 0 in the LP relaxation. This dynamic column deletion can be avoided by setting the "removable" flag to FALSE in the SCIPcreateVar() call.

3. I only implemented one pricer, why is there a second one, called variable pricer?

   As described in the previous question, it may happen, that some variables are not in the current LP relaxation. Nevertheless, these variables still exist, and SCIP can calculate their reduced costs and add them to the LP again, if necessary. This is the job of the variable pricer. It is called before all other pricers.

4. How can I store branching decisions?

   This is a very common problem in Branch-And-Price, which you can deal nicely with using SCIP. There are basically three different options. The first one is to add binary variables to the problem that encode branching decisions. Then constraints should be added that enforce the corresponding branching decisions in the subtrees.

   If you have complex pricer data like a graph and need to update it after each branching decision, you should introduce "marker constraints" that are added to the branching nodes and store all the information needed (see the next question).

   The third way is to use an event handler, which is described here.

5. I want to store some information at the nodes and update my pricer's data structures when entering a new node. How can I do that?

   This can be done by creating a new constraint handler with constraint data that can store the information and do/undo changes in the pricer's data structures.

   Once you have such a constraint handler, just create constraints of this type and add them to the child nodes of your branching by SCIPaddConsNode(). Make sure to set the "stickingatnode" flag to TRUE in order to prevent SCIP from moving the constraint around in the tree.

   In general, all methods of the constraint handler (check, enforcing, separation, ...) should be empty (which means that they always return the status SCIP_FEASIBLE for the fundamental callbacks), just as if all constraints of this type are always feasible. The important callbacks are the CONSACTIVE and CONSDEACTIVE methods for communicating the constraints along the active path to your pricer, and the CONSDELETE callback for deleting data of constraints at nodes which became obsolete.

   The CONSACTIVE method is always called when a node is entered on which the constraint has been added. Here, you need to apply the changes to your pricing data structures. The CONSDEACTIVE method will be called if the node is left again. Since the CONSACTIVE and CONSDEACTIVE methods of different constraints are always called in a stack-like fashion, this should be exactly what you need.

   All data of a constraint need to be freed by implementing an appropriate CONSDELETE callback.

   If you need to fix variables for enforcing your branching decision, this can be done in the propagation callback of the constraint handler. Since, in general, each node is only propagated once, in this case you will have to check in your CONSACTIVE method whether new variables were added after your last propagation of this node. If this is the case, you will have to mark this node for repropagation by SCIPrepropagateNode().

   You can look into the constraint handler of the coloring problem (examples/Coloring/src/cons_storeGraph.c) to get an example of a constraint handler that does all these things.

6. How can an event handler help me with my branching?

   An event handler can watch for events like local bound changes on variables. So, if your pricer wants to be informed whenever a local bound of a certain variable changes, add an event handler, catch the corresponding events of the variable, and in the event handler's execution method adjust the data structures of your pricer accordingly.

7. How can I add locally valid variables to the problem in my branch-and-price code?

   Variables in SCIP are always added globally. If you want to add them locally, because they are forbidden in another part of the branch-and-bound-tree, you should ensure that they are locally fixed to 0 in all subtrees where they are not valid. A description of how this can be done is given here.

8. My pricer generates the same column twice. How can I solve this problem?

   First check whether your pricing is correct. Are there upper bounds on variables that you have forgotten to take into account? If your pricer cannot cope with variable bounds other than 0 and infinity, you have to mark all constraints containing priced variables as modifiable, and you may have to disable reduced cost strengthening by setting propagating/rootredcost/freq to -1.

   If your pricer works correctly and makes sure that the same column is added at most once in one pricing round, this behavior is probably caused by the PRICER_DELAY property of your pricer.

   If it is set to FALSE, the following may have happened: The variable pricer (see this question) found a variable with negative dual feasibility that was not part of the current LP relaxation and added it to the LP. In the same pricing round, your own pricer found the same column and created a new variable for it. This might happen, since your pricer uses the same dual values as the variable pricer. To avoid this behavior, set PRICER_DELAY to TRUE, so that the LP is reoptimized after the variable pricer added variables to the LP. You can find some more information about the PRICER_DELAY property at How to add variable pricers .

9. Which default plugins should be deactivated in order to get a working branch-and-price code?

   In most cases you should deactivate separators since cutting planes that are added to your master problem may destroy your pricing problem. Additionally, it may be necessary to deactivate some presolvers, mainly the dual fixing presolver. This can be done by not including these plugins into SCIP, namely by not calling SCIPincludeSepaXyz() and SCIPincludePresolXyz() in your own plugins-including files. Alternatively, you can set the parameters maxrounds and maxroundsroot to zero for all separators and maxrounds to zero for the presolvers.

10. What are the lazy bounds for variables in SCIP and what do I need them for?

    In many Branch-and-Price applications, you have binary variables, but you do not want to impose upper bounds on these variables in the LP relaxation, because the upper bound is already implicitly enforced by the problem constraints and the objective. If the upper bounds are explicitly added to the LP, they lead to further dual variables, which may be hard to take into account in the pricing problem.

    There are two possibilities for how to solve this problem. First, you could change the binary variables to general integer variables, if this does not change the problem. However, if you use special linear constraints like set partitioning/packing/covering, you can only add binary variables to these constraints.

    In order to still allow the usage of these types of constraints in a branch-and-price approach, the concept of lazy bounds was introduced in SCIP 2.0. For each variable, you can define lazy upper and lower bounds, i.e. bounds, that are implicitly enforced by constraints and objective. SCIP adds variable bounds to the LP only if the bound is tighter than the corresponding lazy bound. Note that lazy bounds are explicitly put into and removed from the LP when starting and ending diving mode, respectively. This is needed because changing the objective in diving might reverse the implicitly enforced bounds.

    For instance, if you have set partitioning constraints in your problem, you can define variables contained in these constraints as binary and set the lazy upper bound to 1, which allows you to use the better propagation methods of the setppc constraint handler compared to the linear constraint handler without taking care about upper bounds on variables in the master.

11. Can I stop the pricing process before the master problem is solved to optimality?

    In a column generation approach, you usually have to solve the master problem to optimality; otherwise, its objective function value is not a valid dual bound. However, there is a way in SCIP to stop the pricing process earlier, called "early branching".

    The reduced cost pricing method of a pricer has a result pointer that should be set each time the method is called. In the usual case that the pricer either adds a new variable or ensures that there are no further variables with negative dual feasibility, the result pointer should be set to SCIP_SUCCESS. If the pricer aborts pricing without creating a new variable, but there might exist additional variables with negative dual feasibility, the result pointer should be set to SCIP_DIDNOTRUN. In this case, the LP solution will not be used as a lower bound. Typically, early branching goes along with the computation of a Lagrangian bound in each pricing iteration. The pricer store store this valid lower bound in the lowerbound pointer in order to update the lower bound of the current node. Since SCIP 3.1, it is even possible to state that pricing should be stopped early even though new variables were created in the last pricing round. For this, the pricer has to set the stopearly pointer to TRUE.

12. How can I delete variables?

    SCIP features the functionality to delete variables from the problem when performing branch-and-price. This feature is still in a beta status and can be activated by switching the parameters pricing/delvars and pricing/delvarsroot to TRUE in order to allow deletion of variables at the root node and at all other nodes, respectively. Furthermore, variables have to be marked to be deletable by SCIPvarMarkDeletable(), which has to be done before adding the variable to the problem. Then, after a node of the branch-and-bound-tree is processed, SCIP automatically deletes variables from the problem that were created at the current node and whose corresponding columns were already removed from the LP. Note that due to the way SCIP stores basis information, it is not possible to completely delete a variable that was created at another node than the current node. You might want to change the parameters lp/colagelimit, lp/cleanupcols, and lp/cleanupcolsroot, which have an impact on when and how fast columns are removed from the LP.

    Constraint handlers support a new callback function that deletes variables from constraints in which they were marked to be deleted. Thus, when using automatic variable deletion, you should make sure that all used constraint handlers implement this callback. By now, the linear, the set partitioning/packing/covering and the knapsack constraint handler support this callback, which should be sufficient for most branch-and-price applications. Note that set covering constraints can be used instead of logicor constraints.

    Instead of deleting a variable completely, you can also remove it from the problem by either fixing the variable to zero using SCIPfixVar(), which fixes the variable globally or using SCIPchgVarUbNode() and SCIPchgVarLbNode(), which changes the bounds only for the current subtree.

13. How do I branch on constraints?

    Constraint-based branching is rather straightforward to implement in SCIP. You have to add a new branching rule that uses the methods SCIPcreateChild() and SCIPaddConsNode() in its branching callbacks. A very good example for this is the Ryan/Foster branching rule that has been implemented in the binpacking example from the examples section.

    Sometimes it might be more appropriate to implement a constraint handler instead of a branching rule. This is the case if, e.g., the added constraints alone do NOT ensure integrality of the integer variables, or if you still want to use the available branching rules. In the ENFOLP callback of your constraint handler, the branching really happens. The integrality constraint handler calls the branching rules within the ENFOLP callback. Give your constraint handler a positive enforcement priority to trigger your constraint branching before the integrality constraint handler and perform the constraint branching.

Specific questions about the copy functionality in SCIP

1. What is SCIPcopy()?

   The functionality of copying a SCIP model was added in SCIP version 2.0.0. It gives the possibility to generate a copy of the current SCIP model. This functionality is of interest, for example, in large neighborhood heuristics (such as heur_rens.c). They can now easily copy the complete problem and fix a certain set of variables to work on a reasonable copy of the original problem.

2. How do I get a copy of a variable or a constraint?

   For the variables and constraints there are the methods SCIPgetVarCopy() and SCIPgetConsCopy() which provide a copy for a variable or a constraint, respectively.

3. What does the valid pointer in the copy callback of the constraint handler and variable pricer mean?

   SCIP would like to know if the copied problem is a one to one copy. That is, if all problem defining objects were successfully copied. If this is the case, all reductions made in the copy can be transferred to the original instance. The problem defining objects in SCIP are the constraint handlers and the variable pricers.

Contact

For general information or questions about SCIP please write to [email protected]. Trouble compiling SCIP from source? Please check the build documentation before sending an email.
For questions about our SCIP interfaces on GitHub please open an issue in the corresponding repository.

Mailing List

The SCIP mailing list can be accessed via the SCIP mailing list page. You can conveniently search the archives using Google: site:listserv.zib.de/pipermail/scip

Stack Overflow

We are also watching the SCIP tag on stackoverflow.com and will answer your questions there.

Reporting Bugs

SCIP has more than 500,000 lines of source code and is definitely not bug free. If you'd like to help us improve SCIP, visit our bug submission page and file a bug report in English or German.

Known Bugs

Here is a list of known bugs in the current version:

• If one uses column generation and restarts, a solution that contains variables that are only present in the transformed problem (i.e., variables that were generated by a pricer) is not pulled back into the original space correctly, since the priced variables have no original counterpart. Therefore, one should disable restarts by setting the parameter "presolving/maxrestarts" to 0, if one uses a column generation approach.

Developers

Main developers

Gerald Gamrath	Column generation, mixed integer programming, branching rules
Ambros Gleixner	SoPlex interface, mixed integer nonlinear programming
Robert Gottwald	Shared memory parallelization
Gregor Hendel	Primal heuristics, mixed integer programming, solver intelligence
Stephen J. Maher	Mixed integer programming, Python interface
Matthias Miltenberger	SoPlex and Python interfaces, Probing propagator
Benjamin Müller	Mixed integer nonlinear programming, domain propagation
Marc Pfetsch	Special math programming constraints, former project head
Felipe Serrano	Nonlinear programming, cutting planes, Python interface
Dieter Weninger	Presolving, mixed integer programming
Jakob Witzig	Reoptimization, mixed integer programming

Further and former developers

Tobias Achterberg	Former main developer
Timo Berthold	Former main developer, primal heuristics, branching rules
Stefan Heinz	Former main developer, solution counting, global constraints, conflict analysis
Tobias Fischer	Constraint handler for special ordered sets, type one
Thorsten Koch	Project head
Alexandra Kraft	Former student assistant
Alexander Martin	Developer of SIP – the predecessor of SCIP
Stefan Vigerske	Former main developer, mixed integer nonlinear programming
Robert Waniek	Former student assistant
Michael Winkler	Former main developer, student assistant, presolving
Kati Wolter	Former main developer, cutting planes, exact integer programming

Contributors

Martin Ballerstein	Constraint Handler for bivariate nonlinear constraints
Chris Beck	Logic-based Bender's decomposition
Livio Bertacco	Interface to FICO/Xpress
Andreas Bley	VRP example
Tobias Buchwald	Dual value heuristic
Daniel Espinoza	Interface to QSopt
John Forrest	Interface to CLP
Thorsten Gellermann	Generic NLP interface
Bo Jensen	Interface to MOSEK
Manuel Kutschka	Separator for {0,1/2}-cuts
Anna Melchiori	Multi-aggregated variable branching rule
Dennis Michaels	Constraint Handler for bivariate nonlinear constraints
Giacomo Nannicini	GMI example
Michael Perregaard	Interface to FICO/Xpress
Frédéric Pythoud	Superindicator constraint handler
Christian Raack	Separator for MCF cuts
Jörg Rambau	Branch-and-Price contributions
Daniel Rehfeldt	Steiner Tree Problem application
Domenico Salvagnin	Feasibility Pump 2.0
Jens Schulz	Scheduling plugins: cumulative and linking constraint handler, variable bounds propagator
Cornelius Schwarz	Queens example
Robert Schwarz	Python interface
Felix Simon	JNI interface
Yuji Shinano	Parallel extension of SCIP
Dan Steffy	Exact integer programming
Timo Strunk	Multi-objective application
Andreas Tuchscherer	Branch-and-Price contributions
Ingmar Vierhaus	Nonlinear constraint parsing in CIP reader
Stefan Weltge	OBBT propagator

Related Work

Compiled list of all publications about SCIP on swMath.org

• Projects at ZIB that use SCIP

• • Optimization of Gas Transport,DFG Research Center Matheon, Project B20.
  • Advanced Solver Technology for SCM
  • DESI – Durchgängig energiesensible IKT-Produktion
  • Exact Integer Programming, DFG Priority Program 1307 Algorithm Engineering.
  • Integrated Planning of Multi-layer Networks, DFG Research Center Matheon,  Project B3.
  • Service Design in Public Transport, DFG Research Center Matheon,  Project B15.
  • ForNe: Research Cooperation Network Optimization
  • Chip Design Verification, DFG Research Center Matheon,  Project D17.
  • Discrete Morse Functions.
  • Infeasible Linear Inequality Systems.
  • MLTN - Multi-layer Transport Networks
  • Stable sets and special graph classes
  • Symmetries in Integer Programming, DFG Research Center Matheon,  Project B12.
  • VeriCount - Counting Solutions in the Field of Verification
  • SCIL – Symbolic Constraints in Integer Linear programming, Max-Planck-Institut für Informatik
  • Scheduling the SBB Cargo Railroad routing and shipment operations at night, Combinatorial Optimization & Graph Algorithms Group, TU Berlin.
  • Scheduling Techniques in Constraint Integer Programming , DFG Research Center Matheon,  Project B25.

• Projects using SCIP (outside ZIB)

• This is a list of only the projects we know, which may be quite incomplete.
  • DSP – Parallel Solver for Stochastic Mixed-integer Programming Problems
  • GOBNILP – Globally Optimal Bayesian Network learning using Integer Linear Programming, The University of York
  • Generic Decomposition Algorithms for Integer Programs, DFG Priority Program 1307 Algorithm Engineering. TU Darmstadt
  • Erzeugung von Zertifikaten für die Unzulässigkeit der technischen Kapazitäten an einem Netzpunkt, TU Braunschweig
  • Generic Column Generation , RWTH Aachen
  • Normaliz, a tool for computations in affine monoids, vector configurations, lattice polytopes, and rational cones developed at the University of Osnabrück.
  • Numberjack – A python constraint programming platform University College Cork

• Some Papers that use SCIP

• • Conflict Analysis in Mixed Integer Programming
    Tobias Achterberg
    Discrete Optimization, Special Issue 4, 2007
  • Hybrid Branching
    Tobias Achterberg, Timo Berthold
    Proc. of CPAIOR 2009, LNCS 5547, 05.2009.
    
  • Improving the Feasibility Pump
    Tobias Achterberg, Timo Berthold
    Discrete Optimization, Special Issue 4, 2007
  • Constraint Integer Programming: Techniques and Applications
    Tobias Achterberg, Timo Berthold, Stefan Heinz, Thorsten Koch, Kati Wolter
    ZIB-Report 08-43.
    
  • Constraint Integer Programming: a New Approach to Integrate CP and MIP
    Tobias Achterberg, Timo Berthold, Thorsten Koch, Kati Wolter
    Proc. of CPAIOR 2008, LNCS 5015, 2008
  • Teaching MIP Modeling and Solving
    Tobias Achterberg, Thorsten Koch, and Martin Grötschel
    ORMS Today 33, no. 6
    
  • Counting solutions of integer programs using unrestricted subtree detection
    Tobias Achterberg, Stefan Heinz, Thorsten Koch
    Proc. of CPAIOR 2008, LNCS 5015, 2008
  • Experiments with Linear and Semidefinite Relaxations for Solving the Minimum Graph Bisection Problem
    Michael Armbruster, Marzena Fügenschuh, Christoph Helmberg, and Alexander Martin
    Technical Report, TU Darmstadt, 2006
    
  • Constrained Clustering using Column Generation
    Babaki, B., Guns, T., Nijssen, S.
    CPAIOR, May 2014, Cork, Ireland
    
  • Heuristics of the Branch-Cut-and-Price-Framework SCIP
    Timo Berthold
    Operations Research Proceedings 2007
    
  • RENS - Relaxation Enforced Neighborhood Search
    Timo Berthold
    ZIB-Report 07-28
    
  • Rapid learning for binary programs
    Timo Berthold, Thibaut Feydy, Peter J. Stuckey
    Proc. of CPAIOR 2010, LNCS 6140
  • SCIP Optimization Suite を利用した 混合整数(線形/非線形) 計画問題の解法
    Timo Berthold, Ambros Gleixner, Stefan Heinz, Thorsten Koch, and Yuji Shinano.
    ZIB-Report 12-24
    
  • Undercover – a primal heuristic for MINLP based on sub-MIPs generated by set covering
    Timo Berthold, Ambros M. Gleixner
    ZIB-Report 09-40
    
  • A Constraint Integer Programming Approach for Resource-Constrained Project Scheduling
    Timo Berthold, Stefan Heinz, Marco Lübbecke, Rolf H. Möhring, Jens Schulz
    Proc. of CPAIOR 2010, LNCS 6140
  • Nonlinear pseudo-Boolean optimization: relaxation or propagation?
    Timo Berthold, Stefan Heinz, Marc E. Pfetsch
    Theory and Applications of Satisfiability Testing – SAT 2009, LNCS 5584, 2009
    
  • Solving Pseudo-Boolean Problems with SCIP
    Timo Berthold, Stefan Heinz, Marc E. Pfetsch
    ZIB-Report 08-12
    
  • Extending a CIP framework to solve MIQCPs
    Timo Berthold, Stefan Heinz, Stefan Vigerske
    ZIB-Report 09-23
    
  • Comparing MIQCP solvers to a specialised algorithm for mine production scheduling
    Andreas Bley, Ambros M. Gleixner, Thorsten Koch, Stefan Vigerske
    ZIB-Report 09-32
    
  • Auslegung heterogener Kommunikationsnetze nach Performance und Wirtschaftlichkeit
    Andreas Bley, Friederich Kupzog, and Adrian Zymolka
    Proc. of the 11th Kasseler Symposium Energie-Systemtechnik: Energie und Kommunikation, 2006
    
  • Angebotsplanung im öffentlichen Nahverkehr
    Ralf Borndörfer, Marika Neumann, Marc E. Pfetsch
    ZIB-Report 08-04, to appear in Heureka'08
    
  • The Location-Dispatching Problem: polyhedral results and Content Delivery Network Design
    Philippe Chrétienne, Pierre Fouilhoux, Eric Gourdin, and Jean-Mathieu Segura
    Electronic Notes in Discrete Mathematics 26, 867-874, 2010
    
  • A Branch-and-Price Algorithm for Multi-mode Resource Leveling
    Eamonn T. Coughlan, Marco E. Lübbecke and Jens Schulz
    Proc. of SEA 2010, LNCS 6049, 226-238, 2010
    
  • Optimal control of spatial-dynamic processes: the case of biological invasions
    Rebecca S. Epanchin-Niell and James E. Wilen
    Agricultural and Applied Economics Association 2010 Annual Meeting
    
  • Integer linear programming models for topology optimization in sheet metal design
    Armin Fügenschuh and Marzena Fügenschuh
    Mathematical Methods of Operations Research, to appear (2008)
    
  • Scenario Technique with Integer Programming for Sustainability in Manufacturing
    Armin Fügenschuh, Pia Gausemeier, Günther Seliger, and Semih Severengiz
    Lecture Notes in Business Information Processing 46, 320-331, 2010
    
  • Experiments with a Generic Dantzig-Wolfe Decomposition for Integer Programs
    Gerald Gamrath and Marco E. Lübbecke
    Proc. of SEA 2010, LNCS 6049, 239-252, 2010
    
  • Using Model Counting to Find Optimal Distinguishing Tests
    Stefan Heinz and Martin Sachenbacher
    Proc. of CPAIOR 2009, LNCS 5547
    
  • Exact and Approximate Sparse Solutions of Underdetermined Linear Equations
    Sadegh Jokar, Marc E. Pfetsch
    ZIB-Report 07-05
    
  • Computing Optimal Morse Matchings
    Michael Joswig and Marc E. Pfetsch
    SIAM Journal on Discrete Mathematics 20, no. 1, 2006
    
  • Orbitopal Fixing
    Volker Kaibel, Matthias Peinhardt, and Marc E. Pfetsch
    Proc. of the 12th Integer Programming and Combinatorial Optimization conference (IPCO)
    M. Fischetti and D. Williamson (eds.), LNCS 4513, Springer-Verlag, 74-88, 2007
    
  • On connectivity limits in ad hoc networks with beamforming antennas
    Moritz Kiese, Christian Hartmann, Julian Lamberty, and Robert Vilzmann
    EURASIP Journal on Wireless Communications and Networking 2009, No.7, 74-88, 02.2009
    
  • Approximated segmentation considering technical and dosimetric constraints in intensity-modulated radiation therapy with electrons
    Antje Kiesel and Tobias Gauer
    ArXiv e-prints, May 2010
  • Rapid Mathematical Programming or How to Solve Sudoku Puzzles in a few Seconds
    Thorsten Koch
    Operations Research Proceedings 2005
    
  • Algorithms to separate {0,1/2}-Chvatal-Gomory cuts
    Arie M. C. A. Koster, Adrian Zymolka and Manuel Kutschka
    Algorithmica 55, No. 2, 375-391
    
  • A formulation space search heuristic for packing unequal circles in a fixed size circular container
    C. O. López and J. E. Beasley
    European Journal of Operational Research 251 (2016) 64–73
    
  • Large-scale identification of genetic design strategies using local search
    Desmond S. Lun, Graham Rockwell, Nicholas J. Guido, Michael Baym, Jonathan A. Kelner, Bonnie Berger, James E. Galagan, and George M. Church
    Molecular Systems Biology 5, No. 296, 2009
    
  • Optimization Methods For Selecting Founder Individuals For Captive Breeding or reintroduction of Endangered Species
    Webb Miller, Stephen J. Wright, Yu Zhang, Stephan C. Schuster, Vanessa M. Hayes
    Pacific Symposium on Biocomputing, 43-53, 2010
    
  • Two-layer Network Design by Branch-and-Cut featuring MIP-based Heuristics
    Sebastian Orlowski, Arie M. C. A. Koster, Christian Raack, and Roland Wessäly
    Proceedings of the Third International Network Optimization Conference, 2007
    
  • Branch-And-Cut for the Maximum Feasible Subsystem Problem
    Marc E. Pfetsch
    SIAM Journal on Optimization 19, No. 1, 21-38 (2008)
    
  • Integer Programming and Sports Rankings
    Christian Raack, Annie Raymond, Thomas Schlechte, Axel Werner
    ZIB-Report 13-19
    
  • Rostering from staffing levels: a branch-and-price approach
    Egbert van der Veen and Bart Veltman
    Proc. of the 35th International Conference on Operational Research Applied to Health Services, 1-10, 2009
    
  • Faster MIP solutions via new node selection rules
    Daniel T. Wojtaszeka and John W. Chinneck
    Computers & Operations Research 37, 1544-1556, September 2009
    
  • Robust Aircraft Routing
    Chiwei Yan and Jerry Kung
    INFORMS Transportation Science, July 2016
    

If you know about further projects or papers that use SCIP, please let us know.

Cooperation

SCIP is developed in cooperation with

Solving MIPs exactly over the rational numbers

As all standard MIP solvers, SCIP works with finite precision binary floating-point arithmetic. This allows efficient computations, but also introduces rounding errors. To some extent, rounding errors can be handled by using tolerances at certain parts of the solving process (e.g., when testing the feasibility of primal solutions w.r.t. constraints and bounds). However, this by no means guarantees truely correct results.

For most applications, the errors can be neglected. This situation changes fundamentally, if MIPs are used to study theoretical problems, if feasibility questions are considered, and if wrong answers can have legal consequences. For such applications, an exact MIP solver is required.

There is now a beta-version of SCIP available (based on SCIP 3.0.0) which can solve MIP instances exactly over the rational numbers. So far, the branch-and-bound algorithm of SCIP has been adapted for exact MIP solving. It works with safe primal and dual bounds and supports all branching plugins of SCIP. All additional plugins, like separators, primal heuristics, and presolvers must not be included (adding them might introduce rounding errors).

This project is supported by the DFG Priority Program 1307 "Algorithm Engineering".

Authors

• Kati Wolter
• Dan Steffy

Notes

• This is a beta-version.
• The code only supports solving MIPs.
• The code can only be used as a black box solver.

Download

You can download the source code of the SCIP distribution that supports solving MIPs exactly here.

It can be compiled in exact solving mode or in standard solving mode using floating-point arithmetic. In the latter case, you will get the same solver/behavior as with the official distribution of SCIP 3.0.0.

For information, see "Installation description for SCIP in exact solving mode" in the contained INSTALL file and "How to use SCIP in exact solving mode" in your local doxygen docu (via "make doc").

References

• A Hybrid Branch-and-Bound Approach for Exact Rational Mixed-Integer Programming William Cook, Thorsten Koch, Daniel E. Steffy, and Kati Wolter
  Available as ZIB-Report 12-49, 2012
• An Exact Rational Mixed-Integer Programming Solver William Cook, Thorsten Koch, Daniel E. Steffy, and Kati Wolter
  IPCO 2011: The 15th Conference on Integer Programming and Combinatorial Optimization, LNCS 6655, 104-116, 2011. Available as ZIB-Report 11-07, 2011
• Valid Linear Programming Bounds for Exact Mixed-Integer Programming Daniel E. Steffy and Kati Wolter
  INFORMS Journal on Computing, 25(2):271-284, 2013. Available as ZIB-Report 11-08, 2011