Skip to content
Show whitespace changes
Inline Side-by-side
libs/or-tools-src-ubuntu/include/scip/heur_intdiving.h 0 → 100644
View file @ a9bd42a2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file heur_intdiving.h
* @ingroup PRIMALHEURISTICS
* @brief LP diving heuristic that fixes variables with integral LP value
* @author Tobias Achterberg
*
* Diving heuristic: Iteratively fixes some fractional variable and resolves the LP-relaxation, thereby simulating a
* depth-first-search in the tree. Integer Diving fixes variables with integral LP values in order to enable further
* domain propagations. One-level backtracking is applied: If the LP gets infeasible, the last fixing is undone, and
* the opposite fixing is tried. If this is infeasible, too, the procedure aborts.
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_HEUR_INTDIVING_H__
#define __SCIP_HEUR_INTDIVING_H__
#include "scip/def.h"
#include "scip/type_retcode.h"
#include "scip/type_scip.h"
#ifdef __cplusplus
extern "C" {
#endif
/** creates the intdiving heuristic and includes it in SCIP
*
* @ingroup PrimalHeuristicIncludes
*/
SCIP_EXPORT
SCIP_RETCODE SCIPincludeHeurIntdiving(
SCIP* scip /**< SCIP data structure */
);
#ifdef __cplusplus
}
#endif
#endif
libs/or-tools-src-ubuntu/include/scip/heur_intshifting.h 0 → 100644
View file @ a9bd42a2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file heur_intshifting.h
* @ingroup PRIMALHEURISTICS
* @brief LP rounding heuristic that tries to recover from intermediate infeasibilities, shifts integer variables, and
* solves a final LP to calculate feasible values for continuous variables
* @author Tobias Achterberg
*
* This heuristic is similar to the Shifting heuristic (see @ref heur_shifting.h), but it ignores continuous variables
* during the shifting phase and solves a final LP to find feasible (and optimal w.r.t. the integer fixings) values for
* the continuous variables.
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_HEUR_INTSHIFTING_H__
#define __SCIP_HEUR_INTSHIFTING_H__
#include "scip/def.h"
#include "scip/type_retcode.h"
#include "scip/type_scip.h"
#ifdef __cplusplus
extern "C" {
#endif
/** creates the intshifting heuristic and includes it in SCIP
*
* @ingroup PrimalHeuristicIncludes
*/
SCIP_EXPORT
SCIP_RETCODE SCIPincludeHeurIntshifting(
SCIP* scip /**< SCIP data structure */
);
#ifdef __cplusplus
}
#endif
#endif
libs/or-tools-src-ubuntu/include/scip/heur_linesearchdiving.h 0 → 100644
View file @ a9bd42a2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file heur_linesearchdiving.h
* @ingroup PRIMALHEURISTICS
* @brief LP diving heuristic that fixes variables with a large difference to their root solution
* @author Tobias Achterberg
*
* Diving heuristic: Iteratively fixes some fractional variable and resolves the LP-relaxation, thereby simulating a
* depth-first-search in the tree. Line search diving chooses the variable with the greatest difference of its root LP
* solution and the current LP solution, hence, the variable that developed most. It is fixed to the next integer in
* the direction it developed. One-level backtracking is applied: If the LP gets infeasible, the last fixing is undone,
* and the opposite fixing is tried. If this is infeasible, too, the procedure aborts.
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_HEUR_LINESEARCHDIVING_H__
#define __SCIP_HEUR_LINESEARCHDIVING_H__
#include "scip/def.h"
#include "scip/type_retcode.h"
#include "scip/type_scip.h"
#ifdef __cplusplus
extern "C" {
#endif
/** creates the linesearchdiving primal heuristic and includes it in SCIP
*
* @ingroup PrimalHeuristicIncludes
*/
SCIP_EXPORT
SCIP_RETCODE SCIPincludeHeurLinesearchdiving(
SCIP* scip /**< SCIP data structure */
);
#ifdef __cplusplus
}
#endif
#endif
libs/or-tools-src-ubuntu/include/scip/heur_localbranching.h 0 → 100644
View file @ a9bd42a2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file heur_localbranching.h
* @ingroup PRIMALHEURISTICS
* @brief Local branching heuristic according to Fischetti and Lodi
* @author Timo Berthold
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_HEUR_LOCALBRANCHING_H__
#define __SCIP_HEUR_LOCALBRANCHING_H__
#include "scip/def.h"
#include "scip/type_retcode.h"
#include "scip/type_scip.h"
#ifdef __cplusplus
extern "C" {
#endif
/** creates local branching primal heuristic and includes it in SCIP
*
* @ingroup PrimalHeuristicIncludes
*/
SCIP_EXPORT
SCIP_RETCODE SCIPincludeHeurLocalbranching(
SCIP* scip /**< SCIP data structure */
);
#ifdef __cplusplus
}
#endif
#endif
libs/or-tools-src-ubuntu/include/scip/heur_locks.h 0 → 100644
View file @ a9bd42a2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file heur_locks.h
* @ingroup PRIMALHEURISTICS
* @brief locks primal heuristic
* @author Michael Winkler
* @author Gerald Gamrath
*
* The locks heuristic is a start heuristic that first tries to fix all binary variables, then solves the resulting LP
* and tries to round the solution and finally solves a sub-MIP on the remaining problem if the LP solution could not be
* rounded. The fixing works as follows: First, all variables are sorted by their total number of rounding locks (up-
* and down-locks summed up). Then, looking at the variable with the highest number of locks first, the variable is
* fixed to the bound where there are fewer locks (in case of ties, the bound which is better w.r.t. the objective
* function). This fix is propagated and the activities of all LP rows are updated. If any LP row becomes redundant
* w.r.t. the updated bounds, we adjust the rounding locks.
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_HEUR_LOCKS_H__
#define __SCIP_HEUR_LOCKS_H__
#include "scip/def.h"
#include "scip/type_heur.h"
#include "scip/type_retcode.h"
#include "scip/type_scip.h"
#ifdef __cplusplus
extern "C" {
#endif
/** creates the locks primal heuristic and includes it in SCIP
*
* @ingroup PrimalHeuristicIncludes
*/
SCIP_EXPORT
SCIP_RETCODE SCIPincludeHeurLocks(
SCIP* scip /**< SCIP data structure */
);
/** apply fix-and-propagate scheme based on variable locks
*
* @note probing mode of SCIP needs to be enabled before
*/
SCIP_EXPORT
SCIP_RETCODE SCIPapplyLockFixings(
SCIP* scip, /**< SCIP data structure */
SCIP_HEURDATA* heurdata, /**< primal heuristic data */
SCIP_Bool* cutoff, /**< pointer to store if a cutoff was detected */
SCIP_Bool* allrowsfulfilled /**< pointer to store if all rows became redundant */
);
#ifdef __cplusplus
}
#endif
#endif
libs/or-tools-src-ubuntu/include/scip/heur_lpface.h 0 → 100644
View file @ a9bd42a2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file heur_lpface.h
* @ingroup PRIMALHEURISTICS
* @brief LNS heuristic that tries to compute integral solution on optimal LP face
* @author Gregor Hendel
*
* @todo doc
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_HEUR_LPFACE_H__
#define __SCIP_HEUR_LPFACE_H__
#include "scip/def.h"
#include "scip/type_retcode.h"
#include "scip/type_scip.h"
#ifdef __cplusplus
extern "C" {
#endif
/** creates the lpface primal heuristic and includes it in SCIP
*
* @ingroup PrimalHeuristicIncludes
*/
SCIP_EXPORT
SCIP_RETCODE SCIPincludeHeurLpface(
SCIP* scip /**< SCIP data structure */
);
#ifdef __cplusplus
}
#endif
#endif
libs/or-tools-src-ubuntu/include/scip/heur_mpec.h 0 → 100644
View file @ a9bd42a2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file heur_mpec.h
* @ingroup PRIMALHEURISTICS
* @brief mpec primal heuristic
* @author Felipe Serrano
* @author Benjamin Mueller
*
* This heuristic is based on the paper:
* @par
* Lars Schewe and Martin Schmidt@n
* [Computing Feasible Points for MINLPs with MPECs](http://www.optimization-online.org/DB_HTML/2016/12/5778.html)
*
* An MPEC is a mathematical program with complementarity constraint.
* For example, the constraint \f$x \in \{0, 1\}\f$ as \f$x (1-x) = 0\f$
* can be modeled as complementarity constraint \f$x = 0\f$ or \f$x = 1\f$.
*
* This heuristic applies only to mixed binary nonlinear problems.
* The idea is to rewrite the MBNLP as MPEC and solve the MPEC instead (to a
* a local optimum) by replacing each integrality constraint by the
* complementarity constraint \f$x = 0\f$ or \f$x = 1\f$.
* In principle, this MPEC can be reformulated to a NLP by rewriting this
* constraint as equation \f$x (1-x) = 0\f$.
* However, solving this NLP reformulation with a generic NLP solver will
* often fail. One issue is that the reformulated complementarity constraints
* will not, in general, satisfy constraint qualifications (for instance,
* Slater's conditions, which requires the existence of a relative interior
* point, will not be satisfied).
* In order to increase the chances of solving the NLP reformulation of
* the MPEC by a NLP solver, the heuristic applies a regularization
* (proposed by Scholtes): it relaxes \f$x(1-x) = 0\f$ to
* \f$x(1-x) \leq \theta\f$.
*
* So the heuristic proceeds as follows.
* - Build the regularized NLP (rNLP) with a starting \f$\theta \in (0, \tfrac{1}{4}\f$.
* - Give the current LP solution as starting point to the NLP solver.
* - Solves rNLP and let \f$x^*\f$ be the best point found (if there is no point, abort).
* - If feasible, then reduce \f$\theta\f$ by a factor \f$\sigma\f$ and use
* its solution as the starting point for the next iteration.
*
* - If the rNLP is found infeasible, but the regularization constraints are feasible, abort.
*
* - If some variable violates the regularization constraint, i.e.,
* \f$x^*_i(1-x^*_i) > \tau\f$ then solve the rNLP again using its starting solution
* modified by \f$x_i = 0\f$ if \f$x^*_i > 0.5\f$ and \f$x_i = 1\f$ if \f$x^*_i < 0.5\f$.
* One possible explanation for this choice is that, assuming \f$x^*_i > 0.5\f$,
* if really \f$x_i = 1\f$ were a solution, then the NLP solver should not have had troubles
* pushing \f$x_i\f$ towards 1, making at least the regularization constraint feasible.
* Instead, it might be that there is a solution with \f$x_i = 0\f$, but since \f$x^*_i > 0.5\f$
* the NLP solver is having more problems pushing it to 0.
*
* - If the modification of the starting point did not help finding a feasible solution,
* solve the problem again, but now fixing the problematic variables using the same criteria.
*
* - If still we do not get a feasible solution, abort (note that the paper suggests to backtrack,
* but this might be just too expensive).
*
* - If the maximum binary infeasibility is small enough, call sub-NLP heuristic
* with binary variables fixed to the value suggested by \f$x^*\f$.
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_HEUR_MPEC_H__
#define __SCIP_HEUR_MPEC_H__
#include "scip/def.h"
#include "scip/type_retcode.h"
#include "scip/type_scip.h"
#ifdef __cplusplus
extern "C" {
#endif
/** creates the mpec primal heuristic and includes it in SCIP
*
* @ingroup PrimalHeuristicIncludes
*/
SCIP_EXPORT
SCIP_RETCODE SCIPincludeHeurMpec(
SCIP* scip /**< SCIP data structure */
);
#ifdef __cplusplus
}
#endif
#endif
libs/or-tools-src-ubuntu/include/scip/heur_multistart.h 0 → 100644
View file @ a9bd42a2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file heur_multistart.h
* @ingroup PRIMALHEURISTICS
* @brief multistart heuristic for convex and nonconvex MINLPs
* @author Benjamin Mueller
*
* The heuristic applies multiple NLP local searches to a mixed-integer nonlinear program with, probably nonconvex,
* constraints of the form \f$g_j(x) \le 0\f$. The algorithm tries to identify clusters which approximate the boundary
* of the feasible set of the continuous relaxation by sampling and improving randomly generated points. For each
* cluster we use a local search heuristic to find feasible solutions. The algorithm consists of the following four
* steps:
*
* 1. sample points
*
* Sample random points \f$ x^1, \ldots, x^n \f$ in the box \f$ [\ell,u] \f$. For an unbounded variable \f$ x_i \f$
* we consider \f$ [\ell_i,\ell_i + \alpha], [u_i - \alpha,u_i], \f$ or \f$ [-\alpha / 2, \alpha / 2]\f$ for an \f$
* \alpha > 0 \f$ depending on which bound is infinite.
*
* 2. reduce infeasibility
*
* For each point \f$ x^i \f$ we use a gradient descent method to reduce the maximum infeasibility. We first compute
*
* \f[
* d_j = -\frac{g_j(x^i)}{||\nabla g_j(x^i)||^2} \nabla g_j(x^i)
* \f]
*
* and update the current point \f$ x^i \f$ with
*
* \f[
* x^i := x^i + \frac{1}{n_j} \sum_{j} d_j
* \f]
*
* where \f$ n_j \f$ is the number of strictly positive \f$ d_j \f$. The algorithm is called Constraint Consensus
* Method and has been introduced by <a
* href="http://www.sce.carleton.ca/faculty/chinneck/docs/ConstraintConsensusJoC.pdf">here </a>.
*
* 3. cluster points
*
* We use a greedy algorithm to all of the resulting points of step 3. to find clusters which (hopefully) approximate
* the boundary of the feasible set locally. Points with a too large violations will be filtered.
*
* 4. solve sub-problems
*
* Depending on the current setting, we solve a sub-problem for each identified cluster. The default strategy is to
* compute a starting point for the sub-NLP heuristic (see @ref heur_subnlp.h) by using a linear combination of the
* points in a cluster \f$ C \f$, i.e.,
*
* \f[
* s := \sum_{x \in C} \lambda_x x
* \f]
*
* Since the sub-NLP heuristic requires a starting point which is integer feasible we round each fractional
* value \f$ s_i \f$ to its closest integer.
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_HEUR_MULTISTART_H__
#define __SCIP_HEUR_MULTISTART_H__
#include "scip/def.h"
#include "scip/type_retcode.h"
#include "scip/type_scip.h"
#ifdef __cplusplus
extern "C" {
#endif
/** creates the multistart primal heuristic and includes it in SCIP
*
* @ingroup PrimalHeuristicIncludes
*/
SCIP_EXPORT
SCIP_RETCODE SCIPincludeHeurMultistart(
SCIP* scip /**< SCIP data structure */
);
#ifdef __cplusplus
}
#endif
#endif
libs/or-tools-src-ubuntu/include/scip/heur_mutation.h 0 → 100644
View file @ a9bd42a2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file heur_mutation.h
* @ingroup PRIMALHEURISTICS
* @brief LNS heuristic that tries to randomly mutate the incumbent solution
* @author Timo Berthold
*
* Mutation is a large neighborhood search improvement heuristic that is inspired by genetic algorithms and requires a
* known feasible solution. It randomly fixes variables to their value in the incumbent solution and solves a sub-SCIP,
* consisting of the remaining variables. See also @ref heur_crossover.h
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_HEUR_MUTATION_H__
#define __SCIP_HEUR_MUTATION_H__
#include "scip/def.h"
#include "scip/type_retcode.h"
#include "scip/type_scip.h"
#ifdef __cplusplus
extern "C" {
#endif
/** creates the mutation primal heuristic and includes it in SCIP
*
* @ingroup PrimalHeuristicIncludes
*/
SCIP_EXPORT
SCIP_RETCODE SCIPincludeHeurMutation(
SCIP* scip /**< SCIP data structure */
);
#ifdef __cplusplus
}
#endif
#endif
libs/or-tools-src-ubuntu/include/scip/heur_nlpdiving.h 0 → 100644
View file @ a9bd42a2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file heur_nlpdiving.h
* @ingroup PRIMALHEURISTICS
* @brief NLP diving heuristic that chooses fixings w.r.t. the fractionalities
* @author Timo Berthold
* @author Stefan Vigerske
*
* Diving heuristic: Iteratively fixes some fractional variable and resolves the NLP-relaxation, thereby simulating a
* depth-first-search in the tree. Fractional Diving chooses the variable with the highest fractionality and rounds it to the
* nearest integer. One-level backtracking is applied: If the NLP gets infeasible, the last fixing is undone, and the
* opposite fixing is tried. If this is infeasible, too, the procedure aborts.
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_HEUR_NLPDIVING_H__
#define __SCIP_HEUR_NLPDIVING_H__
#include "scip/def.h"
#include "scip/type_retcode.h"
#include "scip/type_scip.h"
#ifdef __cplusplus
extern "C" {
#endif
/** creates the fracdiving heuristic and includes it in SCIP
*
* @ingroup PrimalHeuristicIncludes
*/
SCIP_EXPORT
SCIP_RETCODE SCIPincludeHeurNlpdiving(
SCIP* scip /**< SCIP data structure */
);
#ifdef __cplusplus
}
#endif
#endif
libs/or-tools-src-ubuntu/include/scip/heur_objpscostdiving.h 0 → 100644
View file @ a9bd42a2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file heur_objpscostdiving.h
* @ingroup PRIMALHEURISTICS
* @brief LP diving heuristic that changes variable's objective value instead of bounds, using pseudo cost values as guide
* @author Tobias Achterberg
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_HEUR_OBJPSCOSTDIVING_H__
#define __SCIP_HEUR_OBJPSCOSTDIVING_H__
#include "scip/def.h"
#include "scip/type_retcode.h"
#include "scip/type_scip.h"
#ifdef __cplusplus
extern "C" {
#endif
/** creates the objpscostdiving heuristic and includes it in SCIP
*
* @ingroup PrimalHeuristicIncludes
*/
SCIP_EXPORT
SCIP_RETCODE SCIPincludeHeurObjpscostdiving(
SCIP* scip /**< SCIP data structure */
);
#ifdef __cplusplus
}
#endif
#endif
libs/or-tools-src-ubuntu/include/scip/heur_octane.h 0 → 100644
View file @ a9bd42a2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file heur_octane.h
* @ingroup PRIMALHEURISTICS
* @brief octane primal heuristic based on Balas, Ceria, Dawande, Margot, and Pataki
* @author Timo Berthold
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_HEUR_OCTANE_H__
#define __SCIP_HEUR_OCTANE_H__
#include "scip/def.h"
#include "scip/type_retcode.h"
#include "scip/type_scip.h"
#ifdef __cplusplus
extern "C" {
#endif
/** creates the octane primal heuristic and includes it in SCIP
*
* @ingroup PrimalHeuristicIncludes
*/
SCIP_EXPORT
SCIP_RETCODE SCIPincludeHeurOctane(
SCIP* scip /**< SCIP data structure */
);
#ifdef __cplusplus
}
#endif
#endif
libs/or-tools-src-ubuntu/include/scip/heur_ofins.h 0 → 100644
View file @ a9bd42a2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file heur_ofins.h
* @ingroup PRIMALHEURISTICS
* @brief OFINS - Objective Function Induced Neighborhood Search - a primal heuristic for reoptimization
* @author Jakob Witzig
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_HEUR_OFINS_H__
#define __SCIP_HEUR_OFINS_H__
#include "scip/def.h"
#include "scip/type_retcode.h"
#include "scip/type_scip.h"
#ifdef __cplusplus
extern "C" {
#endif
/** creates the ofins primal heuristic and includes it in SCIP
*
* @ingroup PrimalHeuristicIncludes
*/
SCIP_EXPORT
SCIP_RETCODE SCIPincludeHeurOfins(
SCIP* scip /**< SCIP data structure */
);
#ifdef __cplusplus
}
#endif
#endif
libs/or-tools-src-ubuntu/include/scip/heur_oneopt.h 0 → 100644
View file @ a9bd42a2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file heur_oneopt.h
* @ingroup PRIMALHEURISTICS
* @brief Improvement heuristic that alters single variable values
* @author Timo Berthold
*
* Oneopt is a straightforward improvement heuristic: given a feasible MIP solution, the value of
* an integer variable x<sub>j</sub> can be decreased for c<sub>j</sub> > 0 or increased for c<sub>j</sub> < 0
* if the resulting solution is still feasible. If more than one variable can be shifted, they are sorted by
* non-decreasing impact on the objective and sequentially shifted until no more improvements can be
* obtained.
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_HEUR_ONEOPT_H__
#define __SCIP_HEUR_ONEOPT_H__
#include "scip/def.h"
#include "scip/type_retcode.h"
#include "scip/type_scip.h"
#ifdef __cplusplus
extern "C" {
#endif
/** creates the oneopt primal heuristic and includes it in SCIP
*
* @ingroup PrimalHeuristicIncludes
*/
SCIP_EXPORT
SCIP_RETCODE SCIPincludeHeurOneopt(
SCIP* scip /**< SCIP data structure */
);
#ifdef __cplusplus
}
#endif
#endif
libs/or-tools-src-ubuntu/include/scip/heur_padm.h 0 → 100644
View file @ a9bd42a2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file heur_padm.h
* @ingroup PRIMALHEURISTICS
* @brief PADM primal heuristic based on ideas published in the paper
* "A Decomposition Heuristic for Mixed-Integer Supply Chain Problems"
* by Martin Schmidt, Lars Schewe, and Dieter Weninger
* @author Dieter Weninger
* @author Katrin Halbig
*
* The penalty alternating direction method (PADM) heuristic is a construction heuristic which additionally needs a
* user decomposition with linking variables only.
*
* PADM splits the problem into several sub-SCIPs according to the decomposition, whereby the linking variables get
* copied and the difference is penalized. Then the sub-SCIPs are solved on an alternating basis until they arrive at
* the same values of the linking variables (ADM-loop). If they don't reconcile after a couple of iterations,
* the penalty parameters are increased (penalty-loop) and the sub-SCIPs are solved again on an alternating basis.
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_HEUR_PADM_H__
#define __SCIP_HEUR_PADM_H__
#include "scip/def.h"
#include "scip/type_retcode.h"
#include "scip/type_scip.h"
#ifdef __cplusplus
extern "C" {
#endif
/** creates the PADM primal heuristic and includes it in SCIP
*
* @ingroup PrimalHeuristicIncludes
*/
SCIP_EXPORT
SCIP_RETCODE SCIPincludeHeurPADM(
SCIP* scip /**< SCIP data structure */
);
#ifdef __cplusplus
}
#endif
#endif
libs/or-tools-src-ubuntu/include/scip/heur_proximity.h 0 → 100644
View file @ a9bd42a2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file heur_proximity.h
* @ingroup PRIMALHEURISTICS
* @brief improvement heuristic which uses an auxiliary objective instead of the original objective function which
* is itself added as a constraint to a sub-SCIP instance. The heuristic was presented by Matteo Fischetti
* and Michele Monaci
* @author Gregor Hendel
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_HEUR_PROXIMITY_H__
#define __SCIP_HEUR_PROXIMITY_H__
#include "scip/def.h"
#include "scip/type_heur.h"
#include "scip/type_result.h"
#include "scip/type_retcode.h"
#include "scip/type_scip.h"
#ifdef __cplusplus
extern "C" {
#endif
/** creates the proximity primal heuristic and includes it in SCIP
*
* @ingroup PrimalHeuristicIncludes
*/
SCIP_EXPORT
SCIP_RETCODE SCIPincludeHeurProximity(
SCIP* scip /**< SCIP data structure */
);
/**@addtogroup PRIMALHEURISTICS
*
* @{
*/
/** main procedure of the proximity heuristic, creates and solves a sub-SCIP
*
* @note the method can be applied in an iterative way, keeping the same subscip in between. If the @p freesubscip
* parameter is set to FALSE, the heuristic will keep the subscip data structures. Always set this parameter
* to TRUE, or call SCIPdeleteSubproblemProximity() afterwards
*/
SCIP_EXPORT
SCIP_RETCODE SCIPapplyProximity(
SCIP* scip, /**< original SCIP data structure */
SCIP_HEUR* heur, /**< heuristic data structure */
SCIP_RESULT* result, /**< result data structure */
SCIP_Real minimprove, /**< factor by which proximity should at least improve the incumbent */
SCIP_Longint nnodes, /**< node limit for the subproblem */
SCIP_Longint nlpiters, /**< LP iteration limit for the subproblem */
SCIP_Longint* nusednodes, /**< pointer to store number of used nodes in subscip */
SCIP_Longint* nusedlpiters, /**< pointer to store number of used LP iterations in subscip */
SCIP_Bool freesubscip /**< should the created sub-MIP be freed at the end of the method? */
);
/** frees the sub-MIP created by proximity */
SCIP_EXPORT
SCIP_RETCODE SCIPdeleteSubproblemProximity(
SCIP* scip /** SCIP data structure */
);
/** @} */
#ifdef __cplusplus
}
#endif
#endif
libs/or-tools-src-ubuntu/include/scip/heur_pscostdiving.h 0 → 100644
View file @ a9bd42a2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file heur_pscostdiving.h
* @ingroup PRIMALHEURISTICS
* @brief LP diving heuristic that chooses fixings w.r.t. the pseudo cost values
* @author Tobias Achterberg
*
* Diving heuristic: Iteratively fixes some fractional variable and resolves the LP-relaxation, thereby simulating a
* depth-first-search in the tree. Pseudocost Diving chooses the variable with the smallest ratio of estimated objective
* increase if rounding to either direction. If the variable is significantly different from its root LP vlaue, it will
* be rounded into the direction it developed (see @ref heur_linesearchdiving.h), if it is close to an integral point,
* it will be rounded to that one, otherwise it will be rounded into the direction of lower pseudocosts. One-level
* backtracking is applied: If the LP gets infeasible, the last fixing is undone, and the opposite fixing is tried. If
* this is infeasible, too, the procedure aborts.
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_HEUR_PSCOSTDIVING_H__
#define __SCIP_HEUR_PSCOSTDIVING_H__
#include "scip/def.h"
#include "scip/type_retcode.h"
#include "scip/type_scip.h"
#ifdef __cplusplus
extern "C" {
#endif
/** creates the pscostdiving heuristic and includes it in SCIP
*
* @ingroup PrimalHeuristicIncludes
*/
SCIP_EXPORT
SCIP_RETCODE SCIPincludeHeurPscostdiving(
SCIP* scip /**< SCIP data structure */
);
#ifdef __cplusplus
}
#endif
#endif
libs/or-tools-src-ubuntu/include/scip/heur_randrounding.h 0 → 100644
View file @ a9bd42a2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file heur_randrounding.h
* @ingroup PRIMALHEURISTICS
* @brief randomized LP rounding heuristic which also generates conflicts via an auxiliary probing tree
* @author Gregor Hendel
*
* Randomized LP rounding uses a random variable from a uniform distribution
* over [0,1] to determine whether the fractional LP value x should be rounded
* up with probability x - floor(x) or down with probability ceil(x) - x.
*
* This implementation uses domain propagation techniques to tighten the variable domains after every
* rounding step.
*
* @see: The most relevant publication is Raghavan & Thompson,
* "Randomized rounding: A technique for provably good algorithms and algorithmic proofs",
* Combinatorica 7 (4): 365–374
* 1987
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_HEUR_RANDROUNDING_H__
#define __SCIP_HEUR_RANDROUNDING_H__
#include "scip/def.h"
#include "scip/type_retcode.h"
#include "scip/type_scip.h"
#ifdef __cplusplus
extern "C" {
#endif
/** creates the rand rounding heuristic and includes it in SCIP
*
* @ingroup PrimalHeuristicIncludes
*/
SCIP_EXPORT
SCIP_RETCODE SCIPincludeHeurRandrounding(
SCIP* scip /**< SCIP data structure */
);
#ifdef __cplusplus
}
#endif
#endif
libs/or-tools-src-ubuntu/include/scip/heur_rens.h 0 → 100644
View file @ a9bd42a2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file heur_rens.h
* @ingroup PRIMALHEURISTICS
* @brief LNS heuristic that finds the optimal rounding to a given point
* @author Timo Berthold
*
* RENS is a large neighborhood search start heuristic, i.e., unlike other LNS heuristics, it does not need a known
* feasible solution. It solves a sub-SCIP that is created by fixing variables which take an integral value in a given
* LP or NLP solution. For the remaining integer variables, the bounds get tightened to the two nearest integral values.
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_HEUR_RENS_H__
#define __SCIP_HEUR_RENS_H__
#include "scip/def.h"
#include "scip/type_heur.h"
#include "scip/type_result.h"
#include "scip/type_retcode.h"
#include "scip/type_scip.h"
#ifdef __cplusplus
extern "C" {
#endif
/** creates RENS primal heuristic and includes it in SCIP
*
* @ingroup PrimalHeuristicIncludes
*/
SCIP_EXPORT
SCIP_RETCODE SCIPincludeHeurRens(
SCIP* scip /**< SCIP data structure */
);
/**@addtogroup PRIMALHEURISTICS
*
* @{
*/
/** main procedure of the RNS heuristic, creates and solves a sub-SCIP */
SCIP_EXPORT
SCIP_RETCODE SCIPapplyRens(
SCIP* scip, /**< original SCIP data structure */
SCIP_HEUR* heur, /**< heuristic data structure */
SCIP_RESULT* result, /**< result data structure */
SCIP_Real minfixingrate, /**< minimum percentage of integer variables that have to be fixed */
SCIP_Real minimprove, /**< factor by which RENS should at least improve the incumbent */
SCIP_Longint maxnodes, /**< maximum number of nodes for the subproblem */
SCIP_Longint nstallnodes, /**< number of stalling nodes for the subproblem */
char startsol, /**< solution used for fixing values ('l'p relaxation, 'n'lp relaxation) */
SCIP_Bool binarybounds, /**< should general integers get binary bounds [floor(.),ceil(.)]? */
SCIP_Bool uselprows /**< should subproblem be created out of the rows in the LP rows? */
);
/** @} */
#ifdef __cplusplus
}
#endif
#endif
libs/or-tools-src-ubuntu/include/scip/heur_reoptsols.h 0 → 100644
View file @ a9bd42a2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2020 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file heur_reoptsols.h
* @ingroup PRIMALHEURISTICS
* @brief reoptsols primal heuristic
* @author Jakob Witzig
*
* template file for primal heuristic plugins
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_HEUR_REOPTSOLS_H__
#define __SCIP_HEUR_REOPTSOLS_H__
#include "scip/def.h"
#include "scip/type_retcode.h"
#include "scip/type_scip.h"
#ifdef __cplusplus
extern "C" {
#endif
/** creates the reoptsols primal heuristic and includes it in SCIP
*
* @ingroup PrimalHeuristicIncludes
*/
SCIP_EXPORT
SCIP_RETCODE SCIPincludeHeurReoptsols(
SCIP* scip /**< SCIP data structure */
);
/**@addtogroup PRIMALHEURISTICS
*
* @{
*/
/* returns the number of checked solutions */
SCIP_EXPORT
int SCIPreoptsolsGetNCheckedsols(
SCIP* scip
);
/* returns the number of found improving solutions */
SCIP_EXPORT
int SCIPreoptsolsGetNImprovingsols(
SCIP* scip
);
/** @} */
#ifdef __cplusplus
}
#endif
#endif